LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_pow
static int math_pow (lua_State *L) {
  lua_Number x = luaL_checknumber(L, 1);
  lua_Number y = luaL_checknumber(L, 2);
  lua_pushnumber(L, l_mathop(pow)(x, y));
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x9364
movsd %xmm0, (%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x9364
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x6140
movq %rbx, %rdi
callq 0x7adc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_random
static int math_random (lua_State *L) {
  /* the `%' avoids the (rare) case of r==1, and is needed also because on
     some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
  lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX;
  switch (lua_gettop(L)) {  /* check number of arguments */
    case 0: {  /* no arguments */
      lua_pushnumber(L, r);  /* Number between 0 and 1 */
      break;
    }
    case 1: {  /* only upper limit */
      lua_Number u = luaL_checknumber(L, 1);
      luaL_argcheck(L, (lua_Number)1.0 <= u, 1, "interval is empty");
      lua_pushnumber(L, l_mathop(floor)(r*u) + (lua_Number)(1.0));  /* [1, u] */
      break;
    }
    case 2: {  /* lower and upper limits */
      lua_Number l = luaL_checknumber(L, 1);
      lua_Number u = luaL_checknumber(L, 2);
      luaL_argcheck(L, l <= u, 2, "interval is empty");
      lua_pushnumber(L, l_mathop(floor)(r*(u-l+1)) + l);  /* [l, u] */
      break;
    }
    default: return luaL_error(L, "wrong number of arguments");
  }
  return 1;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x65c0
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cltd
idivl %ecx
cvtsi2sd %edx, %xmm0
divsd 0x10128(%rip), %xmm0    # 0x1ec20
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x7423
cmpl $0x2, %eax
je 0xeb76
cmpl $0x1, %eax
je 0xeb26
testl %eax, %eax
jne 0xebf0
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
jmp 0xebe2
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x9364
movapd %xmm0, %xmm1
ucomisd 0x100eb(%rip), %xmm0    # 0x1ec28
jae 0xeb5d
leaq 0x10176(%rip), %rdx     # 0x1ecbc
pushq $0x1
popq %rsi
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0x8c84
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
callq 0x64f0
addsd 0x100b4(%rip), %xmm0    # 0x1ec28
jmp 0xebdf
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x9364
movsd %xmm0, 0x8(%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x9364
movapd %xmm0, %xmm1
ucomisd 0x8(%rsp), %xmm0
jae 0xebbc
leaq 0x10117(%rip), %rdx     # 0x1ecbc
pushq $0x2
popq %rsi
movq %rbx, %rdi
movsd %xmm1, 0x18(%rsp)
callq 0x8c84
movsd 0x18(%rsp), %xmm1
subsd 0x8(%rsp), %xmm1
addsd 0x1005e(%rip), %xmm1    # 0x1ec28
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
callq 0x64f0
addsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x7adc
pushq $0x1
popq %rax
addq $0x20, %rsp
popq %rbx
retq
leaq 0x100d7(%rip), %rsi     # 0x1ecce
movq %rbx, %rdi
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
jmp 0x8d68
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmem.c
// Function: luaM_realloc_
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
  void *newblock;
  global_State *g = G(L);
  size_t realosize = (block) ? osize : 0;
  lua_assert((realosize == 0) == (block == NULL));
#if defined(HARDMEMTESTS)
  if (nsize > realosize && g->gcrunning)
    luaC_fullgc(L, 1);  /* force a GC whenever possible */
#endif
  newblock = (*g->frealloc)(g->ud, block, osize, nsize);
  if (newblock == NULL && nsize > 0) {
    api_check(L, nsize > realosize,
                 "realloc cannot fail when shrinking a block");
    if (g->gcrunning) {
      luaC_fullgc(L, 1);  /* try to free some memory... */
      newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
    }
    if (newblock == NULL)
      luaD_throw(L, LUA_ERRMEM);
  }
  lua_assert((nsize == 0) == (newblock == NULL));
  g->GCdebt = (g->GCdebt + nsize) - realosize;
  return newblock;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rdi), %r13
movq 0x8(%r13), %rdi
callq *(%r13)
testq %rbx, %rbx
je 0xedc6
testq %rax, %rax
jne 0xedc6
cmpb $0x0, 0x57(%r13)
je 0xedde
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0xcd65
movq 0x8(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *(%r13)
testq %rax, %rax
je 0xedde
testq %r15, %r15
cmoveq %r15, %r14
subq %r14, %rbx
addq %rbx, 0x18(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x4
popq %rsi
movq %r12, %rdi
callq 0xad18
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: gctm
static int gctm (lua_State *L) {
  int n = luaL_len(L, 1);
  for (; n >= 1; n--) {  /* for each handle, in reverse order */
    lua_rawgeti(L, 1, n);  /* get handle CLIBS[n] */
    ll_unloadlib(lua_touserdata(L, -1));
    lua_pop(L, 1);  /* pop handle */
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x9b70
movl %eax, %r14d
pushq $-0x1
popq %r15
pushq $-0x2
popq %r12
testl %r14d, %r14d
jle 0xf024
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7e9f
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7a37
movq %rax, %rdi
callq 0x6580
movq %rbx, %rdi
movl %r12d, %esi
callq 0x7437
decl %r14d
jmp 0xefef
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: ll_loadfunc
static int ll_loadfunc (lua_State *L, const char *path, const char *sym) {
  void *reg = ll_checkclib(L, path);  /* check loaded C libraries */
  if (reg == NULL) {  /* must load library? */
    reg = ll_load(L, path, *sym == '*');
    if (reg == NULL) return ERRLIB;  /* unable to load library */
    ll_addtoclib(L, path, reg);
  }
  if (*sym == '*') {  /* loading only library (no function)? */
    lua_pushboolean(L, 1);  /* return 'true' */
    return 0;  /* no errors */
  }
  else {
    lua_CFunction f = ll_sym(L, reg, sym);
    if (f == NULL)
      return ERRFUNC;  /* unable to find function */
    lua_pushcfunction(L, f);  /* else create new function */
    return 0;  /* no errors */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xfb0c(%rip), %rdx      # 0x1ed29
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x7e19
pushq $-0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x7e19
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7a37
movq %rax, %r12
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x7437
testq %r12, %r12
jne 0xf2d8
xorl %esi, %esi
cmpb $0x2a, (%r14)
sete %sil
shll $0x8, %esi
orl $0x2, %esi
movq %r15, %rdi
callq 0x62f0
testq %rax, %rax
je 0xf322
movq %rax, %r12
leaq 0xfaa6(%rip), %rdx      # 0x1ed29
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x7e19
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7d57
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x7604
pushq $-0x3
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x809d
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9b70
leal 0x1(%rax), %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8172
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7437
cmpb $0x2a, (%r14)
jne 0xf2ed
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x7d3d
xorl %ebp, %ebp
jmp 0xf335
movq %r12, %rdi
movq %r14, %rsi
callq 0x64d0
testq %rax, %rax
je 0xf30e
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x7cba
jmp 0xf335
callq 0x6050
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7b76
pushq $0x2
jmp 0xf334
callq 0x6050
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7b76
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: searcher_preload
static int searcher_preload (lua_State *L) {
  const char *name = luaL_checkstring(L, 1);
  lua_getfield(L, LUA_REGISTRYINDEX, "_PRELOAD");
  lua_getfield(L, -1, name);
  if (lua_isnil(L, -1))  /* not found? */
    lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x9264
movq %rax, %r14
leaq 0xf598(%rip), %rdx      # 0x1ea35
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x7e19
pushq $-0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x7e19
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7624
testl %eax, %eax
jne 0xf4dc
leaq 0xf9b8(%rip), %rsi      # 0x1ee87
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x7c0d
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: findfile
static const char *findfile (lua_State *L, const char *name,
                                           const char *pname,
                                           const char *dirsep) {
  const char *path;
  lua_getfield(L, lua_upvalueindex(1), pname);
  path = lua_tostring(L, -1);
  if (path == NULL)
    luaL_error(L, LUA_QL("package.%s") " must be a string", pname);
  return searchpath(L, name, path, ".", dirsep);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x7e19
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x7967
movq %rax, %r12
testq %rax, %rax
jne 0xf6ae
leaq 0xf807(%rip), %rsi      # 0x1eea8
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8d68
leaq 0xed58(%rip), %rcx      # 0x1e40d
leaq 0xf7ba(%rip), %r8       # 0x1ee76
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf340
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: checkload
static int checkload (lua_State *L, int stat, const char *filename) {
  if (stat) {  /* module loaded successfully? */
    lua_pushstring(L, filename);  /* will be 2nd argument to module */
    return 2;  /* return open function and file name */
  }
  else
    return luaL_error(L, "error loading module " LUA_QS
                         " from file " LUA_QS ":\n\t%s",
                          lua_tostring(L, 1), filename, lua_tostring(L, -1));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
testl %esi, %esi
je 0xf6f8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7b76
pushq $0x2
popq %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x7967
movq %rax, %r15
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x7967
leaq 0xf7aa(%rip), %rsi      # 0x1eec6
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x8d68
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: loadfunc
static int loadfunc (lua_State *L, const char *filename, const char *modname) {
  const char *funcname;
  const char *mark;
  modname = luaL_gsub(L, modname, ".", LUA_OFSEP);
  mark = strchr(modname, *LUA_IGMARK);
  if (mark) {
    int stat;
    funcname = lua_pushlstring(L, modname, mark - modname);
    funcname = lua_pushfstring(L, LUA_POF"%s", funcname);
    stat = ll_loadfunc(L, filename, funcname);
    if (stat != ERRFUNC) return stat;
    modname = mark + 1;  /* else go ahead and try old-style name */
  }
  funcname = lua_pushfstring(L, LUA_POF"%s", modname);
  return ll_loadfunc(L, filename, funcname);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xecc4(%rip), %rax      # 0x1e40d
leaq 0xf7a4(%rip), %rcx      # 0x1eef4
movq %rdx, %rsi
movq %rax, %rdx
callq 0x9f0b
movq %rax, %r12
pushq $0x2d
popq %rsi
movq %rax, %rdi
callq 0x6190
testq %rax, %rax
je 0xf7af
movq %rax, %r15
movq %rax, %rdx
subq %r12, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x7b27
leaq 0xf76d(%rip), %rsi      # 0x1eef6
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7c0d
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xf205
cmpl $0x2, %eax
jne 0xf7dc
incq %r15
movq %r15, %r12
leaq 0xf740(%rip), %rsi      # 0x1eef6
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x7c0d
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xf205
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lobject.c
// Function: luaO_int2fb
int luaO_int2fb (unsigned int x) {
  int e = 0;  /* exponent */
  if (x < 8) return x;
  while (x >= 0x10) {
    x = (x+1) >> 1;
    e++;
  }
  return ((e+1) << 3) | (cast_int(x) - 8);
}

// Assembly:
movl %edi, %eax
cmpl $0x8, %edi
jb 0xfa11
pushq $0x8
popq %rcx
cmpl $0x10, %eax
jb 0xfa0c
incl %eax
shrl %eax
addl $0x8, %ecx
jmp 0xf9fe
addl $-0x8, %eax
orl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lobject.c
// Function: luaO_arith
lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2) {
  switch (op) {
    case LUA_OPADD: return luai_numadd(NULL, v1, v2);
    case LUA_OPSUB: return luai_numsub(NULL, v1, v2);
    case LUA_OPMUL: return luai_nummul(NULL, v1, v2);
    case LUA_OPDIV: return luai_numdiv(NULL, v1, v2);
    case LUA_OPMOD: return luai_nummod(NULL, v1, v2);
    case LUA_OPPOW: return luai_numpow(NULL, v1, v2);
    case LUA_OPUNM: return luai_numunm(NULL, v1);
    default: lua_assert(0); return 0;
  }
}

// Assembly:
cmpl $0x6, %edi
ja 0xfaaa
movl %edi, %eax
leaq 0xf520(%rip), %rcx      # 0x1ef80
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm1, %xmm0
retq
subq $0x28, %rsp
movapd %xmm0, 0x10(%rsp)
divsd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x64f0
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
mulsd %xmm1, %xmm0
retq
divsd %xmm1, %xmm0
retq
xorps %xmm0, %xmm0
retq
subsd %xmm1, %xmm0
retq
jmp 0x6140
xorps 0xf4b1(%rip), %xmm0     # 0x1ef70
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lobject.c
// Function: luaO_str2d
int luaO_str2d (const char *s, size_t len, lua_Number *result) {
  char *endptr;
  if (strpbrk(s, "nN"))  /* reject 'inf' and 'nan' */
    return 0;
  else if (strpbrk(s, "xX"))  /* hexa? */
    *result = lua_strx2number(s, &endptr);
  else
    *result = lua_str2number(s, &endptr);
  if (endptr == s) return 0;  /* nothing recognized */
  while (lisspace(cast_uchar(*endptr))) endptr++;
  return (endptr == s + len);  /* OK if no trailing characters */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf5bc(%rip), %rsi      # 0x1f0b8
callq 0x6430
xorl %ebp, %ebp
testq %rax, %rax
jne 0xfc61
leaq 0xf5a8(%rip), %rsi      # 0x1f0bb
movq %rbx, %rdi
callq 0x6430
testq %rax, %rax
je 0xfb5e
andl $0x0, 0x24(%rsp)
andl $0x0, 0xc(%rsp)
movq %rbx, 0x18(%rsp)
leaq 0x108da(%rip), %r13     # 0x20410
movq %rbx, %rax
movzbl (%rax), %ecx
incq %rax
testb $0x8, 0x1(%rcx,%r13)
jne 0xfb39
leaq -0x1(%rax), %rdx
movq %rdx, 0x10(%rsp)
cmpl $0x2b, %ecx
je 0xfb7a
cmpl $0x2d, %ecx
jne 0xfb86
xorl %esi, %esi
jmp 0xfb7d
leaq 0x18(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6110
movaps %xmm0, %xmm1
movq (%r12), %r12
jmp 0xfc31
movb $0x1, %sil
movq %rax, 0x10(%rsp)
movb (%rax), %cl
jmp 0xfb8c
movb $0x1, %sil
movq %rdx, %rax
xorps %xmm1, %xmm1
cmpb $0x30, %cl
jne 0xfc2e
movzbl 0x1(%rax), %ecx
orl $0x20, %ecx
cmpl $0x78, %ecx
jne 0xfc2e
movl %esi, 0x20(%rsp)
addq $0x2, %rax
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
leaq 0xc(%rsp), %rsi
xorps %xmm0, %xmm0
movq %r12, %rdi
callq 0x1012c
movq (%r12), %rax
xorl %edi, %edi
cmpb $0x2e, (%rax)
jne 0xfbf0
incq %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x24(%rsp), %r12
movq %r12, %rsi
callq 0x1012c
movl (%r12), %edi
movl 0xc(%rsp), %eax
orl %edi, %eax
movq %rbx, %r12
xorps %xmm1, %xmm1
je 0xfc31
shll $0x2, %edi
negl %edi
movq 0x10(%rsp), %r12
movq %r12, 0x18(%rsp)
movzbl (%r12), %eax
orl $0x20, %eax
cmpl $0x70, %eax
jne 0xfc72
movzbl 0x1(%r12), %edx
cmpl $0x2d, %edx
je 0xfc77
cmpl $0x2b, %edx
jne 0xfc85
movb $0x1, %cl
jmp 0xfc79
movq %rbx, %r12
movsd %xmm1, (%r15)
cmpq %rbx, %r12
je 0xfc61
decq %r12
leaq 0x107cb(%rip), %rax     # 0x20410
movzbl 0x1(%r12), %ecx
incq %r12
testb $0x8, 0x1(%rcx,%rax)
jne 0xfc45
addq %r14, %rbx
xorl %ebp, %ebp
cmpq %rbx, %r12
sete %bpl
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rax
jmp 0xfcc6
xorl %ecx, %ecx
leaq 0x2(%r12), %rax
movb 0x2(%r12), %dl
jmp 0xfc8c
leaq 0x1(%r12), %rax
movb $0x1, %cl
movzbl %dl, %esi
testb $0x2, 0x1(%rsi,%r13)
je 0xfccb
xorl %esi, %esi
movzbl %dl, %r8d
testb $0x2, 0x1(%r8,%r13)
je 0xfcb8
imull $0xa, %esi, %esi
movsbl %dl, %edx
addl %edx, %esi
addl $-0x30, %esi
movb 0x1(%rax), %dl
incq %rax
jmp 0xfc99
movl %esi, %edx
negl %edx
testb %cl, %cl
cmovnel %esi, %edx
addl %edx, %edi
movq %rax, %r12
movq %rax, 0x18(%rsp)
cmpb $0x0, 0x20(%rsp)
jne 0xfcd9
xorps 0xf297(%rip), %xmm0     # 0x1ef70
callq 0x6090
movaps %xmm0, %xmm1
jmp 0xfc31
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lobject.c
// Function: readhexa
static lua_Number readhexa (const char **s, lua_Number r, int *count) {
  for (; lisxdigit(cast_uchar(**s)); (*s)++) {  /* read integer part */
    r = (r * cast_num(16.0)) + cast_num(luaO_hexavalue(cast_uchar(**s)));
    (*count)++;
  }
  return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
incq %r15
leaq 0x102c9(%rip), %r12     # 0x20410
movzbl -0x1(%r15), %edi
testb $0x10, 0x1(%rdi,%r12)
je 0x1017d
movsd %xmm0, (%rsp)
callq 0xfac0
movsd (%rsp), %xmm0
cvtsi2sd %eax, %xmm1
incl (%rbx)
mulsd 0xef3f(%rip), %xmm0     # 0x1f0b0
addsd %xmm1, %xmm0
movq %r15, (%r14)
incq %r15
jmp 0x10147
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loslib.c
// Function: os_exit
static int os_exit (lua_State *L) {
  int status;
  if (lua_isboolean(L, 1))
    status = (lua_toboolean(L, 1) ? EXIT_SUCCESS : EXIT_FAILURE);
  else
    status = luaL_optint(L, 1, EXIT_SUCCESS);
  if (lua_toboolean(L, 2))
    lua_close(L);
  if (L) exit(status);  /* 'if' to avoid warnings for unreachable 'return' */
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7624
pushq $0x1
popq %rsi
movq %rbx, %rdi
cmpl $0x1, %eax
jne 0x10585
callq 0x7943
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
jmp 0x1058f
xorl %edx, %edx
callq 0x9456
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7943
testl %eax, %eax
je 0x105a6
movq %rbx, %rdi
callq 0x135c7
testq %rbx, %rbx
jne 0x105b5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %r14d, %edi
callq 0x6530
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loslib.c
// Function: os_time
static int os_time (lua_State *L) {
  time_t t;
  if (lua_isnoneornil(L, 1))  /* called without args? */
    t = time(NULL);  /* get current time */
  else {
    struct tm ts;
    luaL_checktype(L, 1, LUA_TTABLE);
    lua_settop(L, 1);  /* make sure table is at the top */
    ts.tm_sec = getfield(L, "sec", 0);
    ts.tm_min = getfield(L, "min", 0);
    ts.tm_hour = getfield(L, "hour", 12);
    ts.tm_mday = getfield(L, "day", -1);
    ts.tm_mon = getfield(L, "month", -1) - 1;
    ts.tm_year = getfield(L, "year", -1) - 1900;
    ts.tm_isdst = getboolfield(L, "isdst");
    t = mktime(&ts);
  }
  if (t == (time_t)(-1))
    lua_pushnil(L);
  else
    lua_pushnumber(L, (lua_Number)t);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7624
testl %eax, %eax
jle 0x107bc
pushq $0x1
popq %rbp
pushq $0x5
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x92e7
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7437
leaq 0xeb6f(%rip), %rsi      # 0x1f266
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1085e
movl %eax, (%rsp)
leaq 0xe583(%rip), %rsi      # 0x1ec8e
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1085e
movl %eax, 0x4(%rsp)
leaq 0xeb4a(%rip), %rsi      # 0x1f26a
pushq $0xc
popq %rdx
movq %rbx, %rdi
callq 0x1085e
movl %eax, 0x8(%rsp)
leaq 0xeb45(%rip), %rsi      # 0x1f27b
pushq $-0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x1085e
movl %eax, 0xc(%rsp)
leaq 0xeb21(%rip), %rsi      # 0x1f26f
movq %rbx, %rdi
movl %ebp, %edx
callq 0x1085e
decl %eax
movl %eax, 0x10(%rsp)
leaq 0xeb10(%rip), %rsi      # 0x1f275
movq %rbx, %rdi
movl %ebp, %edx
callq 0x1085e
addl $0xfffff894, %eax       # imm = 0xFFFFF894
movl %eax, 0x14(%rsp)
leaq 0xeb05(%rip), %rdx      # 0x1f284
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7e19
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7624
testl %eax, %eax
je 0x107a4
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x7943
movl %eax, %ebp
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x7437
movq %rsp, %rdi
movl %ebp, 0x20(%rdi)
callq 0x6400
jmp 0x107c3
xorl %edi, %edi
callq 0x6380
cmpq $-0x1, %rax
je 0x107d8
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
callq 0x7adc
jmp 0x107e0
movq %rbx, %rdi
callq 0x7acb
pushq $0x1
popq %rax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loslib.c
// Function: getfield
static int getfield (lua_State *L, const char *key, int d) {
  int res, isnum;
  lua_getfield(L, -1, key);
  res = (int)lua_tointegerx(L, -1, &isnum);
  if (!isnum) {
    if (d < 0)
      return luaL_error(L, "field " LUA_QS " missing in date table", key);
    res = d;
  }
  lua_pop(L, 1);
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
pushq $-0x1
popq %rbp
movl %ebp, %esi
movq %r15, %rdx
callq 0x7e19
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x78a4
cmpl $0x0, (%r12)
je 0x1089c
movl %eax, %ebx
jmp 0x108a0
testl %ebx, %ebx
js 0x108ba
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x7437
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xea49(%rip), %rsi      # 0x1f30a
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8d68
movl %eax, %ebx
jmp 0x108ab
nop
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: luaY_parser
Closure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
                      Dyndata *dyd, const char *name, int firstchar) {
  LexState lexstate;
  FuncState funcstate;
  Closure *cl = luaF_newLclosure(L, 1);  /* create main closure */
  /* anchor closure (to avoid being collected) */
  setclLvalue(L, L->top, cl);
  incr_top(L);
  funcstate.f = cl->l.p = luaF_newproto(L);
  funcstate.f->source = luaS_new(L, name);  /* create and anchor TString */
  lexstate.buff = buff;
  lexstate.dyd = dyd;
  dyd->actvar.n = dyd->gt.n = dyd->label.n = 0;
  luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar);
  mainfunc(&lexstate, &funcstate);
  lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs);
  /* all scopes should be correctly finished */
  lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0);
  return cl;  /* it's on the stack too */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %r9d, 0x4(%rsp)
movq %r8, %r13
movq %rcx, %r15
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
pushq $0x1
popq %rsi
callq 0xbe28
movq %rax, %rbx
movq 0x10(%r12), %rax
movq %rbx, (%rax)
movl $0x46, 0x8(%rax)
movq 0x10(%r12), %rax
movq 0x30(%r12), %rcx
addq $0x10, %rax
movq %rax, 0x10(%r12)
subq %rax, %rcx
cmpq $0xf, %rcx
jg 0x1093d
movq %r12, %rdi
xorl %esi, %esi
callq 0xaef2
movq %r12, %rdi
callq 0xbfa4
movq %rax, %rbp
movq %rax, 0x18(%rbx)
leaq 0x40(%rsp), %r14
movq %rax, (%r14)
movq %r12, %rdi
movq %r13, %rsi
callq 0x138fd
movq %rax, 0x48(%rbp)
leaq 0x88(%rsp), %r13
movq 0x8(%rsp), %rcx
movq %rcx, 0x48(%r13)
movq %r15, 0x50(%r13)
andl $0x0, 0x28(%r15)
andl $0x0, 0x18(%r15)
andl $0x0, 0x8(%r15)
movq %r12, %rdi
movq %r13, %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
movl 0x4(%rsp), %r8d
callq 0x1c572
leaq 0x18(%rsp), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x10a10
movq (%r14), %rax
movb $0x1, 0x79(%rax)
leaq 0x28(%rsp), %rdx
orq $-0x1, 0x10(%rdx)
movl $0x7, (%rdx)
andl $0x0, 0x8(%rdx)
movq 0x60(%r13), %rsi
movq %r14, %rdi
callq 0x10ab3
movq %r13, %rdi
callq 0x1c5df
movq %r13, %rdi
callq 0x10b98
movq %r13, %rdi
movl $0x11e, %esi            # imm = 0x11E
callq 0x10bda
movq %r13, %rdi
callq 0x10be6
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: open_func
static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) {
  lua_State *L = ls->L;
  Proto *f;
  fs->prev = ls->fs;  /* linked list of funcstates */
  fs->ls = ls;
  ls->fs = fs;
  fs->pc = 0;
  fs->lasttarget = 0;
  fs->jpc = NO_JUMP;
  fs->freereg = 0;
  fs->nk = 0;
  fs->np = 0;
  fs->nups = 0;
  fs->nlocvars = 0;
  fs->nactvar = 0;
  fs->firstlocal = ls->dyd->actvar.n;
  fs->bl = NULL;
  f = fs->f;
  f->source = ls->source;
  f->maxstacksize = 2;  /* registers 0/1 are always valid */
  fs->h = luaH_new(L);
  /* anchor table of constants (to avoid being collected) */
  sethvalue2s(L, L->top, fs->h);
  incr_top(L);
  enterblock(fs, bl, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %r14
movq %rax, 0x10(%rsi)
movq %rdi, 0x18(%rsi)
movq %rsi, 0x30(%rdi)
movaps 0xe94d(%rip), %xmm0     # 0x1f380
movups %xmm0, 0x28(%rsi)
andl $0x0, 0x38(%rsi)
andl $0x0, 0x40(%rsi)
movq %rdx, %r15
movb $0x0, 0x44(%rsi)
movq 0x50(%rdi), %rax
movl 0x8(%rax), %eax
movl %eax, 0x3c(%rsi)
andq $0x0, 0x20(%rsi)
movq (%rsi), %rax
movq 0x58(%rdi), %rcx
movq %rcx, 0x48(%rax)
movb $0x2, 0x7a(%rax)
movq %r14, %rdi
callq 0x15a42
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rcx
movq %rax, (%rcx)
movl $0x45, 0x8(%rcx)
movq 0x10(%r14), %rax
movq 0x30(%r14), %rcx
addq $0x10, %rax
movq %rax, 0x10(%r14)
subq %rax, %rcx
cmpq $0xf, %rcx
jg 0x10aa1
movq %r14, %rdi
xorl %esi, %esi
callq 0xaef2
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x10dbd
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: singlevar
static void singlevar (LexState *ls, expdesc *var) {
  TString *varname = str_checkname(ls);
  FuncState *fs = ls->fs;
  if (singlevaraux(fs, varname, var, 1) == VVOID) {  /* global name? */
    expdesc key;
    singlevaraux(fs, ls->envn, var, 1);  /* get environment variable */
    lua_assert(var->k == VLOCAL || var->k == VUPVAL);
    codestring(ls, &key, varname);  /* key is variable name */
    luaK_indexed(fs, var, &key);  /* env[varname] */
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x11967
movq %rax, %r12
movq 0x30(%r15), %r14
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x128d2
testl %eax, %eax
jne 0x128c6
movq 0x60(%r15), %rsi
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x128d2
movq 0x30(%r15), %rdi
movq %r12, %rsi
callq 0x1a3aa
movq %rsp, %rdx
orq $-0x1, 0x10(%rdx)
movl $0x4, (%rdx)
movl %eax, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ac11
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: undefgoto
static l_noret undefgoto (LexState *ls, Labeldesc *gt) {
  const char *msg = isreserved(gt->name)
                    ? "<%s> at line %d not inside a loop"
                    : "no visible label " LUA_QS " for <goto> at line %d";
  msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line);
  semerror(ls, msg);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdx
cmpb $0x4, 0x8(%rdx)
jne 0x12a3a
cmpb $0x0, 0xa(%rdx)
leaq 0xcbb7(%rip), %rcx      # 0x1f5e4
leaq 0xcb8e(%rip), %rax      # 0x1f5c2
cmoveq %rcx, %rax
jmp 0x12a41
leaq 0xcba3(%rip), %rax      # 0x1f5e4
movq 0x38(%rbx), %rdi
addq $0x18, %rdx
movl 0xc(%rsi), %ecx
movq %rax, %rsi
xorl %eax, %eax
callq 0xff79
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12bf9
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: findgotos
static void findgotos (LexState *ls, Labeldesc *lb) {
  Labellist *gl = &ls->dyd->gt;
  int i = ls->fs->bl->firstgoto;
  while (i < gl->n) {
    if (luaS_eqstr(gl->arr[i].name, lb->name))
      closegoto(ls, i, lb);
    else
      i++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rax
movq 0x50(%rdi), %r12
movq 0x20(%rax), %rax
movswl 0xa(%rax), %ebp
movslq %ebp, %r15
imulq $0x18, %r15, %r13
cmpl 0x18(%r12), %r15d
jge 0x12b3f
movq 0x10(%r12), %rax
movq (%rax,%r13), %rdi
movq (%rbx), %rsi
callq 0x13609
testl %eax, %eax
je 0x12b3b
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x12b4e
jmp 0x12b0f
incl %ebp
jmp 0x12b08
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: closegoto
static void closegoto (LexState *ls, int g, Labeldesc *label) {
  int i;
  FuncState *fs = ls->fs;
  Labellist *gl = &ls->dyd->gt;
  Labeldesc *gt = &gl->arr[g];
  lua_assert(luaS_eqstr(gt->name, label->name));
  if (gt->nactvar < label->nactvar) {
    TString *vname = getlocvar(fs, gt->nactvar)->varname;
    const char *msg = luaO_pushfstring(ls->L,
      "<goto %s> at line %d jumps into the scope of local " LUA_QS,
      getstr(gt->name), gt->line, getstr(vname));
    semerror(ls, msg);
  }
  luaK_patchlist(fs, gt->pc, label->pc);
  /* remove goto from pending list */
  for (i = g; i < gl->n - 1; i++)
    gl->arr[i] = gl->arr[i + 1];
  gl->n--;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq 0x50(%rbx), %r14
movq 0x10(%r14), %r13
movslq %esi, %r15
imulq $0x18, %r15, %r12
movzbl 0x10(%r13,%r12), %esi
addq %r12, %r13
cmpb 0x10(%rdx), %sil
jb 0x12bc4
movl 0x8(%r13), %esi
movl 0x8(%rdx), %edx
callq 0x1a114
movslq 0x18(%r14), %rax
decq %rax
cmpq %rax, %r15
jge 0x12bb6
movq 0x10(%r14), %rax
incq %r15
movq 0x28(%rax,%r12), %rcx
movq %rcx, 0x10(%rax,%r12)
movups 0x18(%rax,%r12), %xmm0
movups %xmm0, (%rax,%r12)
addq $0x18, %r12
jmp 0x12b88
movl %eax, 0x18(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x126bd
movq (%rax), %r8
movq 0x38(%rbx), %rdi
movq (%r13), %rdx
addq $0x18, %rdx
movl 0xc(%r13), %ecx
addq $0x18, %r8
leaq 0xc9a3(%rip), %rsi      # 0x1f58a
xorl %eax, %eax
callq 0xff79
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12bf9
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstate.c
// Function: luaE_extendCI
CallInfo *luaE_extendCI (lua_State *L) {
  CallInfo *ci = luaM_new(L, CallInfo);
  lua_assert(L->ci->next == NULL);
  L->ci->next = ci;
  ci->previous = L->ci;
  ci->next = NULL;
  return ci;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x50
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0xed73
movq 0x20(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq %rcx, 0x10(%rax)
andq $0x0, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstate.c
// Function: lua_newthread
LUA_API lua_State *lua_newthread (lua_State *L) {
  lua_State *L1;
  lua_lock(L);
  luaC_checkGC(L);
  L1 = &luaC_newobj(L, LUA_TTHREAD, sizeof(LX), NULL, offsetof(LX, l))->th;
  setthvalue(L, L->top, L1);
  api_incr_top(L);
  preinit_state(L1, G(L));
  L1->hookmask = L->hookmask;
  L1->basehookcount = L->basehookcount;
  L1->hook = L->hook;
  resethookcount(L1);
  luai_userstatethread(L, L1);
  stack_init(L1, L);  /* init stack */
  lua_unlock(L);
  return L1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq $0x0, 0x18(%rax)
jle 0x13137
movq %rbx, %rdi
callq 0xcd44
pushq $0x8
popq %rsi
movl $0xd0, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xc26a
movq %rax, %r14
movq 0x10(%rbx), %rax
movq %r14, (%rax)
movl $0x48, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x1319e
movb 0x48(%rbx), %al
movb %al, 0x48(%r14)
movl 0x4c(%rbx), %eax
movl %eax, 0x4c(%r14)
movq 0x58(%rbx), %rcx
movq %rcx, 0x58(%r14)
movl %eax, 0x50(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x131d5
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstate.c
// Function: freestack
static void freestack (lua_State *L) {
  if (L->stack == NULL)
    return;  /* stack not completely built yet */
  L->ci = &L->base_ci;  /* free the entire 'ci' list */
  luaE_freeCI(L);
  luaM_freearray(L, L->stack, L->stacksize);  /* free stack array */
}

// Assembly:
cmpq $0x0, 0x38(%rdi)
je 0x132bd
pushq %rbx
movq %rdi, %rbx
leaq 0x80(%rdi), %rax
movq %rax, 0x20(%rdi)
callq 0x130e3
movq 0x38(%rbx), %rsi
movslq 0x40(%rbx), %rdx
shlq $0x4, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
popq %rbx
jmp 0xed73
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstate.c
// Function: f_luaopen
static void f_luaopen (lua_State *L, void *ud) {
  global_State *g = G(L);
  UNUSED(ud);
  stack_init(L, L);  /* init stack */
  init_registry(L, g);
  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
  luaT_init(L);
  luaX_init(L);
  /* pre-create memory-error message */
  g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
  luaS_fix(g->memerrmsg);  /* it should never be collected */
  g->gcrunning = 1;  /* allow gc */
  g->version = lua_version(NULL);
  luai_userstateopen(L);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r12
movq %rdi, %rsi
callq 0x131d5
movq %rbx, %rdi
callq 0x15a42
movq %rax, %r14
movq %rax, 0x40(%r12)
pushq $0x45
popq %r13
movl %r13d, 0x48(%r12)
pushq $0x2
popq %rbp
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x15728
leaq 0x8(%rsp), %r15
movq %rbx, (%r15)
movl $0x48, 0x8(%r15)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x15983
movq %rbx, %rdi
callq 0x15a42
movq %rax, (%r15)
movl %r13d, 0x8(%r15)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x15983
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x1366c
movq %rbx, %rdi
callq 0x16900
movq %rbx, %rdi
callq 0x1c390
leaq 0xab18(%rip), %rsi      # 0x1e025
pushq $0x11
popq %rdx
movq %rbx, %rdi
callq 0x13766
movq %rax, 0x118(%r12)
orb $0x20, 0x9(%rax)
movb $0x1, 0x57(%r12)
xorl %edi, %edi
callq 0x73e9
movq %rax, 0x110(%r12)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstring.c
// Function: luaS_eqlngstr
int luaS_eqlngstr (TString *a, TString *b) {
  size_t len = a->tsv.len;
  lua_assert(a->tsv.tt == LUA_TLNGSTR && b->tsv.tt == LUA_TLNGSTR);
  return (a == b) ||  /* same instance or... */
    ((len == b->tsv.len) &&  /* equal length and ... */
     (memcmp(getstr(a), getstr(b), len) == 0));  /* equal contents */
}

// Assembly:
cmpq %rsi, %rdi
je 0x13605
movq 0x10(%rdi), %rdx
xorl %eax, %eax
cmpq 0x10(%rsi), %rdx
jne 0x13604
pushq %rax
addq $0x18, %rdi
addq $0x18, %rsi
callq 0x63e0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addq $0x8, %rsp
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstring.c
// Function: luaS_hash
unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) {
  unsigned int h = seed ^ cast(unsigned int, l);
  size_t l1;
  size_t step = (l >> LUAI_HASHLIMIT) + 1;
  for (l1 = l; l1 >= step; l1 -= step)
    h = h ^ ((h<<5) + (h>>2) + cast_byte(str[l1 - 1]));
  return h;
}

// Assembly:
movl %edx, %eax
xorl %esi, %eax
movq %rsi, %rcx
shrq $0x5, %rcx
movq %rcx, %rdx
notq %rdx
cmpq %rcx, %rsi
jbe 0x1366b
movl %eax, %r8d
shll $0x5, %r8d
movl %eax, %r9d
shrl $0x2, %r9d
addl %r8d, %r9d
movzbl -0x1(%rdi,%rsi), %r8d
addl %r9d, %r8d
xorl %r8d, %eax
addq %rdx, %rsi
jmp 0x13644
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstring.c
// Function: luaS_resize
void luaS_resize (lua_State *L, int newsize) {
  int i;
  stringtable *tb = &G(L)->strt;
  /* cannot resize while GC is traversing strings */
  luaC_runtilstate(L, ~bitmask(GCSsweepstring));
  if (newsize > tb->size) {
    luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *);
    for (i = tb->size; i < newsize; i++) tb->hash[i] = NULL;
  }
  /* rehash */
  for (i=0; i<tb->size; i++) {
    GCObject *p = tb->hash[i];
    tb->hash[i] = NULL;
    while (p) {  /* for each node in the list */
      GCObject *next = gch(p)->next;  /* save next */
      unsigned int h = lmod(gco2ts(p)->hash, newsize);  /* new position */
      gch(p)->next = tb->hash[h];  /* chain it */
      tb->hash[h] = p;
      resetoldbit(p);  /* see MOVE OLD rule */
      p = next;
    }
  }
  if (newsize < tb->size) {
    /* shrinking slice must be empty */
    lua_assert(tb->hash[newsize] == NULL && tb->hash[tb->size - 1] == NULL);
    luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *);
  }
  tb->size = newsize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %r12
pushq $-0x5
popq %rsi
callq 0xc3ff
movl 0x3c(%r12), %eax
movslq %ebx, %r15
cmpl %ebx, %eax
jge 0x136d7
cmpl $-0x2, %ebx
jle 0x1375e
movslq %eax, %rdx
movq 0x30(%r12), %rsi
shlq $0x3, %rdx
leaq (,%r15,8), %rcx
movq %r14, %rdi
callq 0xed73
movq %rax, 0x30(%r12)
movl 0x3c(%r12), %eax
movslq %eax, %rcx
cmpq %r15, %rcx
jge 0x136d7
movq 0x30(%r12), %rdx
andq $0x0, (%rdx,%rcx,8)
incq %rcx
jmp 0x136c3
leal -0x1(%rbx), %ecx
xorl %esi, %esi
movslq %eax, %rdx
cmpq %rdx, %rsi
jge 0x13727
movq 0x30(%r12), %rdx
movq (%rdx,%rsi,8), %rax
andq $0x0, (%rdx,%rsi,8)
testq %rax, %rax
je 0x1371d
movq (%rax), %rdx
movl 0xc(%rax), %edi
andl %ecx, %edi
movq 0x30(%r12), %r8
movq (%r8,%rdi,8), %r8
movq %r8, (%rax)
movq 0x30(%r12), %r8
movq %rax, (%r8,%rdi,8)
andb $-0x41, 0x9(%rax)
movq %rdx, %rax
jmp 0x136f2
incq %rsi
movl 0x3c(%r12), %eax
jmp 0x136dc
cmpl %ebx, %eax
jle 0x1374d
cmpl $-0x2, %ebx
jle 0x1375e
movq 0x30(%r12), %rsi
shlq $0x3, %rdx
shlq $0x3, %r15
movq %r14, %rdi
movq %r15, %rcx
callq 0xed73
movq %rax, 0x30(%r12)
movl %ebx, 0x3c(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0xed64
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstring.c
// Function: luaS_newlstr
TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
  if (l <= LUAI_MAXSHORTLEN)  /* short string? */
    return internshrstr(L, str, l);
  else {
    if (l + 1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
      luaM_toobig(L);
    return createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed, NULL);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
cmpq $0x28, %rdx
ja 0x137fd
movq %rdi, (%rsp)
movq 0x18(%rdi), %r15
movl 0x50(%r15), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13633
movl %eax, %ebp
movq 0x30(%r15), %rcx
movl 0x3c(%r15), %r12d
leal -0x1(%r12), %eax
andl %ebp, %eax
cltq
movq %rcx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
leaq (%rcx,%rax,8), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x1382f
cmpl 0xc(%r13), %ebp
jne 0x137b8
cmpq %rbx, 0x10(%r13)
jne 0x137b8
leaq 0x18(%r13), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x63e0
testl %eax, %eax
jne 0x137b8
movb 0x9(%r13), %al
xorb $0x3, %al
movb 0x54(%r15), %cl
xorb $0x3, %cl
testb %al, %cl
jne 0x137f5
movb %al, 0x9(%r13)
movq %r13, %rax
jmp 0x13897
leaq 0x1b(%rbx), %rax
cmpq $0x19, %rax
jbe 0x138a6
movq 0x18(%rdi), %rax
movl 0x50(%rax), %r8d
pushq $0x14
popq %rcx
movq %r14, %rsi
movq %rbx, %rdx
xorl %r9d, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x138ab
cmpl $0x3ffffffe, %r12d      # imm = 0x3FFFFFFE
jg 0x1386d
cmpl %r12d, 0x38(%r15)
movq (%rsp), %r13
jb 0x13871
addl %r12d, %r12d
movq %r13, %rdi
movl %r12d, %esi
callq 0x1366c
movslq 0x3c(%r15), %rax
movq 0x30(%r15), %rcx
movq %rcx, 0x10(%rsp)
decq %rax
movslq %ebp, %rcx
andq %rax, %rcx
movq %rcx, 0x8(%rsp)
jmp 0x13871
movq (%rsp), %r13
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
leaq (%rax,%rcx,8), %r9
pushq $0x4
popq %rcx
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %r8d
callq 0x138ab
incl 0x38(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xed64
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstring.c
// Function: createstrobj
static TString *createstrobj (lua_State *L, const char *str, size_t l,
                              int tag, unsigned int h, GCObject **list) {
  TString *ts;
  size_t totalsize;  /* total size of TString object */
  totalsize = sizeof(TString) + ((l + 1) * sizeof(char));
  ts = &luaC_newobj(L, tag, totalsize, list, 0)->ts;
  ts->tsv.len = l;
  ts->tsv.hash = h;
  ts->tsv.extra = 0;
  memcpy(ts+1, str, l*sizeof(char));
  ((char *)(ts+1))[l] = '\0';  /* ending 0 */
  return ts;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rdx, %r14
movq %rsi, %r15
addq $0x19, %rdx
xorl %ebp, %ebp
movl %ecx, %esi
movq %r9, %rcx
xorl %r8d, %r8d
callq 0xc26a
movq %rax, %r12
movq %r14, 0x10(%rax)
movl %ebx, 0xc(%rax)
movb %bpl, 0xa(%rax)
leaq 0x18(%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6350
movb %bpl, 0x18(%r12,%r14)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstring.c
// Function: luaS_newudata
Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
  Udata *u;
  if (s > MAX_SIZET - sizeof(Udata))
    luaM_toobig(L);
  u = &luaC_newobj(L, LUA_TUSERDATA, sizeof(Udata) + s, NULL, 0)->u;
  u->uv.len = s;
  u->uv.metatable = NULL;
  u->uv.env = e;
  return u;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $-0x2a, %rsi
jae 0x1395a
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x28(%rsi), %rdx
pushq $0x7
popq %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xc26a
movq %r14, 0x20(%rax)
andq $0x0, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xed64
nop
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstrlib.c
// Function: str_byte
static int str_byte (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  size_t posi = posrelat(luaL_optinteger(L, 2, 1), l);
  size_t pose = posrelat(luaL_optinteger(L, 3, posi), l);
  int n, i;
  if (posi < 1) posi = 1;
  if (pose > l) pose = l;
  if (posi > pose) return 0;  /* empty interval; return no values */
  n = (int)(pose -  posi + 1);
  if (posi + n <= pose)  /* (size_t -> int) overflow? */
    return luaL_error(L, "string slice too long");
  luaL_checkstack(L, n, "string slice too long");
  for (i=0; i<n; i++)
    lua_pushinteger(L, uchar(s[posi+i-1]));
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x9264
movq %rax, %r14
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x9456
movq %rax, %r15
testq %rax, %rax
jns 0x13a46
movq 0x8(%rsp), %rax
movq %r15, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x13a40
xorl %r15d, %r15d
jmp 0x13a46
addq %rax, %r15
incq %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x9456
movq 0x8(%rsp), %rcx
testq %rax, %rax
jns 0x13a73
movq %rax, %rdx
negq %rdx
cmpq %rdx, %rcx
jae 0x13a6d
xorl %eax, %eax
jmp 0x13a73
addq %rcx, %rax
incq %rax
cmpq $0x1, %r15
adcq $0x0, %r15
cmpq %rcx, %rax
cmovbq %rax, %rcx
xorl %ebp, %ebp
cmpq %r15, %rcx
jb 0x13aeb
movl %ecx, %ebp
subl %r15d, %ebp
incl %ebp
movslq %ebp, %rax
addq %r15, %rax
cmpq %rcx, %rax
jbe 0x13ad8
leaq 0xbd6e(%rip), %rdx      # 0x1f810
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9291
addq %r15, %r14
decq %r14
xorl %r15d, %r15d
testl %ebp, %ebp
movl $0x0, %r12d
cmovgl %ebp, %r12d
cmpq %r15, %r12
je 0x13aeb
movzbl (%r14,%r15), %esi
movq %rbx, %rdi
callq 0x7af1
incq %r15
jmp 0x13ac1
leaq 0xbd31(%rip), %rsi      # 0x1f810
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8d68
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstrlib.c
// Function: str_char
static int str_char (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  luaL_Buffer b;
  char *p = luaL_buffinitsize(L, &b, n);
  for (i=1; i<=n; i++) {
    int c = luaL_checkint(L, i);
    luaL_argcheck(L, uchar(c) == c, i, "value out of range");
    p[i - 1] = uchar(c);
  }
  luaL_pushresultsize(&b, n);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, %rbx
callq 0x7423
movslq %eax, %r13
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x9670
movq %rax, %r15
xorl %r14d, %r14d
testl %r13d, %r13d
movl $0x0, %r12d
movq %r13, (%rsp)
cmovgl %r13d, %r12d
cmpq %r14, %r12
je 0x13b77
leaq 0x1(%r14), %r13
movq %rbx, %rdi
movl %r13d, %esi
callq 0x93db
movq %rax, %rbp
testl $0xffffff00, %ebp       # imm = 0xFFFFFF00
je 0x13b6e
movq %rbx, %rdi
movl %r13d, %esi
leaq 0xbcbd(%rip), %rdx      # 0x1f826
callq 0x8c84
movb %bpl, (%r15,%r14)
movq %r13, %r14
jmp 0x13b3d
leaq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x95eb
pushq $0x1
popq %rax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstrlib.c
// Function: str_dump
static int str_dump (lua_State *L) {
  luaL_Buffer b;
  luaL_checktype(L, 1, LUA_TFUNCTION);
  lua_settop(L, 1);
  luaL_buffinit(L,&b);
  if (lua_dump(L, writer, &b) != 0)
    return luaL_error(L, "unable to dump given function");
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, %r14
pushq $0x1
popq %rbx
pushq $0x6
popq %rdx
movl %ebx, %esi
callq 0x92e7
movq %r14, %rdi
movl %ebx, %esi
callq 0x7437
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x9657
leaq 0xe04(%rip), %rsi       # 0x149d9
movq %r14, %rdi
movq %r15, %rdx
callq 0x8566
testl %eax, %eax
je 0x13bf9
leaq 0xbc4e(%rip), %rsi      # 0x1f839
movq %r14, %rdi
xorl %eax, %eax
callq 0x8d68
movl %eax, %ebx
jmp 0x13c01
movq %rsp, %rdi
callq 0x95ae
movl %ebx, %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lstrlib.c
// Function: gmatch
static int gmatch (lua_State *L) {
  luaL_checkstring(L, 1);
  luaL_checkstring(L, 2);
  lua_settop(L, 2);
  lua_pushinteger(L, 0);
  lua_pushcclosure(L, gmatch_aux, 3);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
xorl %edx, %edx
callq 0x9264
pushq $0x2
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x9264
movq %r14, %rdi
movl %ebp, %esi
callq 0x7437
movq %r14, %rdi
xorl %esi, %esi
callq 0x7af1
leaq 0x129d(%rip), %rsi      # 0x154d6
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x7cba
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq