LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x65d0
cltq
movq %rax, %rcx
shlq $0x1e, %rcx
addq %rax, %rcx
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x3d, %rcx
addl %edx, %ecx
addl %ecx, %eax
shll $0x1f, %ecx
addl %eax, %ecx
cvtsi2sd %ecx, %xmm0
divsd 0x11352(%rip), %xmm0    # 0x20c50
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x7674
cmpl $0x2, %eax
je 0xf980
cmpl $0x1, %eax
je 0xf92c
testl %eax, %eax
jne 0xfa02
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
jmp 0xf9f2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9787
movapd %xmm0, %xmm1
ucomisd 0x11313(%rip), %xmm0    # 0x20c58
jae 0xf967
leaq 0x1139e(%rip), %rdx     # 0x20cec
movq %rbx, %rdi
movl $0x1, %esi
movsd %xmm1, 0x8(%rsp)
callq 0x905e
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6500
addsd 0x112da(%rip), %xmm0    # 0x20c58
jmp 0xf9ef
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9787
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x9787
movapd %xmm0, %xmm1
ucomisd 0x8(%rsp), %xmm0
jae 0xf9cc
leaq 0x11339(%rip), %rdx     # 0x20cec
movq %rbx, %rdi
movl $0x2, %esi
movsd %xmm1, 0x18(%rsp)
callq 0x905e
movsd 0x18(%rsp), %xmm1
subsd 0x8(%rsp), %xmm1
addsd 0x1127e(%rip), %xmm1    # 0x20c58
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
callq 0x6500
addsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x7e80
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
leaq 0x112f5(%rip), %rsi     # 0x20cfe
movq %rbx, %rdi
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
jmp 0x9144
// File: /workspace/github_c_makefile_star2_O3/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 0xfbd5
testq %rax, %rax
jne 0xfbd5
cmpb $0x0, 0x57(%r13)
je 0xfbed
movq %r12, %rdi
movl $0x1, %esi
callq 0xd787
movq 0x8(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *(%r13)
testq %rax, %rax
je 0xfbed
testq %r15, %r15
cmoveq %r15, %r14
subq %r14, %rbx
addq %rbx, 0x18(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
movl $0x4, %esi
callq 0xb2c0
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0xa031
testl %eax, %eax
jle 0xfe4a
movl %eax, %r14d
movq %rbx, %rdi
movl $0x1, %esi
movl %r14d, %edx
callq 0x8249
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7dbd
movq %rax, %rdi
callq 0x6590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7688
leal -0x1(%r14), %eax
cmpl $0x1, %r14d
movl %eax, %r14d
ja 0xfe0b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10d03(%rip), %rdx     # 0x20d59
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x81c3
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x81c3
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7dbd
movq %rax, %r12
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x7688
testq %r12, %r12
jne 0x10120
xorl %esi, %esi
cmpb $0x2a, (%r14)
sete %sil
shll $0x8, %esi
orl $0x2, %esi
movq %r15, %rdi
callq 0x6300
testq %rax, %rax
je 0x1016f
movq %rax, %r12
leaq 0x10c98(%rip), %rdx     # 0x20d59
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x81c3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x80ff
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7972
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movq %r15, %rdx
callq 0x844e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xa031
leal 0x1(%rax), %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8523
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7688
cmpb $0x2a, (%r14)
jne 0x10137
movq %rbx, %rdi
movl $0x1, %esi
callq 0x80e5
xorl %ebp, %ebp
jmp 0x10184
movq %r12, %rdi
movq %r14, %rsi
callq 0x64e0
testq %rax, %rax
je 0x10158
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x8061
jmp 0x10184
callq 0x6050
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7f1a
movl $0x2, %ebp
jmp 0x10184
callq 0x6050
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7f1a
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x9690
movq %rax, %r14
leaq 0x10773(%rip), %rdx     # 0x20a61
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x81c3
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x81c3
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7992
testl %eax, %eax
jne 0x10330
leaq 0x10b94(%rip), %rsi     # 0x20eb7
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x7fb4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x81c3
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x7cea
testq %rax, %rax
je 0x1050e
leaq 0xff41(%rip), %rcx      # 0x2043d
leaq 0x109a3(%rip), %r8      # 0x20ea6
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
jmp 0x10538
leaq 0x109c3(%rip), %rsi     # 0x20ed8
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x9144
leaq 0xff14(%rip), %rcx      # 0x2043d
leaq 0x10976(%rip), %r8      # 0x20ea6
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1018f
// File: /workspace/github_c_makefile_star2_O3/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 0x10567
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7f1a
movl $0x2, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x7cea
movq %rax, %r15
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x7cea
leaq 0x10967(%rip), %rsi     # 0x20ef6
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x9144
// File: /workspace/github_c_makefile_star2_O3/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 0xfe81(%rip), %rax      # 0x2043d
leaq 0x10961(%rip), %rcx     # 0x20f24
movq %rdx, %rsi
movq %rax, %rdx
callq 0xa3cd
movq %rax, %r12
movq %rax, %rdi
movl $0x2d, %esi
callq 0x6190
testq %rax, %rax
je 0x10624
movq %rax, %r15
movq %rax, %rdx
subq %r12, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x7ecb
leaq 0x10928(%rip), %rsi     # 0x20f26
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7fb4
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1003e
cmpl $0x2, %eax
jne 0x10651
incq %r15
movq %r15, %r12
leaq 0x108fb(%rip), %rsi     # 0x20f26
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x7fb4
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1003e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x108c0
movl $0x8, %ecx
cmpl $0x10, %eax
jb 0x108b7
incl %eax
movl %eax, %edx
shrl %edx
addl $0x8, %ecx
cmpl $0x1f, %eax
movl %edx, %eax
ja 0x108a5
jmp 0x108b9
movl %eax, %edx
addl $-0x8, %edx
orl %ecx, %edx
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lobject.c
// Function: luaO_ceillog2
int luaO_ceillog2 (unsigned int x) {
  static const lu_byte log_2[256] = {
    0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
  };
  int l = 0;
  x--;
  while (x >= 256) { l += 8; x >>= 8; }
  return l + log_2[x];
}

// Assembly:
decl %edi
xorl %ecx, %ecx
cmpl $0x100, %edi            # imm = 0x100
jb 0x108ff
xorl %ecx, %ecx
movl %edi, %eax
addl $0x8, %ecx
shrl $0x8, %eax
cmpl $0xffff, %edi           # imm = 0xFFFF
movl %eax, %edi
ja 0x108ed
jmp 0x10901
movl %edi, %eax
movl %eax, %eax
leaq 0x106d6(%rip), %rdx     # 0x20fe0
movzbl (%rax,%rdx), %eax
addl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10969
movl %edi, %eax
leaq 0x10691(%rip), %rcx     # 0x20fb0
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 0x6500
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 0x10622(%rip), %xmm0    # 0x20fa0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1072d(%rip), %rsi     # 0x210e8
callq 0x6440
xorl %ebp, %ebp
testq %rax, %rax
jne 0x10b20
leaq 0x10719(%rip), %rsi     # 0x210eb
movq %rbx, %rdi
callq 0x6440
testq %rax, %rax
je 0x10a1d
xorl %eax, %eax
movl %eax, 0x24(%rsp)
movl %eax, 0xc(%rsp)
movq %rbx, 0x18(%rsp)
leaq 0x11a2b(%rip), %r13     # 0x22420
movq %rbx, %rax
movzbl (%rax), %ecx
incq %rax
testb $0x8, 0x1(%rcx,%r13)
jne 0x109f8
leaq -0x1(%rax), %rdx
movq %rdx, 0x10(%rsp)
cmpl $0x2b, %ecx
je 0x10a39
cmpl $0x2d, %ecx
jne 0x10a45
xorl %esi, %esi
jmp 0x10a3c
leaq 0x18(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6110
movaps %xmm0, %xmm1
movq (%r12), %r12
jmp 0x10af0
movb $0x1, %sil
movq %rax, 0x10(%rsp)
movb (%rax), %cl
jmp 0x10a4b
movb $0x1, %sil
movq %rdx, %rax
xorps %xmm1, %xmm1
cmpb $0x30, %cl
jne 0x10aed
movzbl 0x1(%rax), %ecx
orl $0x20, %ecx
cmpl $0x78, %ecx
jne 0x10aed
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 0x1108f
movq (%r12), %rax
xorl %edi, %edi
cmpb $0x2e, (%rax)
jne 0x10aaf
incq %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x24(%rsp), %r12
movq %r12, %rsi
callq 0x1108f
movl (%r12), %edi
movl 0xc(%rsp), %eax
orl %edi, %eax
movq %rbx, %r12
xorps %xmm1, %xmm1
je 0x10af0
shll $0x2, %edi
negl %edi
movq 0x10(%rsp), %r12
movq %r12, 0x18(%rsp)
movzbl (%r12), %eax
orl $0x20, %eax
cmpl $0x70, %eax
jne 0x10b31
movzbl 0x1(%r12), %edx
cmpl $0x2d, %edx
je 0x10b36
cmpl $0x2b, %edx
jne 0x10b44
movb $0x1, %cl
jmp 0x10b38
movq %rbx, %r12
movsd %xmm1, (%r15)
cmpq %rbx, %r12
je 0x10b20
decq %r12
leaq 0x1191c(%rip), %rax     # 0x22420
movzbl 0x1(%r12), %ecx
incq %r12
testb $0x8, 0x1(%rcx,%rax)
jne 0x10b04
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 0x10b81
xorl %ecx, %ecx
leaq 0x2(%r12), %rax
movb 0x2(%r12), %dl
jmp 0x10b4b
leaq 0x1(%r12), %rax
movb $0x1, %cl
movzbl %dl, %esi
testb $0x2, 0x1(%rsi,%r13)
je 0x10b86
xorl %esi, %esi
leal (%rsi,%rsi,4), %esi
movsbl %dl, %edx
leal (%rdx,%rsi,2), %esi
addl $-0x30, %esi
movzbl 0x1(%rax), %edx
incq %rax
testb $0x2, 0x1(%rdx,%r13)
jne 0x10b58
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 0x10b94
xorps 0x1040c(%rip), %xmm0    # 0x20fa0
callq 0x6090
movaps %xmm0, %xmm1
jmp 0x10af0
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rdi), %rax
movzbl (%rax), %r8d
leaq 0x11383(%rip), %rcx     # 0x22420
movb 0x1(%r8,%rcx), %r9b
testb $0x10, %r9b
je 0x110f4
movl (%rsi), %edx
incl %edx
incq %rax
movsd 0x10029(%rip), %xmm1    # 0x210e0
leal -0x30(%r8), %r10d
orl $0x20, %r8d
addl $-0x57, %r8d
testb $0x2, %r9b
cmovnel %r10d, %r8d
xorps %xmm2, %xmm2
cvtsi2sd %r8d, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movl %edx, (%rsi)
movq %rax, (%rdi)
movzbl (%rax), %r8d
movb 0x1(%r8,%rcx), %r9b
incl %edx
incq %rax
testb $0x10, %r9b
jne 0x110b7
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7992
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x1, %eax
jne 0x11588
callq 0x7cc4
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
jmp 0x11592
xorl %edx, %edx
callq 0x98a0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7cc4
testl %eax, %eax
je 0x115ab
movq %rbx, %rdi
callq 0x14988
testq %rbx, %rbx
jne 0x115ba
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %r14d, %edi
callq 0x6540
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x7992
testl %eax, %eax
jle 0x117e9
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x9720
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7688
leaq 0xfb89(%rip), %rsi      # 0x21296
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11868
movl %eax, (%rsp)
leaq 0xf59d(%rip), %rsi      # 0x20cbe
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11868
movl %eax, 0x4(%rsp)
leaq 0xfb64(%rip), %rsi      # 0x2129a
movq %rbx, %rdi
movl $0xc, %edx
callq 0x11868
movl %eax, 0x8(%rsp)
leaq 0xfb5d(%rip), %rsi      # 0x212ab
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x11868
movl %eax, 0xc(%rsp)
leaq 0xfb34(%rip), %rsi      # 0x2129f
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x11868
decl %eax
movl %eax, 0x10(%rsp)
leaq 0xfb20(%rip), %rsi      # 0x212a5
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x11868
addl $0xfffff894, %eax       # imm = 0xFFFFF894
movl %eax, 0x14(%rsp)
leaq 0xfb12(%rip), %rdx      # 0x212b4
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x81c3
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7992
testl %eax, %eax
je 0x117cf
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7cc4
movl %eax, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7688
movq %rsp, %rdi
movl %ebp, 0x20(%rdi)
callq 0x6410
jmp 0x117f0
xorl %edi, %edi
callq 0x6390
cmpq $-0x1, %rax
je 0x11805
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
callq 0x7e80
jmp 0x1180d
movq %rbx, %rdi
callq 0x7e6c
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x81c3
leaq 0x4(%rsp), %r12
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r12, %rdx
callq 0x7c2b
cmpl $0x0, (%r12)
je 0x118a5
movl %eax, %ebx
jmp 0x118a9
testl %ebx, %ebx
js 0x118c4
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7688
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xfa6f(%rip), %rsi      # 0x2133a
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x9144
movl %eax, %ebx
jmp 0x118b6
// File: /workspace/github_c_makefile_star2_O3/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, %rbp
movq %rcx, %r15
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
movl $0x1, %esi
callq 0xc67a
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 0x11947
movq %r12, %rdi
xorl %esi, %esi
callq 0xb58f
movq %r12, %rdi
callq 0xc831
movq %rax, %r13
movq %rax, 0x18(%rbx)
leaq 0xb0(%rsp), %r14
movq %rax, (%r14)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x14d1a
movq %rax, 0x48(%r13)
leaq 0x40(%rsp), %rbp
movq 0x8(%rsp), %rcx
movq %rcx, 0x48(%rbp)
movq %r15, 0x50(%rbp)
xorl %r13d, %r13d
movl %r13d, 0x28(%r15)
movl %r13d, 0x18(%r15)
movl %r13d, 0x8(%r15)
movq %r12, %rdi
movq %rbp, %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
movl 0x4(%rsp), %r8d
callq 0x1e662
leaq 0x18(%rsp), %rdx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x11a2a
movq (%r14), %rax
movb $0x1, 0x79(%rax)
leaq 0x28(%rsp), %rdx
movq $-0x1, 0x10(%rdx)
movl $0x7, (%rdx)
movl %r13d, 0x8(%rdx)
movq 0x60(%rbp), %rsi
movq %r14, %rdi
callq 0x11af6
movq %rbp, %rdi
callq 0x1e6d4
movq %rbp, %rdi
callq 0x11c7a
cmpl $0x11e, 0x10(%rbp)      # imm = 0x11E
jne 0x11a1b
leaq 0x40(%rsp), %rdi
callq 0x11cbc
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40(%rsp), %rdi
movl $0x11e, %esi            # imm = 0x11E
callq 0x14077
// File: /workspace/github_c_makefile_star2_O3/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 %rdx, %rbx
movq %rsi, %r14
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %r15
movq %rax, 0x10(%rsi)
movq %rdi, 0x18(%rsi)
movq %rsi, 0x30(%rdi)
movaps 0xf960(%rip), %xmm0     # 0x213b0
movups %xmm0, 0x28(%rsi)
xorl %eax, %eax
movl %eax, 0x38(%rsi)
movl %eax, 0x40(%rsi)
movb $0x0, 0x44(%rsi)
movq 0x50(%rdi), %rax
movl 0x8(%rax), %eax
movl %eax, 0x3c(%rsi)
movq $0x0, 0x20(%rsi)
movq (%rsi), %rax
movq 0x58(%rdi), %rcx
movq %rcx, 0x48(%rax)
movb $0x2, 0x7a(%rax)
movq %r15, %rdi
callq 0x1709b
movq %rax, 0x8(%r14)
movq 0x10(%r15), %rcx
movq %rax, (%rcx)
movl $0x45, 0x8(%rcx)
movq 0x10(%r15), %rax
movq 0x30(%r15), %rcx
addq $0x10, %rax
movq %rax, 0x10(%r15)
subq %rax, %rcx
cmpq $0xf, %rcx
jg 0x11abe
movq %r15, %rdi
xorl %esi, %esi
callq 0xb58f
xorl %eax, %eax
movb %al, 0xe(%rbx)
movb 0x42(%r14), %cl
movb %cl, 0xc(%rbx)
movq 0x18(%r14), %rcx
movq 0x50(%rcx), %rcx
movzwl 0x28(%rcx), %edx
movw %dx, 0x8(%rbx)
movzwl 0x18(%rcx), %ecx
movw %cx, 0xa(%rbx)
movb %al, 0xd(%rbx)
movq 0x20(%r14), %rax
movq %rax, (%rbx)
movq %rbx, 0x20(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lparser.c
// Function: listfield
static void listfield (LexState *ls, struct ConsControl *cc) {
  /* listfield -> exp */
  expr(ls, &cc->v);
  checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
  cc->na++;
  cc->tostore++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0x12d0f
movl 0x24(%rbx), %eax
cmpl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
jge 0x1365f
incl %eax
movl %eax, 0x24(%rbx)
incl 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x30(%r14), %rdi
leaq 0xdeca(%rip), %rdx      # 0x21534
movl $0x7ffffffd, %esi       # imm = 0x7FFFFFFD
callq 0x11e93
// File: /workspace/github_c_makefile_star2_O3/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 0x12ae6
movq %rax, %r12
movq 0x30(%r15), %r14
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x13bf7
testl %eax, %eax
jne 0x13beb
movq 0x60(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x13bf7
movq 0x30(%r15), %rdi
movq %r12, %rsi
callq 0x1c1cc
movq %rsp, %rdx
movq $-0x1, 0x10(%rdx)
movl $0x4, (%rdx)
movl %eax, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1cc22
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13d87
cmpb $0x0, 0xa(%rdx)
leaq 0xd89a(%rip), %rcx      # 0x21614
leaq 0xd871(%rip), %rax      # 0x215f2
cmoveq %rcx, %rax
jmp 0x13d8e
leaq 0xd886(%rip), %rax      # 0x21614
movq 0x38(%rbx), %rdi
addq $0x18, %rdx
movl 0xc(%rsi), %ecx
movq %rax, %rsi
xorl %eax, %eax
callq 0x10eda
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13f56
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq 0x30(%rdi), %rax
movq 0x50(%rdi), %r15
movq 0x20(%rax), %rax
movswl 0xa(%rax), %ebp
cmpl %ebp, 0x18(%r15)
jle 0x13e8b
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%r15), %rax
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rbx), %rsi
callq 0x149cb
testl %eax, %eax
je 0x13e83
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x13e96
jmp 0x13e85
incl %ebp
cmpl 0x18(%r15), %ebp
jl 0x13e59
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq 0x50(%rbx), %r14
movq 0x10(%r14), %rax
movslq %esi, %r15
leaq (%r15,%r15,2), %rcx
leaq (%rax,%rcx,8), %r12
movzbl 0x10(%r12), %esi
cmpb 0x10(%rdx), %sil
jb 0x13f20
movl 0x8(%r12), %esi
movl 0x8(%rdx), %edx
callq 0x1bf30
movl 0x18(%r14), %ecx
decl %ecx
cmpl %ebp, %ecx
jle 0x13f13
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %rax
movq 0x10(%r14), %rcx
incq %r15
movq 0x28(%rcx,%rax), %rdx
movq %rdx, 0x10(%rcx,%rax)
movups 0x18(%rcx,%rax), %xmm0
movups %xmm0, (%rcx,%rax)
movslq 0x18(%r14), %rcx
decq %rcx
addq $0x18, %rax
cmpq %rcx, %r15
jl 0x13ee9
movl %ecx, 0x18(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x139b3
movq (%rax), %r8
movq 0x38(%rbx), %rdi
movq (%r12), %rdx
addq $0x18, %rdx
movl 0xc(%r12), %ecx
addq $0x18, %r8
leaq 0xd676(%rip), %rsi      # 0x215ba
xorl %eax, %eax
callq 0x10eda
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13f56
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x50, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xfb80
movq 0x20(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq $0x0, 0x18(%rax)
jle 0x144b2
movq %rbx, %rdi
callq 0xd766
xorl %r15d, %r15d
movl $0xd0, %edx
movq %rbx, %rdi
movl $0x8, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xcb24
movq %rax, %r14
movq 0x10(%rbx), %rax
movq %r14, (%rax)
movl $0x48, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movq %r15, 0x38(%r14)
movq %r15, 0x20(%r14)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r14)
movups %xmm0, 0x58(%r14)
movw $0x100, 0x48(%r14)      # imm = 0x100
movl $0x0, 0x4c(%r14)
movb $0x0, 0xa(%r14)
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 0x1454f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1463d
pushq %rbx
movq %rdi, %rbx
leaq 0x80(%rdi), %rax
movq %rax, 0x20(%rdi)
callq 0x14458
movq 0x38(%rbx), %rsi
movslq 0x40(%rbx), %rdx
shlq $0x4, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
popq %rbx
jmp 0xfb80
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r12
movq %rdi, %rsi
callq 0x1454f
movq %rbx, %rdi
callq 0x1709b
movq %rax, %r14
movq %rax, 0x40(%r12)
movl $0x45, %ebp
movl %ebp, 0x48(%r12)
movq %rbx, %rdi
movq %rax, %rsi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x16c6f
movq %rsp, %r15
movq %rbx, (%r15)
movl $0x48, 0x8(%r15)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movq %r15, %rcx
callq 0x16fda
movq %rbx, %rdi
callq 0x1709b
movq %rax, (%r15)
movl %ebp, 0x8(%r15)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
movq %r15, %rcx
callq 0x16fda
movq %rbx, %rdi
movl $0x20, %esi
callq 0x14a50
movq %rbx, %rdi
callq 0x181ac
movq %rbx, %rdi
callq 0x1e47c
leaq 0xb75a(%rip), %rsi      # 0x20025
movl $0x11, %edx
movq %rbx, %rdi
callq 0x14b50
movq %rax, 0x118(%r12)
orb $0x20, 0x9(%rax)
movb $0x1, 0x57(%r12)
xorl %edi, %edi
callq 0x763a
movq %rax, 0x110(%r12)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x149c5
movq 0x10(%rdi), %rdx
xorl %eax, %eax
cmpq 0x10(%rsi), %rdx
jne 0x149c4
pushq %rax
addq $0x18, %rdi
addq $0x18, %rsi
callq 0x63f0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addq $0x8, %rsp
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0x14a4f
movq %rsi, %rcx
shrq $0x5, %rcx
movq %rcx, %rdx
notq %rdx
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
cmpq %rcx, %rsi
ja 0x14a2a
retq
// File: /workspace/github_c_makefile_star2_O3/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), %r15
movl $0xfffffffb, %esi       # imm = 0xFFFFFFFB
callq 0xcc93
movl 0x3c(%r15), %eax
cmpl %ebx, %eax
jge 0x14abd
cmpl $-0x2, %ebx
jle 0x14b48
movslq %eax, %rdx
movq 0x30(%r15), %rsi
shlq $0x3, %rdx
movslq %ebx, %r12
leaq (,%r12,8), %rcx
movq %r14, %rdi
callq 0xfb80
movq %rax, 0x30(%r15)
movl 0x3c(%r15), %eax
cmpl %ebx, %eax
jge 0x14abd
movslq %eax, %rcx
movq 0x30(%r15), %rdx
movq $0x0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %r12
jne 0x14aa9
testl %eax, %eax
jle 0x14b11
leal -0x1(%rbx), %ecx
xorl %edx, %edx
movq 0x30(%r15), %rdi
movq (%rdi,%rdx,8), %rsi
movq $0x0, (%rdi,%rdx,8)
testq %rsi, %rsi
je 0x14b06
movq (%rsi), %rax
movl 0xc(%rsi), %edi
andl %ecx, %edi
movq 0x30(%r15), %r8
movq (%r8,%rdi,8), %r8
movq %r8, (%rsi)
movq 0x30(%r15), %r8
movq %rsi, (%r8,%rdi,8)
andb $-0x41, 0x9(%rsi)
movq %rax, %rsi
testq %rax, %rax
jne 0x14adb
movl 0x3c(%r15), %eax
incq %rdx
movslq %eax, %rsi
cmpq %rsi, %rdx
jl 0x14ac6
cmpl %ebx, %eax
jle 0x14b38
cmpl $-0x2, %ebx
jle 0x14b48
movq 0x30(%r15), %rsi
movslq %eax, %rdx
shlq $0x3, %rdx
movslq %ebx, %rcx
shlq $0x3, %rcx
movq %r14, %rdi
callq 0xfb80
movq %rax, 0x30(%r15)
movl %ebx, 0x3c(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0xfb71
// File: /workspace/github_c_makefile_star2_O3/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 0x14bff
movq %rdi, (%rsp)
movq 0x18(%rdi), %r8
movl 0x50(%r8), %ebp
xorl %ebx, %ebp
testq %rbx, %rbx
je 0x14baf
movq %rbx, %rax
shrq $0x5, %rax
movq %rax, %rcx
notq %rcx
movq %rbx, %rdx
movl %ebp, %esi
shll $0x5, %esi
movl %ebp, %edi
shrl $0x2, %edi
addl %esi, %edi
movzbl -0x1(%r14,%rdx), %esi
addl %edi, %esi
xorl %esi, %ebp
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x14b91
movq 0x30(%r8), %rcx
movq %r8, 0x8(%rsp)
movl 0x3c(%r8), %r13d
leal -0x1(%r13), %eax
andl %ebp, %eax
movslq %eax, %r15
movq %rcx, 0x10(%rsp)
movq (%rcx,%r15,8), %r12
testq %r12, %r12
je 0x14c51
cmpl 0xc(%r12), %ebp
jne 0x14bf9
cmpq %rbx, 0x10(%r12)
jne 0x14bf9
leaq 0x18(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x63f0
testl %eax, %eax
je 0x14cf8
movq (%r12), %r12
jmp 0x14bce
leaq 0x1b(%rbx), %rax
cmpq $0x19, %rax
jbe 0x14d15
movq 0x18(%rdi), %rax
movl 0x50(%rax), %ebp
leaq 0x19(%rbx), %rdx
xorl %r15d, %r15d
movl $0x14, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xcb24
movq %rax, %r12
movq %rbx, 0x10(%rax)
movl %ebp, 0xc(%rax)
movb %r15b, 0xa(%rax)
leaq 0x18(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6360
movb %r15b, 0x18(%r12,%rbx)
jmp 0x14ce6
cmpl $0x3ffffffe, %r13d      # imm = 0x3FFFFFFE
jg 0x14c97
movq 0x8(%rsp), %r12
cmpl %r13d, 0x38(%r12)
movq (%rsp), %rdi
jb 0x14ca0
addl %r13d, %r13d
movq (%rsp), %rdi
movl %r13d, %esi
callq 0x14a50
movq (%rsp), %rdi
movslq 0x3c(%r12), %rax
movq 0x30(%r12), %rcx
movq %rcx, 0x10(%rsp)
decq %rax
movslq %ebp, %r15
andq %rax, %r15
jmp 0x14ca0
movq 0x8(%rsp), %r12
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
leaq (%rax,%r15,8), %rcx
leaq 0x19(%rbx), %rdx
xorl %r15d, %r15d
movl $0x4, %esi
xorl %r8d, %r8d
callq 0xcb24
movq %r12, %r13
movq %rax, %r12
movq %rbx, 0x10(%rax)
movl %ebp, 0xc(%rax)
movb %r15b, 0xa(%rax)
leaq 0x18(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6360
movb %r15b, 0x18(%r12,%rbx)
incl 0x38(%r13)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb 0x9(%r12), %al
xorb $0x3, %al
movq 0x8(%rsp), %rcx
movb 0x54(%rcx), %cl
xorb $0x3, %cl
testb %al, %cl
jne 0x14ce6
movb %al, 0x9(%r12)
jmp 0x14ce6
callq 0xfb71
// File: /workspace/github_c_makefile_star2_O3/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 0x14d7c
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x28(%rsi), %rdx
movl $0x7, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xcb24
movq %r14, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xfb71
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x9690
movq %rax, %r14
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x98a0
movq %rax, %r15
testq %rax, %rax
jns 0x14e77
movq 0x8(%rsp), %rax
movq %r15, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x14e71
xorl %r15d, %r15d
jmp 0x14e77
addq %rax, %r15
incq %r15
movq %rbx, %rdi
movl $0x3, %esi
movq %r15, %rdx
callq 0x98a0
movq 0x8(%rsp), %rcx
testq %rax, %rax
jns 0x14ea6
movq %rax, %rdx
negq %rdx
cmpq %rdx, %rcx
jae 0x14ea0
xorl %eax, %eax
jmp 0x14ea6
addq %rcx, %rax
incq %rax
cmpq $0x1, %r15
adcq $0x0, %r15
cmpq %rcx, %rax
cmovbq %rax, %rcx
xorl %ebp, %ebp
cmpq %r15, %rcx
jb 0x14f22
movl %ecx, %r12d
subl %r15d, %r12d
leal 0x1(%r12), %ebp
movslq %ebp, %rax
addq %r15, %rax
cmpq %rcx, %rax
jbe 0x14f0f
leaq 0xc94f(%rip), %rdx      # 0x21828
movq %rbx, %rdi
movl %ebp, %esi
callq 0x96ca
cmpl $0x7ffffffe, %r12d      # imm = 0x7FFFFFFE
ja 0x14f22
addq %r15, %r14
decq %r14
movl %ebp, %r15d
xorl %r12d, %r12d
movzbl (%r14,%r12), %esi
movq %rbx, %rdi
callq 0x7e95
incq %r12
cmpq %r12, %r15
jne 0x14ef8
jmp 0x14f22
leaq 0xc912(%rip), %rsi      # 0x21828
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9144
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq