LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_argerror
LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
  lua_Debug ar;
  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
    return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
  lua_getinfo(L, "n", &ar);
  if (strcmp(ar.namewhat, "method") == 0) {
    narg--;  /* do not count `self' */
    if (narg == 0)  /* error is in the self argument itself? */
      return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
                           ar.name, extramsg);
  }
  if (ar.name == NULL)
    ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?";
  return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",
                        narg, ar.name, extramsg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
xorl %esi, %esi
callq 0xa530
testl %eax, %eax
je 0x8fbc
leaq 0x18ccb(%rip), %rsi     # 0x21c35
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0xa730
movq 0x10(%r15), %rdi
leaq 0x178af(%rip), %rsi     # 0x20834
callq 0x62e0
testl %eax, %eax
jne 0x8f92
decl %ebp
je 0x8fd4
cmpq $0x0, 0x10(%rsp)
jne 0x8ffb
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0x8fef
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x7bdc
jmp 0x8ff6
leaq 0x17475(%rip), %rsi     # 0x20438
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x9024
jmp 0x9016
movq 0x10(%rsp), %rdx
leaq 0x1746e(%rip), %rsi     # 0x2044e
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x9024
jmp 0x9016
leaq 0x17822(%rip), %rax     # 0x20818
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
leaq 0x17465(%rip), %rsi     # 0x2046c
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %r8
xorl %eax, %eax
callq 0x9024
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: pushglobalfuncname
static int pushglobalfuncname (lua_State *L, lua_Debug *ar) {
  int top = lua_gettop(L);
  lua_getinfo(L, "f", ar);  /* push function */
  lua_pushglobaltable(L);
  if (findfield(L, top + 1, 2)) {
    lua_copy(L, -1, top + 1);  /* move name to proper place */
    lua_pop(L, 2);  /* remove pushed values */
    return 1;
  }
  else {
    lua_settop(L, top);  /* remove function and global table */
    return 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x7683
movl %eax, %r14d
leaq 0x17493(%rip), %rsi     # 0x2058f
movq %rbx, %rdi
movq %r15, %rdx
callq 0xa730
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movl $0x2, %edx
callq 0x8145
leal 0x1(%r14), %ebp
movq %rbx, %rdi
movl %ebp, %esi
movl $0x2, %edx
callq 0xa3e8
testl %eax, %eax
je 0x914c
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %ebp, %edx
callq 0x784a
movl $0x1, %ebp
movl $0xfffffffd, %r14d      # imm = 0xFFFFFFFD
jmp 0x914e
xorl %ebp, %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x7697
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_execresult
LUALIB_API int luaL_execresult (lua_State *L, int stat) {
  const char *what = "exit";  /* type of termination */
  if (stat == -1)  /* error? */
    return luaL_fileresult(L, 0, NULL);
  else {
    inspectstat(stat, what);  /* interpret result */
    if (*what == 'e' && stat == 0)  /* successful termination? */
      lua_pushboolean(L, 1);
    else
      lua_pushnil(L);
    lua_pushstring(L, what);
    lua_pushinteger(L, stat);
    return 3;  /* return true/nil,what,code */
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
cmpl $-0x1, %esi
je 0x9297
movl %esi, %ebx
movl %esi, %eax
andl $0x7f, %eax
je 0x92a8
movl %eax, %ecx
shll $0x18, %ecx
addl $0x1000000, %ecx        # imm = 0x1000000
cmpl $0x2000000, %ecx        # imm = 0x2000000
cmovgel %eax, %ebx
leaq 0x17210(%rip), %rax     # 0x2049a
leaq 0x17204(%rip), %r14     # 0x20495
cmovgeq %rax, %r14
jmp 0x92b2
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x91d4
movzbl %bh, %ebx
leaq 0x171e3(%rip), %r14     # 0x20495
testl %ebx, %ebx
jne 0x92cb
cmpb $0x65, (%r14)
jne 0x92cb
movq %r15, %rdi
movl $0x1, %esi
callq 0x7fe1
jmp 0x92d3
movq %r15, %rdi
callq 0x7d5e
movq %r15, %rdi
movq %r14, %rsi
callq 0x7e16
movslq %ebx, %rsi
movq %r15, %rdi
callq 0x7d87
movl $0x3, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_newmetatable
LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
  luaL_getmetatable(L, tname);  /* try to get metatable */
  if (!lua_isnil(L, -1))  /* name already in use? */
    return 0;  /* leave previous value on top, but return 0 */
  lua_pop(L, 1);
  lua_newtable(L);  /* create metatable */
  lua_pushvalue(L, -1);
  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
callq 0x80bf
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7889
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x935b
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7697
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x81c0
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7869
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
callq 0x833f
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_checkoption
LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
                                 const char *const lst[]) {
  const char *name = (def) ? luaL_optstring(L, narg, def) :
                             luaL_checkstring(L, narg);
  int i;
  for (i=0; lst[i]; i++)
    if (strcmp(lst[i], name) == 0)
      return i;
  return luaL_argerror(L, narg,
                       lua_pushfstring(L, "invalid option " LUA_QS, name));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %esi, %ebx
movq %rdi, %r14
testq %rdx, %rdx
je 0x9496
movq %rdx, %r12
movq %r14, %rdi
movl %ebx, %esi
callq 0x7889
testl %eax, %eax
jle 0x94a5
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x9559
movq %rax, %r12
movq (%r15), %rdi
testq %rdi, %rdi
je 0x94c9
xorl %r13d, %r13d
movq %r12, %rsi
callq 0x62e0
testl %eax, %eax
je 0x94f3
movq 0x8(%r15,%r13,8), %rdi
incq %r13
testq %rdi, %rdi
jne 0x94b0
leaq 0x16fd1(%rip), %rsi     # 0x204a1
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x7eb0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8f3e
movl %r13d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_optlstring
LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,
                                        const char *def, size_t *len) {
  if (lua_isnoneornil(L, narg)) {
    if (len)
      *len = (def ? strlen(def) : 0);
    return def;
  }
  else return luaL_checklstring(L, narg, len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x7889
testl %eax, %eax
jle 0x9532
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9559
testq %rbx, %rbx
je 0x954b
testq %r14, %r14
je 0x9546
movq %r14, %rdi
callq 0x6170
jmp 0x9548
xorl %eax, %eax
movq %rax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_checkstack
LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) {
  /* keep some extra space to run error routines, if needed */
  const int extra = LUA_MINSTACK;
  if (!lua_checkstack(L, space + extra)) {
    if (msg)
      luaL_error(L, "stack overflow (%s)", msg);
    else
      luaL_error(L, "stack overflow");
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
addl $0x14, %esi
callq 0x7564
testl %eax, %eax
je 0x95b1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testq %r14, %r14
je 0x95d1
leaq 0x16ef8(%rip), %rsi     # 0x204b5
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9024
leaq 0x172ba(%rip), %rsi     # 0x20892
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9024
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_checknumber
LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
  int isnum;
  lua_Number d = lua_tonumberx(L, narg, &isnum);
  if (!isnum)
    tag_error(L, narg, LUA_TNUMBER);
  return d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rdx
callq 0x7ad5
cmpl $0x0, (%r15)
jne 0x9695
movq %r14, %rdi
movl $0x3, %esi
movsd %xmm0, (%rsp)
callq 0x78aa
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x942c
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_checkinteger
LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
  int isnum;
  lua_Integer d = lua_tointegerx(L, narg, &isnum);
  if (!isnum)
    tag_error(L, narg, LUA_TNUMBER);
  return d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4(%rsp), %r12
movq %r12, %rdx
callq 0x7b1d
movq %rax, %r15
cmpl $0x0, (%r12)
jne 0x9712
movq %r14, %rdi
movl $0x3, %esi
callq 0x78aa
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x942c
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_checkunsigned
LUALIB_API lua_Unsigned luaL_checkunsigned (lua_State *L, int narg) {
  int isnum;
  lua_Unsigned d = lua_tounsignedx(L, narg, &isnum);
  if (!isnum)
    tag_error(L, narg, LUA_TNUMBER);
  return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movq %r15, %rdx
callq 0x7b60
movl %eax, %ebp
cmpl $0x0, (%r15)
jne 0x975c
movq %r14, %rdi
movl $0x3, %esi
callq 0x78aa
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x942c
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_prepbuffsize
LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) {
  lua_State *L = B->L;
  if (B->size - B->n < sz) {  /* not enough space? */
    char *newbuff;
    size_t newsize = B->size * 2;  /* double buffer size */
    if (newsize - B->n < sz)  /* not big enough? */
      newsize = B->n + sz;
    if (newsize < B->n || newsize - B->n < sz)
      luaL_error(L, "buffer too large");
    /* create larger buffer */
    newbuff = (char *)lua_newuserdata(L, newsize * sizeof(char));
    /* move content to new buffer */
    memcpy(newbuff, B->b, B->n * sizeof(char));
    if (buffonstack(B))
      lua_remove(L, -2);  /* remove old buffer */
    B->b = newbuff;
    B->size = newsize;
  }
  return &B->b[B->n];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
movq %rcx, %rdx
subq %rax, %rdx
cmpq %rsi, %rdx
jae 0x9856
addq %rcx, %rcx
movq %rcx, %rdx
subq %rax, %rdx
leaq (%rax,%rsi), %r14
cmpq %rsi, %rdx
cmovaeq %rcx, %r14
movq 0x18(%rbx), %r15
movq %r14, %rcx
subq %rax, %rcx
setb %al
notb %al
cmpq %rsi, %rcx
setae %cl
testb %cl, %al
jne 0x981c
leaq 0x16cc6(%rip), %rsi     # 0x204d8
movq %r15, %rdi
xorl %eax, %eax
callq 0x9024
movq %r15, %rdi
movq %r14, %rsi
callq 0x8a40
movq %rax, %r12
movq (%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
callq 0x6360
leaq 0x20(%rbx), %rax
cmpq %rax, (%rbx)
je 0x984f
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x76e8
movq %r12, (%rbx)
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
addq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_pushresult
LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
  lua_State *L = B->L;
  lua_pushlstring(L, B->b, B->n);
  if (buffonstack(B))
    lua_remove(L, -2);  /* remove old buffer */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rbx
movq (%rdi), %rsi
movq 0x10(%rdi), %rdx
movq %rbx, %rdi
callq 0x7dc7
leaq 0x20(%r14), %rax
cmpq %rax, (%r14)
je 0x9907
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x76e8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_getmetafield
LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
  if (!lua_getmetatable(L, obj))  /* no metatable? */
    return 0;
  lua_pushstring(L, event);
  lua_rawget(L, -2);
  if (lua_isnil(L, -1)) {
    lua_pop(L, 2);  /* remove metatable and metafield */
    return 0;
  }
  else {
    lua_remove(L, -2);  /* remove only metatable */
    return 1;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %r14
callq 0x821f
xorl %ebx, %ebx
testl %eax, %eax
je 0x9e82
movq %r14, %rdi
movq %r15, %rsi
callq 0x7e16
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8119
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7889
movq %r14, %rdi
testl %eax, %eax
je 0x9e78
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x76e8
movl $0x1, %ebx
jmp 0x9e82
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x7697
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_callmeta
LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
  obj = lua_absindex(L, obj);
  if (!luaL_getmetafield(L, obj, event))  /* no metafield? */
    return 0;
  lua_pushvalue(L, obj);
  lua_call(L, 1, 1);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x7662
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x9e25
testl %eax, %eax
je 0x9ed4
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7869
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x85f1
jmp 0x9ed6
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_len
LUALIB_API int luaL_len (lua_State *L, int idx) {
  int l;
  int isnum;
  lua_len(L, idx);
  l = (int)lua_tointegerx(L, -1, &isnum);
  if (!isnum)
    luaL_error(L, "object length is not a number");
  lua_pop(L, 1);  /* remove object */
  return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x89fd
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x7b1d
movq %rax, %r14
cmpl $0x0, (%r15)
jne 0x9f1d
leaq 0x165e4(%rip), %rsi     # 0x204f7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9024
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7697
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_checkversion_
LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver) {
  const lua_Number *v = lua_version(L);
  if (v != lua_version(NULL))
    luaL_error(L, "multiple Lua VMs detected");
  else if (*v != ver)
    luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
                  ver, *v);
  /* check conversions number -> integer types */
  lua_pushnumber(L, -(lua_Number)0x1234);
  if (lua_tointeger(L, -1) != -0x1234 ||
      lua_tounsigned(L, -1) != (lua_Unsigned)-0x1234)
    luaL_error(L, "bad conversion number->int;"
                  " must recompile Lua with proper settings");
  lua_pop(L, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0x7649
movq %rax, %r14
xorl %edi, %edi
callq 0x7649
cmpq %rax, %r14
je 0xa0dd
leaq 0x16470(%rip), %rsi     # 0x20541
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9024
jmp 0xa100
movsd (%r14), %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm0, %xmm1
jne 0xa0ef
jnp 0xa100
leaq 0x16465(%rip), %rsi     # 0x2055b
movq %rbx, %rdi
movb $0x2, %al
callq 0x9024
movsd 0x162e8(%rip), %xmm0    # 0x203f0
movq %rbx, %rdi
callq 0x7d72
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x7b1d
cmpq $-0x1234, %rax          # imm = 0xEDCC
jne 0xa13d
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x7b60
cmpl $0xffffedcc, %eax       # imm = 0xFFFFEDCC
je 0xa14e
leaq 0x1644d(%rip), %rsi     # 0x20591
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9024
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7697
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_getsubtable
LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) {
  lua_getfield(L, idx, fname);
  if (lua_istable(L, -1)) return 1;  /* table already there */
  else {
    lua_pop(L, 1);  /* remove previous result */
    idx = lua_absindex(L, idx);
    lua_newtable(L);
    lua_pushvalue(L, -1);  /* copy to be left at top */
    lua_setfield(L, idx, fname);  /* assign new table to field */
    return 0;  /* false, because did not find table there */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x80bf
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7889
movl $0x1, %r15d
cmpl $0x5, %eax
je 0xa1d0
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7697
movq %r14, %rdi
movl %ebp, %esi
callq 0x7662
movl %eax, %ebp
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x81c0
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7869
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x833f
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_requiref
LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
                               lua_CFunction openf, int glb) {
  lua_pushcfunction(L, openf);
  lua_pushstring(L, modname);  /* argument to open function */
  lua_call(L, 1, 1);  /* open module */
  luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
  lua_pushvalue(L, -2);  /* make copy of module (call result) */
  lua_setfield(L, -2, modname);  /* _LOADED[modname] = module */
  lua_pop(L, 1);  /* remove _LOADED table */
  if (glb) {
    lua_pushvalue(L, -1);  /* copy of 'mod' */
    lua_setglobal(L, modname);  /* _G[modname] = module */
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
xorl %edx, %edx
callq 0x7f5d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7e16
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x85f1
leaq 0x1631c(%rip), %rdx     # 0x20539
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xa162
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7869
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %rbx, %rdx
callq 0x833f
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7697
testl %ebp, %ebp
je 0xa274
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7869
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x82a5
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: lua_setlocal
LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
  StkId pos = 0;  /* to avoid warnings */
  const char *name = findlocal(L, ar->i_ci, n, &pos);
  lua_lock(L);
  if (name)
    setobjs2s(L, pos, L->top - 1);
  L->top--;  /* pop value */
  lua_unlock(L);
  return name;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rcx
movq $0x0, (%rcx)
movq 0x78(%rsi), %rsi
callq 0xa5f8
testq %rax, %rax
je 0xa725
movq 0x10(%rbx), %rcx
movq 0x8(%rsp), %rdx
movq -0x10(%rcx), %rsi
movq %rsi, (%rdx)
movl -0x8(%rcx), %ecx
movl %ecx, 0x8(%rdx)
addq $-0x10, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: luaG_typeerror
l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
  CallInfo *ci = L->ci;
  const char *name = NULL;
  const char *t = objtypename(o);
  const char *kind = NULL;
  if (isLua(ci)) {
    kind = getupvalname(ci, o, &name);  /* check whether 'o' is an upvalue */
    if (!kind && isinstack(ci, o))  /* no? try a register */
      kind = getobjname(ci_func(ci)->p, currentpc(ci),
                        cast_int(o - ci->u.l.base), &name);
  }
  if (kind)
    luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)",
                op, kind, name, t);
  else
    luaG_runerror(L, "attempt to %s a %s value", op, t);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r15
movq 0x20(%rdi), %rax
movq $0x0, 0x8(%rsp)
movl 0x8(%rsi), %ecx
andl $0xf, %ecx
leaq 0x21cb1(%rip), %rsi     # 0x2c840
movq 0x8(%rsi,%rcx,8), %r14
testb $0x1, 0x22(%rax)
jne 0xaba1
xorl %ecx, %ecx
jmp 0xac50
movq (%rax), %rcx
movq (%rcx), %rsi
movzbl 0xa(%rsi), %r8d
movb $0x1, %dil
testq %r8, %r8
jne 0xabb8
xorl %ecx, %ecx
jmp 0xac03
shll $0x3, %r8d
xorl %ecx, %ecx
xorl %r9d, %r9d
movq 0x20(%rsi,%r9), %r10
cmpq %rdx, 0x10(%r10)
je 0xabd7
addq $0x8, %r9
cmpq %r9, %r8
jne 0xabc1
jmp 0xac03
movq 0x18(%rsi), %rcx
movq 0x38(%rcx), %rcx
movq (%rcx,%r9,2), %rcx
leaq 0x18(%rcx), %rdi
testq %rcx, %rcx
leaq 0x15c27(%rip), %rcx     # 0x20818
cmovneq %rdi, %rcx
movq %rcx, 0x8(%rsp)
leaq 0x17955(%rip), %rcx     # 0x22556
xorl %edi, %edi
testb %dil, %dil
je 0xac50
movq 0x8(%rax), %rdi
movq 0x30(%rax), %r8
cmpq %rdi, %r8
jae 0xab9a
xorl %ecx, %ecx
movq %r8, %r9
cmpq %rdx, %r9
je 0xac2a
addq $0x10, %r9
cmpq %rdi, %r9
jb 0xac1a
jmp 0xac50
movq 0x18(%rsi), %rdi
movq 0x38(%rax), %rsi
subq 0x18(%rdi), %rsi
shrq $0x2, %rsi
decl %esi
subq %r8, %rdx
shrq $0x4, %rdx
leaq 0x8(%rsp), %rcx
callq 0xac88
movq %rax, %rcx
testq %rcx, %rcx
jne 0xac6c
leaq 0x15b23(%rip), %rsi     # 0x2077f
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0xaf1a
movq 0x8(%rsp), %r8
leaq 0x15ae4(%rip), %rsi     # 0x2075c
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %r9
xorl %eax, %eax
callq 0xaf1a
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: luaG_runerror
l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
  va_list argp;
  va_start(argp, fmt);
  addinfo(L, luaO_pushvfstring(L, fmt, argp));
  va_end(argp);
  luaG_errormsg(L);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xaf75
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq %rbx, %rdi
callq 0x10a84
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb0c5
movq %rbx, %rdi
callq 0xb04b
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: luaG_ordererror
l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
  const char *t1 = objtypename(p1);
  const char *t2 = objtypename(p2);
  if (t1 == t2)
    luaG_runerror(L, "attempt to compare two %s values", t1);
  else
    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
}

// Assembly:
pushq %rax
movq %rdx, %rax
movl 0x8(%rsi), %ecx
andl $0xf, %ecx
leaq 0x21826(%rip), %rsi     # 0x2c840
movq 0x8(%rsi,%rcx,8), %rdx
movl 0x8(%rax), %eax
andl $0xf, %eax
movq 0x8(%rsi,%rax,8), %rcx
cmpq %rcx, %rdx
jne 0xb03d
leaq 0x15784(%rip), %rsi     # 0x207ba
xorl %eax, %eax
callq 0xaf1a
leaq 0x15797(%rip), %rsi     # 0x207db
xorl %eax, %eax
callq 0xaf1a
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: luaG_errormsg
l_noret luaG_errormsg (lua_State *L) {
  if (L->errfunc != 0) {  /* is there an error handling function? */
    StkId errfunc = restorestack(L, L->errfunc);
    if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR);
    setobjs2s(L, L->top, L->top - 1);  /* move argument */
    setobjs2s(L, L->top - 1, errfunc);  /* push function */
    L->top++;
    luaD_call(L, L->top - 2, 1, 0);  /* call it */
  }
  luaD_throw(L, LUA_ERRRUN);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rax
testq %rax, %rax
je 0xb0ab
movq 0x38(%rbx), %rcx
movl 0x8(%rcx,%rax), %edx
andl $0xf, %edx
cmpl $0x6, %edx
jne 0xb0b8
movq 0x10(%rbx), %rdx
movq -0x10(%rdx), %rsi
movq %rsi, (%rdx)
movl -0x8(%rdx), %esi
movl %esi, 0x8(%rdx)
movq 0x10(%rbx), %rdx
movq (%rcx,%rax), %rsi
movq %rsi, -0x10(%rdx)
movl 0x8(%rcx,%rax), %eax
movl %eax, -0x8(%rdx)
movq 0x10(%rbx), %rsi
leaq 0x10(%rsi), %rax
movq %rax, 0x10(%rbx)
addq $-0x10, %rsi
movq %rbx, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0xb9c9
movq %rbx, %rdi
movl $0x2, %esi
callq 0xb1b4
movq %rbx, %rdi
movl $0x6, %esi
callq 0xb1b4
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: addinfo
static void addinfo (lua_State *L, const char *msg) {
  CallInfo *ci = L->ci;
  if (isLua(ci)) {  /* is Lua code? */
    char buff[LUA_IDSIZE];  /* add file:line information */
    int line = currentline(ci);
    TString *src = ci_func(ci)->p->source;
    if (src)
      luaO_chunkid(buff, getstr(src), LUA_IDSIZE);
    else {  /* no source available; use "?" instead */
      buff[0] = '?'; buff[1] = '\0';
    }
    luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
  }
}

// Assembly:
movq 0x20(%rdi), %rdx
testb $0x1, 0x22(%rdx)
je 0xb15b
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rcx
testq %rcx, %rcx
je 0xb116
movq 0x38(%rdx), %rdx
subq 0x18(%rax), %rdx
shlq $0x1e, %rdx
movabsq $-0x100000000, %rsi     # imm = 0xFFFFFFFF00000000
addq %rdx, %rsi
sarq $0x20, %rsi
movl (%rcx,%rsi,4), %ebp
jmp 0xb118
xorl %ebp, %ebp
movq 0x48(%rax), %rsi
testq %rsi, %rsi
je 0xb134
addq $0x18, %rsi
movq %rsp, %rdi
movl $0x3c, %edx
callq 0x10e12
jmp 0xb13a
movw $0x3f, (%rsp)
leaq 0x15715(%rip), %rsi     # 0x20856
movq %rsp, %rdx
movq %r14, %rdi
movl %ebp, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x10d8e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: luaD_throw
l_noret luaD_throw (lua_State *L, int errcode) {
  if (L->errorJmp) {  /* thread has an error handler? */
    L->errorJmp->status = errcode;  /* set status */
    LUAI_THROW(L, L->errorJmp);  /* jump to it */
  }
  else {  /* thread has no error handler */
    L->status = cast_byte(errcode);  /* mark it as dead */
    if (G(L)->mainthread->errorJmp) {  /* main thread has a handler? */
      setobjs2s(L, G(L)->mainthread->top++, L->top - 1);  /* copy error obj. */
      luaD_throw(G(L)->mainthread, errcode);  /* re-throw in main thread */
    }
    else {  /* no handler at all; abort */
      if (G(L)->panic) {  /* panic function? */
        lua_unlock(L);
        G(L)->panic(L);  /* call it (last chance to jump out) */
      }
      abort();
    }
  }
}

// Assembly:
pushq %rax
movq 0x70(%rdi), %rax
testq %rax, %rax
jne 0xb1e7
movb %sil, 0xa(%rdi)
movq 0x18(%rdi), %rcx
movq 0x108(%rcx), %rax
cmpq $0x0, 0x70(%rax)
jne 0xb1fe
movq 0x100(%rcx), %rax
testq %rax, %rax
je 0xb1e2
callq *%rax
callq 0x6070
movl %esi, 0xd0(%rax)
addq $0x8, %rax
movq %rax, %rdi
movl $0x1, %esi
callq 0x6460
movq 0x10(%rdi), %rcx
movq 0x10(%rax), %rdx
leaq 0x10(%rdx), %r8
movq %r8, 0x10(%rax)
movq -0x10(%rcx), %rax
movq %rax, (%rdx)
movl -0x8(%rcx), %eax
movl %eax, 0x8(%rdx)
movq 0x18(%rdi), %rax
movq 0x108(%rax), %rdi
callq 0xb1b4
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: luaD_shrinkstack
static int stackinuse (lua_State *L) {
  CallInfo *ci;
  StkId lim = L->top;
  for (ci = L->ci; ci != NULL; ci = ci->previous) {
    lua_assert(ci->top <= L->stack_last);
    if (lim < ci->top) lim = ci->top;
  }
  return cast_int(lim - L->stack) + 1;  /* part of stack in use */
}

// Assembly:
movq 0x10(%rdi), %rax
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0xb510
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rcx
cmpq %rdx, %rax
cmovbq %rdx, %rax
jmp 0xb4fa
subq 0x38(%rdi), %rax
shrq $0x4, %rax
leal 0x1(%rax), %ecx
leal 0x8(%rax), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
sarl $0x3, %edx
leal (%rdx,%rax), %ecx
incl %ecx
movl $0xf4236, %esi          # imm = 0xF4236
cmpl %esi, %ecx
cmovll %ecx, %esi
cmpl $0xf423f, %eax          # imm = 0xF423F
jg 0xb548
addl $0xa, %esi
cmpl 0x40(%rdi), %esi
jl 0xb295
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: luaD_poscall
int luaD_poscall (lua_State *L, StkId firstResult) {
  StkId res;
  int wanted, i;
  CallInfo *ci = L->ci;
  if (L->hookmask & (LUA_MASKRET | LUA_MASKLINE)) {
    if (L->hookmask & LUA_MASKRET) {
      ptrdiff_t fr = savestack(L, firstResult);  /* hook may change stack */
      luaD_hook(L, LUA_HOOKRET, -1);
      firstResult = restorestack(L, fr);
    }
    L->oldpc = ci->previous->u.l.savedpc;  /* 'oldpc' for caller function */
  }
  res = ci->func;  /* res == final position of 1st result */
  wanted = ci->nresults;
  L->ci = ci = ci->previous;  /* back to caller */
  /* move results to correct place */
  for (i = wanted; i != 0 && firstResult < L->top; i--)
    setobjs2s(L, res++, firstResult++);
  while (i-- > 0)
    setnilvalue(res++);
  L->top = res;
  return (wanted - LUA_MULTRET);  /* 0 iff wanted == LUA_MULTRET */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %r15
movzbl 0x48(%rdi), %eax
testb $0x6, %al
je 0xb966
testb $0x2, %al
je 0xb95a
subq 0x38(%rbx), %r14
movq %rbx, %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xb549
addq 0x38(%rbx), %r14
movq 0x10(%r15), %rax
movq 0x38(%rax), %rax
movq %rax, 0x28(%rbx)
movq (%r15), %rsi
movq 0x10(%r15), %rcx
movswl 0x20(%r15), %eax
movq %rcx, 0x20(%rbx)
movl %eax, %ecx
testl %eax, %eax
je 0xb9a2
cmpq 0x10(%rbx), %r14
jae 0xb9a2
leaq 0x10(%rsi), %rdx
movq (%r14), %rdi
movq %rdi, (%rsi)
movl 0x8(%r14), %edi
movl %edi, 0x8(%rsi)
addq $0x10, %r14
movq %rdx, %rsi
decl %ecx
jne 0xb97c
xorl %ecx, %ecx
jmp 0xb9a5
movq %rsi, %rdx
testl %ecx, %ecx
jle 0xb9bd
incl %ecx
movl $0x0, 0x8(%rdx)
addq $0x10, %rdx
decl %ecx
cmpl $0x1, %ecx
jg 0xb9ab
movq %rdx, 0x10(%rbx)
incl %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: luaD_call
void luaD_call (lua_State *L, StkId func, int nResults, int allowyield) {
  if (++L->nCcalls >= LUAI_MAXCCALLS) {
    if (L->nCcalls == LUAI_MAXCCALLS)
      luaG_runerror(L, "C stack overflow");
    else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
      luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
  }
  if (!allowyield) L->nny++;
  if (!luaD_precall(L, func, nResults))  /* is a Lua function? */
    luaV_execute(L);  /* call it */
  if (!allowyield) L->nny--;
  L->nCcalls--;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdi, %rbx
movzwl 0x46(%rdi), %eax
incl %eax
movw %ax, 0x46(%rdi)
movzwl %ax, %eax
cmpl $0xc8, %eax
jb 0xb9ee
je 0xba1d
cmpl $0xe1, %eax
jae 0xba2e
testl %ebp, %ebp
jne 0xb9f6
incw 0x44(%rbx)
movq %rbx, %rdi
callq 0xb5f9
testl %eax, %eax
jne 0xba0a
movq %rbx, %rdi
callq 0x196ba
testl %ebp, %ebp
jne 0xba12
decw 0x44(%rbx)
decw 0x46(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x14e6c(%rip), %rsi     # 0x20890
movq %rbx, %rdi
xorl %eax, %eax
callq 0xaf1a
movq %rbx, %rdi
movl $0x6, %esi
callq 0xb1b4
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: lua_resume
LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) {
  int status;
  int oldnny = L->nny;  /* save 'nny' */
  lua_lock(L);
  luai_userstateresume(L, nargs);
  L->nCcalls = (from) ? from->nCcalls + 1 : 1;
  L->nny = 0;  /* allow yields */
  api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs);
  status = luaD_rawrunprotected(L, resume, L->top - nargs);
  if (status == -1)  /* error calling 'lua_resume'? */
    status = LUA_ERRRUN;
  else {  /* yield or regular error */
    while (status != LUA_OK && status != LUA_YIELD) {  /* error? */
      if (recover(L, status))  /* recover point? */
        status = luaD_rawrunprotected(L, unroll, NULL);  /* run continuation */
      else {  /* unrecoverable error */
        L->status = cast_byte(status);  /* mark thread as `dead' */
        seterrorobj(L, status, L->top);
        L->ci->top = L->top;
        break;
      }
    }
    lua_assert(status == L->status);
  }
  L->nny = oldnny;  /* restore 'nny' */
  L->nCcalls--;
  lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));
  lua_unlock(L);
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xba56
movzwl 0x46(%rsi), %eax
incl %eax
jmp 0xba5a
movw $0x1, %ax
movzwl 0x44(%rbx), %r12d
movw %ax, 0x46(%rbx)
movw $0x0, 0x44(%rbx)
movq 0x10(%rbx), %rax
movslq %edx, %rcx
shlq $0x4, %rcx
subq %rcx, %rax
leaq 0xe3(%rip), %rsi        # 0xbb61
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb22b
cmpl $-0x1, %eax
je 0xbb22
movl %eax, %ebp
cmpl $0x2, %eax
jb 0xbb47
leaq 0x190(%rip), %r14       # 0xbc34
movq 0x20(%rbx), %r13
testq %r13, %r13
je 0xbaba
testb $0x10, 0x22(%r13)
jne 0xbabd
movq 0x10(%r13), %r13
jmp 0xbaa8
xorl %r13d, %r13d
testq %r13, %r13
je 0xbb29
movq 0x38(%rbx), %r15
addq 0x28(%r13), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc68c
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0xbcce
movq %r13, 0x20(%rbx)
movb 0x48(%r13), %al
movb %al, 0x49(%rbx)
movw $0x0, 0x44(%rbx)
movq %rbx, %rdi
callq 0xb4f2
movq 0x40(%r13), %rax
movq %rax, 0x78(%rbx)
orb $0x20, 0x22(%r13)
movb %bpl, 0x49(%r13)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xb22b
movl %eax, %ebp
cmpl $0x1, %eax
ja 0xbaa4
jmp 0xbb47
movl $0x2, %ebp
jmp 0xbb47
movb %bpl, 0xa(%rbx)
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xbcce
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rax, 0x8(%rcx)
movw %r12w, 0x44(%rbx)
decw 0x46(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: resume
static void resume (lua_State *L, void *ud) {
  int nCcalls = L->nCcalls;
  StkId firstArg = cast(StkId, ud);
  CallInfo *ci = L->ci;
  if (nCcalls >= LUAI_MAXCCALLS)
    resume_error(L, "C stack overflow", firstArg);
  if (L->status == LUA_OK) {  /* may be starting a coroutine */
    if (ci != &L->base_ci)  /* not in base level? */
      resume_error(L, "cannot resume non-suspended coroutine", firstArg);
    /* coroutine is in base level; start running it */
    if (!luaD_precall(L, firstArg - 1, LUA_MULTRET))  /* Lua function? */
      luaV_execute(L);  /* call it */
  }
  else if (L->status != LUA_YIELD)
    resume_error(L, "cannot resume dead coroutine", firstArg);
  else {  /* resuming from previous yield */
    L->status = LUA_OK;
    ci->func = restorestack(L, ci->extra);
    if (isLua(ci))  /* yielded inside a hook? */
      luaV_execute(L);  /* just continue running Lua code */
    else {  /* 'common' yield */
      if (ci->u.c.k != NULL) {  /* does it have a continuation? */
        int n;
        ci->u.c.status = LUA_YIELD;  /* 'default' status */
        ci->callstatus |= CIST_YIELDED;
        lua_unlock(L);
        n = (*ci->u.c.k)(L);  /* call continuation */
        lua_lock(L);
        api_checknelems(L, n);
        firstArg = L->top - n;  /* yield results come from continuation */
      }
      luaD_poscall(L, firstArg);  /* finish 'luaD_precall' */
    }
    unroll(L, NULL);
  }
  lua_assert(nCcalls == L->nCcalls);
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
cmpw $0xc8, 0x46(%rdi)
jae 0xbc13
movq 0x20(%rbx), %rax
movzbl 0xa(%rbx), %ecx
cmpl $0x1, %ecx
je 0xbbb3
testl %ecx, %ecx
jne 0xbc1c
leaq 0x80(%rbx), %rcx
cmpq %rcx, %rax
jne 0xbc25
addq $-0x10, %rdx
movq %rbx, %rdi
movq %rdx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xb5f9
testl %eax, %eax
je 0xbc0a
popq %rbx
retq
movb $0x0, 0xa(%rbx)
movq 0x38(%rbx), %rcx
addq 0x28(%rax), %rcx
movq %rcx, (%rax)
movb 0x22(%rax), %cl
testb $0x1, %cl
jne 0xbbfc
movq 0x38(%rax), %rsi
testq %rsi, %rsi
je 0xbbef
movb $0x1, 0x49(%rax)
orb $0x8, %cl
movb %cl, 0x22(%rax)
movq %rbx, %rdi
callq *%rsi
movq 0x10(%rbx), %rdx
cltq
shlq $0x4, %rax
subq %rax, %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xb925
jmp 0xbc04
movq %rbx, %rdi
callq 0x196ba
movq %rbx, %rdi
popq %rbx
jmp 0xbc34
movq %rbx, %rdi
popq %rbx
jmp 0x196ba
leaq 0x14c76(%rip), %rsi     # 0x20890
jmp 0xbc2c
leaq 0x14cf8(%rip), %rsi     # 0x2091b
jmp 0xbc2c
leaq 0x14cc9(%rip), %rsi     # 0x208f5
movq %rbx, %rdi
callq 0xbfcd
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: unroll
static void unroll (lua_State *L, void *ud) {
  UNUSED(ud);
  for (;;) {
    if (L->ci == &L->base_ci)  /* stack is empty? */
      return;  /* coroutine finished normally */
    if (!isLua(L->ci))  /* C function? */
      finishCcall(L);
    else {  /* Lua function */
      luaV_finishOp(L);  /* finish interrupted instruction */
      luaV_execute(L);  /* execute down to higher C 'boundary' */
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x80(%rdi), %r14
movq 0x20(%rdi), %rax
cmpq %r14, %rax
je 0xbcc6
movq %rdi, %rbx
movb 0x22(%rax), %cl
testb $0x1, %cl
jne 0xbcad
testb $0x10, %cl
je 0xbc66
andb $-0x12, %cl
movb %cl, 0x22(%rax)
movq 0x40(%rax), %rcx
movq %rcx, 0x78(%rbx)
cmpw $-0x1, 0x20(%rax)
jne 0xbc7b
movq 0x10(%rbx), %rcx
cmpq %rcx, 0x8(%rax)
jae 0xbc7b
movq %rcx, 0x8(%rax)
movb 0x22(%rax), %cl
testb $0x20, %cl
jne 0xbc87
movb $0x1, 0x49(%rax)
andb $-0x39, %cl
orb $0x8, %cl
movb %cl, 0x22(%rax)
movq %rbx, %rdi
callq *0x38(%rax)
movq 0x10(%rbx), %rsi
cltq
shlq $0x4, %rax
subq %rax, %rsi
movq %rbx, %rdi
callq 0xb925
jmp 0xbcbd
movq %rbx, %rdi
callq 0x1955d
movq %rbx, %rdi
callq 0x196ba
movq 0x20(%rbx), %rax
cmpq %r14, %rax
jne 0xbc4b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: f_parser
static void f_parser (lua_State *L, void *ud) {
  int i;
  Closure *cl;
  struct SParser *p = cast(struct SParser *, ud);
  int c = zgetc(p->z);  /* read first character */
  if (c == LUA_SIGNATURE[0]) {
    checkmode(L, p->mode, "binary");
    cl = luaU_undump(L, p->z, &p->buff, p->name);
  }
  else {
    checkmode(L, p->mode, "text");
    cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
  }
  lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues);
  for (i = 0; i < cl->l.nupvalues; i++) {  /* initialize upvalues */
    UpVal *up = luaF_newupval(L);
    cl->l.upvals[i] = up;
    luaC_objbarrier(L, cl, up);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
subq $0x1, (%rdi)
jae 0xbf1a
callq 0x1aa60
movl %eax, %ebp
jmp 0xbf29
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %ebp
leaq 0x8(%r14), %r15
movq 0x50(%r14), %rsi
cmpl $0x1b, %ebp
jne 0xbf59
leaq 0x14a13(%rip), %rdx     # 0x20950
movq %rbx, %rdi
callq 0xbfff
movq (%r14), %rsi
movq 0x58(%r14), %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x181c0
jmp 0xbf81
leaq 0x149f7(%rip), %rdx     # 0x20957
movq %rbx, %rdi
callq 0xbfff
leaq 0x20(%r14), %rcx
movq (%r14), %rsi
movq 0x58(%r14), %r8
movq %rbx, %rdi
movq %r15, %rdx
movl %ebp, %r9d
callq 0x11790
movq %rax, %r14
cmpb $0x0, 0xa(%rax)
je 0xbfc2
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0xc5ac
movq %rax, 0x20(%r14,%r15,8)
testb $0x3, 0x9(%rax)
je 0xbfb5
testb $0x4, 0x9(%r14)
je 0xbfb5
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xc83c
incq %r15
movzbl 0xa(%r14), %eax
cmpq %rax, %r15
jb 0xbf8d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: checkmode
static void checkmode (lua_State *L, const char *mode, const char *x) {
  if (mode && strchr(mode, x[0]) == NULL) {
    luaO_pushfstring(L,
       "attempt to load a %s chunk (mode is " LUA_QS ")", x, mode);
    luaD_throw(L, LUA_ERRSYNTAX);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xc022
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsbl (%rdx), %esi
movq %r14, %rdi
callq 0x6190
testq %rax, %rax
je 0xc028
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1492d(%rip), %rsi     # 0x2095c
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x10d8e
movq %rbx, %rdi
movl $0x3, %esi
callq 0xb1b4
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldump.c
// Function: luaU_dump
int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
{
 DumpState D;
 D.L=L;
 D.writer=w;
 D.data=data;
 D.strip=strip;
 D.status=0;
 DumpHeader(&D);
 DumpFunction(f,&D);
 return D.status;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, (%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0x18(%rsp)
movl $0x0, 0x1c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x188e9
cmpl $0x0, 0x1c(%rsp)
jne 0xc09d
movq (%rsp), %rdi
movq 0x10(%rsp), %rcx
leaq 0x20(%rsp), %rsi
movl $0x12, %edx
callq *0x8(%rsp)
movl %eax, 0x1c(%rsp)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc0b7
movl 0x1c(%r14), %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldump.c
// Function: DumpString
static void DumpString(const TString* s, DumpState* D)
{
 if (s==NULL)
 {
  size_t size=0;
  DumpVar(size,D);
 }
 else
 {
  size_t size=s->tsv.len+1;		/* include trailing '\0' */
  DumpVar(size,D);
  DumpBlock(getstr(s),size*sizeof(char),D);
 }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0xc4fc
movq %rdi, %r14
movq 0x10(%rdi), %rax
incq %rax
movq %rax, (%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0xc4e2
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %rsp, %rsi
movl $0x8, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
cmpl $0x0, 0x1c(%rbx)
jne 0xc51f
movq (%rsp), %rdx
addq $0x18, %r14
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %r14, %rsi
jmp 0xc519
movq $0x0, (%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0xc51f
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %rsp, %rsi
movl $0x8, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lfunc.c
// Function: luaF_newLclosure
Closure *luaF_newLclosure (lua_State *L, int n) {
  Closure *c = &luaC_newobj(L, LUA_TLCL, sizeLclosure(n), NULL, 0)->cl;
  c->l.p = NULL;
  c->l.nupvalues = cast_byte(n);
  while (n--) c->l.upvals[n] = NULL;
  return c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
leal 0x20(,%rbx,8), %eax
movslq %eax, %rdx
movl $0x6, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xca0d
movq %rax, %r14
movq $0x0, 0x18(%rax)
movb %bl, 0xa(%rax)
testl %ebx, %ebx
je 0xc5a1
leal -0x1(%rbx), %eax
movslq %eax, %rcx
shlq $0x3, %rcx
shlq $0x3, %rax
subq %rax, %rcx
leaq (%rcx,%r14), %rdi
addq $0x20, %rdi
movl %ebx, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x61f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lfunc.c
// Function: luaF_newupval
UpVal *luaF_newupval (lua_State *L) {
  UpVal *uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), NULL, 0)->uv;
  uv->v = &uv->u.value;
  setnilvalue(uv->v);
  return uv;
}

// Assembly:
pushq %rax
movl $0x28, %edx
movl $0xa, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xca0d
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x20(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lfunc.c
// Function: luaF_findupval
UpVal *luaF_findupval (lua_State *L, StkId level) {
  global_State *g = G(L);
  GCObject **pp = &L->openupval;
  UpVal *p;
  UpVal *uv;
  while (*pp != NULL && (p = gco2uv(*pp))->v >= level) {
    GCObject *o = obj2gco(p);
    lua_assert(p->v != &p->u.value);
    lua_assert(!isold(o) || isold(obj2gco(L)));
    if (p->v == level) {  /* found a corresponding upvalue? */
      if (isdead(g, o))  /* is it dead? */
        changewhite(o);  /* resurrect it */
      return p;
    }
    pp = &p->next;
  }
  /* not found: create a new one */
  uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), pp, 0)->uv;
  uv->v = level;  /* current value lives in the stack */
  uv->u.l.prev = &g->uvhead;  /* double link it in `uvhead' list */
  uv->u.l.next = g->uvhead.u.l.next;
  uv->u.l.next->u.l.prev = uv;
  g->uvhead.u.l.next = uv;
  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
  return uv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rdi), %r14
leaq 0x60(%rdi), %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0xc61f
movq 0x10(%rax), %rdx
cmpq %rbx, %rdx
jb 0xc61f
je 0xc5fc
movq %rax, %rcx
movq %rsi, %rax
jmp 0xc615
movb 0x9(%rax), %sil
xorb $0x3, %sil
movb 0x54(%r14), %r8b
xorb $0x3, %r8b
testb %sil, %r8b
jne 0xc615
movb %sil, 0x9(%rax)
movq %rax, %rsi
cmpq %rbx, %rdx
jne 0xc5e1
jmp 0xc656
movl $0x28, %edx
movl $0xa, %esi
xorl %r8d, %r8d
callq 0xca0d
movq %rbx, 0x10(%rax)
leaq 0xb0(%r14), %rcx
movq %rcx, 0x18(%rax)
movq 0xd0(%r14), %rcx
movq %rcx, 0x20(%rax)
movq %rax, 0x18(%rcx)
movq %rax, 0xd0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq