LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lvm.c
// Function: luaV_equalobj_
int luaV_equalobj_ (lua_State *L, const TValue *t1, const TValue *t2) {
  const TValue *tm;
  lua_assert(ttisequal(t1, t2));
  switch (ttype(t1)) {
    case LUA_TNIL: return 1;
    case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2));
    case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2);  /* true must be 1 !! */
    case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
    case LUA_TLCF: return fvalue(t1) == fvalue(t2);
    case LUA_TSHRSTR: return eqshrstr(rawtsvalue(t1), rawtsvalue(t2));
    case LUA_TLNGSTR: return luaS_eqlngstr(rawtsvalue(t1), rawtsvalue(t2));
    case LUA_TUSERDATA: {
      if (uvalue(t1) == uvalue(t2)) return 1;
      else if (L == NULL) return 0;
      tm = get_equalTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable, TM_EQ);
      break;  /* will try TM */
    }
    case LUA_TTABLE: {
      if (hvalue(t1) == hvalue(t2)) return 1;
      else if (L == NULL) return 0;
      tm = get_equalTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);
      break;  /* will try TM */
    }
    default:
      lua_assert(iscollectable(t1));
      return gcvalue(t1) == gcvalue(t2);
  }
  if (tm == NULL) return 0;  /* no TM? */
  callTM(L, tm, t1, t2, L->top, 1);  /* call TM */
  return !l_isfalse(L->top);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl 0x8(%rsi), %eax
andl $0x3f, %eax
cmpl $0x7, %eax
ja 0x1754d
movq %rdi, %r12
pushq $0x1
popq %rbx
leaq 0x887c(%rip), %rcx      # 0x1fd5c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r15), %rax
movq (%r14), %rcx
cmpq %rcx, %rax
je 0x17560
testq %r12, %r12
je 0x175a3
movq 0x10(%rax), %rsi
movq 0x10(%rcx), %rdx
movq %r12, %rdi
callq 0x175ab
testq %rax, %rax
je 0x175a3
movq 0x10(%r12), %r8
pushq $0x1
popq %rbx
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r9d
callq 0x170ee
movq 0x10(%r12), %rax
movl 0x8(%rax), %ecx
testl %ecx, %ecx
je 0x175a7
cmpl $0x1, %ecx
jne 0x17560
xorl %ebx, %ebx
cmpl $0x0, (%rax)
setne %bl
jmp 0x17560
cmpl $0x14, %eax
je 0x1758d
cmpl $0x16, %eax
movq (%r15), %rax
xorl %ebx, %ebx
cmpq (%r14), %rax
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl (%r15), %eax
xorl %ebx, %ebx
cmpl (%r14), %eax
jmp 0x1755d
movsd (%r14), %xmm0
cmpeqsd (%r15), %xmm0
movq %xmm0, %rbx
andl $0x1, %ebx
jmp 0x17560
movq (%r15), %rdi
movq (%r14), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x135d8
xorl %ebx, %ebx
jmp 0x17560
movl %ecx, %ebx
jmp 0x17560
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lvm.c
// Function: get_equalTM
static const TValue *get_equalTM (lua_State *L, Table *mt1, Table *mt2,
                                  TMS event) {
  const TValue *tm1 = fasttm(L, mt1, event);
  const TValue *tm2;
  if (tm1 == NULL) return NULL;  /* no metamethod */
  if (mt1 == mt2) return tm1;  /* same metatables => same metamethods */
  tm2 = fasttm(L, mt2, event);
  if (tm2 == NULL) return NULL;  /* no metamethod */
  if (luaV_rawequalobj(tm1, tm2))  /* same metamethods? */
    return tm1;
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1762a
movq %rsi, %r12
testb $0x20, 0xa(%rsi)
jne 0x1762a
movq %rdx, %r14
movq %rdi, %r15
movq 0x18(%rdi), %rax
movq 0x148(%rax), %rdx
pushq $0x5
popq %rsi
movq %r12, %rdi
callq 0x1694f
testq %rax, %rax
je 0x1762a
movq %rax, %rbx
cmpq %r14, %r12
je 0x1762c
testq %r14, %r14
je 0x1762a
testb $0x20, 0xa(%r14)
jne 0x1762a
movq 0x18(%r15), %rax
movq 0x148(%rax), %rdx
pushq $0x5
popq %rsi
movq %r14, %rdi
callq 0x1694f
testq %rax, %rax
je 0x1762a
movl 0x8(%rbx), %ecx
cmpl 0x8(%rax), %ecx
jne 0x1762a
xorl %edi, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x174ba
testl %eax, %eax
jne 0x1762c
xorl %ebx, %ebx
movq %rbx, %rax
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/lvm.c
// Function: call_binTM
static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,
                       StkId res, TMS event) {
  const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
  if (ttisnil(tm))
    tm = luaT_gettmbyobj(L, p2, event);  /* try second operand */
  if (ttisnil(tm)) return 0;
  callTM(L, tm, p1, p2, res, 1);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl %r8d, %edx
callq 0x16978
cmpl $0x0, 0x8(%rax)
jne 0x17898
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x16978
cmpl $0x0, 0x8(%rax)
je 0x178bd
pushq $0x1
popq %rbp
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movl %ebp, %r9d
callq 0x170ee
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x178b2
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lvm.c
// Function: luaV_objlen
void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) {
  const TValue *tm;
  switch (ttypenv(rb)) {
    case LUA_TTABLE: {
      Table *h = hvalue(rb);
      tm = fasttm(L, h->metatable, TM_LEN);
      if (tm) break;  /* metamethod? break switch to call it */
      setnvalue(ra, cast_num(luaH_getn(h)));  /* else primitive len */
      return;
    }
    case LUA_TSTRING: {
      setnvalue(ra, cast_num(tsvalue(rb)->len));
      return;
    }
    default: {  /* try metamethod */
      tm = luaT_gettmbyobj(L, rb, TM_LEN);
      if (ttisnil(tm))  /* no metamethod? */
        luaG_typeerror(L, rb, "get length of");
      break;
    }
  }
  callTM(L, tm, rb, rb, ra, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl 0x8(%rdx), %eax
andl $0xf, %eax
cmpl $0x4, %eax
je 0x1791f
movq %rdi, %r15
cmpl $0x5, %eax
jne 0x17959
movq (%r14), %r12
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x1790d
testb $0x10, 0xa(%rdi)
jne 0x1790d
movq 0x18(%r15), %rax
movq 0x140(%rax), %rdx
pushq $0x4
popq %rsi
callq 0x1694f
testq %rax, %rax
jne 0x1796d
movq %r12, %rdi
callq 0x15fba
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rbx)
jmp 0x17946
movq (%r14), %rax
movsd 0x10(%rax), %xmm0
unpcklps 0x7db2(%rip), %xmm0     # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x7dba(%rip), %xmm0     # 0x1f6f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
movl $0x3, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x4
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x16978
cmpl $0x0, 0x8(%rax)
je 0x17990
pushq $0x1
popq %r9
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x170ee
leaq 0x8562(%rip), %rdx      # 0x1fef9
movq %r15, %rdi
movq %r14, %rsi
callq 0xa6bd
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lvm.c
// Function: luaV_arith
void luaV_arith (lua_State *L, StkId ra, const TValue *rb,
                 const TValue *rc, TMS op) {
  TValue tempb, tempc;
  const TValue *b, *c;
  if ((b = luaV_tonumber(rb, &tempb)) != NULL &&
      (c = luaV_tonumber(rc, &tempc)) != NULL) {
    lua_Number res = luaO_arith(op - TM_ADD + LUA_OPADD, nvalue(b), nvalue(c));
    setnvalue(ra, res);
  }
  else if (!call_binTM(L, rb, rc, ra, op))
    luaG_aritherror(L, rb, rc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x18(%rsp), %rsi
movq %rdx, %rdi
callq 0x16f50
testq %rax, %rax
je 0x17a07
movq %rax, %r13
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x16f50
testq %rax, %rax
je 0x17a07
addl $-0x6, %ebp
movsd (%r13), %xmm0
movsd (%rax), %xmm1
movl %ebp, %edi
callq 0xfa52
movsd %xmm0, (%rbx)
movl $0x3, 0x8(%rbx)
jmp 0x17a1f
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x17860
testl %eax, %eax
je 0x17a2e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xab42
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lzio.c
// Function: luaZ_openspace
char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) {
  if (n > buff->buffsize) {
    if (n < LUA_MINBUFFER) n = LUA_MINBUFFER;
    luaZ_resizebuffer(L, buff, n);
  }
  return buff->buffer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %rbx
movq 0x10(%rsi), %rdx
cmpq %rax, %rdx
jae 0x18eca
cmpq $0x21, %rax
pushq $0x20
popq %r14
cmovaeq %rax, %r14
leaq 0x3(%r14), %rax
cmpq $0x1, %rax
jbe 0x18ed5
movq (%rbx), %rsi
movq %r14, %rcx
callq 0xed73
movq %rax, (%rbx)
movq %r14, 0x10(%rbx)
jmp 0x18ecd
movq (%rbx), %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/lbaselib.c
// Function: luaopen_base
LUAMOD_API int luaopen_base (lua_State *L) {
  /* set global _G */
  lua_pushglobaltable(L);
  lua_pushglobaltable(L);
  lua_setfield(L, -2, "_G");
  /* open lib into global table */
  luaL_setfuncs(L, base_funcs, 0);
  lua_pushliteral(L, LUA_VERSION);
  lua_setfield(L, -2, "_VERSION");  /* set global _VERSION */
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %rbp
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movl %ebp, %edx
callq 0x7e9f
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movl %ebp, %edx
callq 0x7e9f
leaq 0x5b37(%rip), %rdx      # 0x1ea3e
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x809d
leaq 0x13985(%rip), %rsi     # 0x2c8a0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9c9a
leaq 0x7044(%rip), %rsi      # 0x1ff70
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0x7b27
leaq 0x703a(%rip), %rdx      # 0x1ff78
movq %rbx, %rdi
movl %ebp, %esi
callq 0x809d
pushq $0x1
popq %rax
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/lbaselib.c
// Function: luaB_collectgarbage
static int luaB_collectgarbage (lua_State *L) {
  static const char *const opts[] = {"stop", "restart", "collect",
    "count", "step", "setpause", "setstepmul",
    "setmajorinc", "isrunning", "generational", "incremental", NULL};
  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
    LUA_GCSETMAJORINC, LUA_GCISRUNNING, LUA_GCGEN, LUA_GCINC};
  int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
  int ex = luaL_optint(L, 2, 0);
  int res = lua_gc(L, o, ex);
  switch (o) {
    case LUA_GCCOUNT: {
      int b = lua_gc(L, LUA_GCCOUNTB, 0);
      lua_pushnumber(L, res + ((lua_Number)b/1024));
      lua_pushinteger(L, b);
      return 2;
    }
    case LUA_GCSTEP: case LUA_GCISRUNNING: {
      lua_pushboolean(L, res);
      return 1;
    }
    default: {
      lua_pushinteger(L, res);
      return 1;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x7074(%rip), %rdx      # 0x2001a
leaq 0x13a63(%rip), %rcx     # 0x2ca10
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x918e
cltq
leaq 0x71d0(%rip), %rcx      # 0x20190
movl (%rcx,%rax,4), %r15d
pushq $0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x9456
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x858f
movl %eax, %r12d
cmpl $0x9, %r15d
je 0x19033
cmpl $0x5, %r15d
je 0x19033
cmpl $0x3, %r15d
jne 0x19040
pushq $0x4
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x858f
movl %eax, %ebp
cvtsi2sd %r12d, %xmm1
cvtsi2sd %eax, %xmm0
mulsd 0x6f51(%rip), %xmm0     # 0x1ff68
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x7adc
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x7af1
movl %r14d, %ebp
jmp 0x1904b
movq %rbx, %rdi
movl %r12d, %esi
callq 0x7d3d
jmp 0x1904b
movslq %r12d, %rsi
movq %rbx, %rdi
callq 0x7af1
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/lbaselib.c
// Function: luaB_dofile
static int luaB_dofile (lua_State *L) {
  const char *fname = luaL_optstring(L, 1, NULL);
  lua_settop(L, 1);
  if (luaL_loadfile(L, fname) != LUA_OK)
    return lua_error(L);
  lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);
  return dofilecont(L);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x920b
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7437
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x9776
testl %eax, %eax
je 0x19095
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x86c3
leaq 0x876(%rip), %r8        # 0x19912
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x835f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x19912
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lbaselib.c
// Function: luaB_error
static int luaB_error (lua_State *L) {
  int level = luaL_optint(L, 2, 1);
  lua_settop(L, 1);
  if (lua_isstring(L, 1) && level > 0) {  /* add extra information? */
    luaL_where(L, level);
    lua_pushvalue(L, 1);
    lua_concat(L, 2);
  }
  return lua_error(L);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x9456
movq %rax, %r14
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7437
movq %rbx, %rdi
movl %ebp, %esi
callq 0x76a0
testl %eax, %eax
setne %al
testl %r14d, %r14d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x19116
movq %rbx, %rdi
movl %r14d, %esi
callq 0x8ea0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x7604
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x8700
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x86c3
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lbaselib.c
// Function: luaB_pcall
static int luaB_pcall (lua_State *L) {
  int status;
  luaL_checkany(L, 1);
  lua_pushnil(L);
  lua_insert(L, 1);  /* create space for status result */
  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, pcallcont);
  return finishpcall(L, (status == LUA_OK));
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x9331
movq %rbx, %rdi
callq 0x7acb
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7537
movq %rbx, %rdi
callq 0x7423
leal -0x2(%rax), %esi
leaq 0x7c9(%rip), %r9        # 0x19b0e
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x83be
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x19b28
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lbaselib.c
// Function: luaB_print
static int luaB_print (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  lua_getglobal(L, "tostring");
  for (i=1; i<=n; i++) {
    const char *s;
    size_t l;
    lua_pushvalue(L, -1);  /* function to be called */
    lua_pushvalue(L, i);   /* value to print */
    lua_call(L, 1, 1);
    s = lua_tolstring(L, -1, &l);  /* get result */
    if (s == NULL)
      return luaL_error(L,
         LUA_QL("tostring") " must return a string to " LUA_QL("print"));
    if (i>1) luai_writestring("\t", 1);
    luai_writestring(s, l);
    lua_pop(L, 1);  /* pop result */
  }
  luai_writeline();
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7423
movl %eax, %r14d
leaq 0x4e99(%rip), %rsi      # 0x1e221
movq %rbx, %rdi
callq 0x7d8f
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
negl %r14d
pushq $0x1
popq %rbp
pushq $-0x1
popq %r15
movl %ebp, %r13d
leal (%r14,%r13), %eax
cmpl $0x1, %eax
je 0x19434
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7604
movq %rbx, %rdi
movl %r13d, %esi
callq 0x7604
movq %rbx, %rdi
movl %ebp, %esi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x835f
movq %rbx, %rdi
movl %r15d, %esi
movq %rsp, %rdx
callq 0x7967
testq %rax, %rax
je 0x19452
movq %rax, %r12
cmpl $0x2, %r13d
jb 0x19408
movq 0x13bcb(%rip), %rax     # 0x2cfc8
movq (%rax), %rsi
pushq $0x9
popq %rdi
callq 0x6250
movq (%rsp), %rdx
movq 0x13bb5(%rip), %rax     # 0x2cfc8
movq (%rax), %rcx
movq %r12, %rdi
pushq $0x1
popq %rsi
callq 0x6540
movq %rbx, %rdi
pushq $-0x2
popq %rsi
callq 0x7437
incl %r13d
jmp 0x193a6
movq 0x13b8d(%rip), %rbx     # 0x2cfc8
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x6250
movq (%rbx), %rdi
callq 0x63b0
xorl %eax, %eax
jmp 0x19463
leaq 0x6c7e(%rip), %rsi      # 0x200d7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8d68
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/lbaselib.c
// Function: luaB_select
static int luaB_select (lua_State *L) {
  int n = lua_gettop(L);
  if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
    lua_pushinteger(L, n-1);
    return 1;
  }
  else {
    int i = luaL_checkint(L, 1);
    if (i < 0) i = n + i;
    else if (i > n) i = n;
    luaL_argcheck(L, 1 <= i, 1, "index out of range");
    return n - i;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x7423
movl %eax, %ebx
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x7624
cmpl $0x4, %eax
jne 0x195c3
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7967
cmpb $0x23, (%rax)
jne 0x195c3
decl %ebx
movslq %ebx, %rsi
movq %r14, %rdi
callq 0x7af1
jmp 0x195f7
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x93db
leal (%rbx,%rax), %ecx
cmpl %eax, %ebx
movl %eax, %ebp
cmovll %ebx, %ebp
testl %eax, %eax
cmovsl %ecx, %ebp
testl %ebp, %ebp
jg 0x195f3
leaq 0x6b33(%rip), %rdx      # 0x2011b
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x8c84
subl %ebp, %ebx
movl %ebx, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lbaselib.c
// Function: luaB_xpcall
static int luaB_xpcall (lua_State *L) {
  int status;
  int n = lua_gettop(L);
  luaL_argcheck(L, n >= 2, 2, "value expected");
  lua_pushvalue(L, 1);  /* exchange function... */
  lua_copy(L, 2, 1);  /* ...and error handler */
  lua_replace(L, 2);
  status = lua_pcallk(L, n - 2, LUA_MULTRET, 1, 0, pcallcont);
  return finishpcall(L, (status == LUA_OK));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7423
movl %eax, %ebp
cmpl $0x1, %eax
jg 0x198af
leaq 0x4c25(%rip), %rdx      # 0x1e4c9
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x8c84
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x7604
pushq $0x2
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x75e5
movq %rbx, %rdi
movl %r15d, %esi
callq 0x756e
addl $-0x2, %ebp
leaq 0x229(%rip), %r9        # 0x19b0e
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x83be
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x19b28
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lbaselib.c
// Function: pairsmeta
static int pairsmeta (lua_State *L, const char *method, int iszero,
                      lua_CFunction iter) {
  if (!luaL_getmetafield(L, 1, method)) {  /* no metamethod? */
    luaL_checktype(L, 1, LUA_TTABLE);  /* argument must be a table */
    lua_pushcfunction(L, iter);  /* will return generator, */
    lua_pushvalue(L, 1);  /* state, */
    if (iszero) lua_pushinteger(L, 0);  /* and initial value */
    else lua_pushnil(L);
  }
  else {
    lua_pushvalue(L, 1);  /* argument 'self' to metamethod */
    lua_call(L, 1, 3);  /* get 3 values from metamethod */
  }
  return 3;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %rdx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x9ac7
testl %eax, %eax
je 0x19963
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7604
pushq $0x3
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x835f
pushq $0x1
popq %r15
pushq $0x5
popq %rdx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x92e7
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7cba
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7604
movq %rbx, %rdi
testl %ebp, %ebp
je 0x199a5
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7af1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7acb
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lbaselib.c
// Function: ipairsaux
static int ipairsaux (lua_State *L) {
  int i = luaL_checkint(L, 2);
  luaL_checktype(L, 1, LUA_TTABLE);
  i++;  /* next value */
  lua_pushinteger(L, i);
  lua_rawgeti(L, 1, i);
  return (lua_isnil(L, -1)) ? 1 : 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x2
popq %rbx
movl %ebx, %esi
callq 0x93db
movq %rax, %r15
pushq $0x1
popq %rbp
pushq $0x5
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x92e7
incl %r15d
movslq %r15d, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7af1
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x7e9f
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x7624
cmpl $0x1, %eax
sbbl $0x0, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lbaselib.c
// Function: finishpcall
static int finishpcall (lua_State *L, int status) {
  if (!lua_checkstack(L, 1)) {  /* no space for extra boolean? */
    lua_settop(L, 0);  /* create space for return values */
    lua_pushboolean(L, 0);
    lua_pushstring(L, "stack overflow");
    return 2;  /* return false, msg */
  }
  lua_pushboolean(L, status);  /* first result (status) */
  lua_replace(L, 1);  /* put first result in first slot */
  return lua_gettop(L);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7300
movq %rbx, %rdi
testl %eax, %eax
je 0x19b5f
movl %ebp, %esi
callq 0x7d3d
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x756e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7423
xorl %esi, %esi
callq 0x7437
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7d3d
leaq 0x4ceb(%rip), %rsi      # 0x1e862
movq %rbx, %rdi
callq 0x7b76
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lbitlib.c
// Function: b_arshift
static int b_arshift (lua_State *L) {
  b_uint r = luaL_checkunsigned(L, 1);
  int i = luaL_checkint(L, 2);
  if (i < 0 || !(r & ((b_uint)1 << (LUA_NBITS - 1))))
    return b_shift(L, r, -i);
  else {  /* arithmetic shift for 'negative' number */
    if (i >= LUA_NBITS) r = ALLONES;
    else
      r = trim((r >> i) | ~(~(b_uint)0 >> i));  /* add signal bit */
    lua_pushunsigned(L, r);
    return 1;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x941b
movl %eax, %ebp
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x93db
testl %eax, %eax
sets %cl
testl %ebp, %ebp
setns %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x19bec
negl %eax
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x19e77
jmp 0x19c09
movl %eax, %ecx
shrl %cl, %ebp
pushq $-0x1
popq %rdx
movl %edx, %esi
shrl %cl, %esi
notl %esi
orl %ebp, %esi
cmpl $0x20, %eax
cmovael %edx, %esi
movq %rbx, %rdi
callq 0x7b0b
pushq $0x1
popq %rax
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/lbitlib.c
// Function: b_or
static int b_or (lua_State *L) {
  int i, n = lua_gettop(L);
  b_uint r = 0;
  for (i = 1; i <= n; i++)
    r |= luaL_checkunsigned(L, i);
  lua_pushunsigned(L, trim(r));
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7423
movl %eax, %r14d
xorl %ebp, %ebp
testl %eax, %eax
cmovlel %ebp, %r14d
negl %r14d
pushq $0x1
popq %r15
leal (%r14,%r15), %eax
cmpl $0x1, %eax
je 0x19c8c
movq %rbx, %rdi
movl %r15d, %esi
callq 0x941b
orl %eax, %ebp
incl %r15d
jmp 0x19c71
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7b0b
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lbitlib.c
// Function: b_extract
static int b_extract (lua_State *L) {
  int w;
  b_uint r = luaL_checkunsigned(L, 1);
  int f = fieldargs(L, 2, &w);
  r = (r >> f) & mask(w);
  lua_pushunsigned(L, r);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x941b
movl %eax, %ebp
pushq $0x2
popq %rsi
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x19ee9
movl %eax, %ecx
shrl %cl, %ebp
movb (%r15), %cl
decb %cl
pushq $-0x2
popq %rsi
shll %cl, %esi
notl %esi
andl %ebp, %esi
movq %r14, %rdi
callq 0x7b0b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lbitlib.c
// Function: b_replace
static int b_replace (lua_State *L) {
  int w;
  b_uint r = luaL_checkunsigned(L, 1);
  b_uint v = luaL_checkunsigned(L, 2);
  int f = fieldargs(L, 3, &w);
  int m = mask(w);
  v &= m;  /* erase bits outside given width */
  r = (r & ~(m << f)) | (v << f);
  lua_pushunsigned(L, r);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x941b
movl %eax, %r15d
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x941b
movl %eax, %ebp
pushq $0x3
popq %rsi
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x19ee9
movb (%r12), %cl
decb %cl
pushq $-0x2
popq %rdx
shll %cl, %edx
movl %eax, %ecx
notl %edx
andl %edx, %ebp
shll %cl, %edx
notl %edx
andl %r15d, %edx
shll %cl, %ebp
orl %edx, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x7b0b
movl %ebx, %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/lbitlib.c
// Function: b_shift
static int b_shift (lua_State *L, b_uint r, int i) {
  if (i < 0) {  /* shift right? */
    i = -i;
    r = trim(r);
    if (i >= LUA_NBITS) r = 0;
    else r >>= i;
  }
  else {  /* shift left */
    if (i >= LUA_NBITS) r = 0;
    else r <<= i;
    r = trim(r);
  }
  lua_pushunsigned(L, r);
  return 1;
}

// Assembly:
testl %edx, %edx
js 0x19e89
movl %edx, %ecx
shll %cl, %esi
xorl %eax, %eax
cmpl $0x20, %edx
cmovbl %esi, %eax
jmp 0x19e98
xorl %eax, %eax
cmpl $-0x1f, %edx
jb 0x19e98
negb %dl
movl %edx, %ecx
shrl %cl, %esi
movl %esi, %eax
movl %eax, %esi
jmp 0x7b0b
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lbitlib.c
// Function: andaux
static b_uint andaux (lua_State *L) {
  int i, n = lua_gettop(L);
  b_uint r = ~(b_uint)0;
  for (i = 1; i <= n; i++)
    r &= luaL_checkunsigned(L, i);
  return trim(r);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7423
xorl %r15d, %r15d
testl %eax, %eax
cmovgl %eax, %r15d
negl %r15d
pushq $-0x1
popq %rbp
pushq $0x1
popq %r14
leal (%r15,%r14), %eax
cmpl $0x1, %eax
je 0x19edc
movq %rbx, %rdi
movl %r14d, %esi
callq 0x941b
andl %eax, %ebp
incl %r14d
jmp 0x19ec1
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lbitlib.c
// Function: fieldargs
static int fieldargs (lua_State *L, int farg, int *width) {
  int f = luaL_checkint(L, farg);
  int w = luaL_optint(L, farg + 1, 1);
  luaL_argcheck(L, 0 <= f, farg, "field cannot be negative");
  luaL_argcheck(L, 0 < w, farg + 1, "width must be positive");
  if (f + w > LUA_NBITS)
    luaL_error(L, "trying to access non-existent bits");
  *width = w;
  return f;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r13d
movq %rdi, %r15
callq 0x93db
movq %rax, %r14
leal 0x1(%r13), %ebp
pushq $0x1
popq %rdx
movq %r15, %rdi
movl %ebp, %esi
callq 0x9456
movq %rax, %r12
testl %r14d, %r14d
jns 0x19f30
leaq 0x62df(%rip), %rdx      # 0x20204
movq %r15, %rdi
movl %r13d, %esi
callq 0x8c84
testl %r12d, %r12d
jg 0x19f46
leaq 0x62e1(%rip), %rdx      # 0x2021d
movq %r15, %rdi
movl %ebp, %esi
callq 0x8c84
leal (%r12,%r14), %eax
cmpl $0x21, %eax
jl 0x19f60
leaq 0x62de(%rip), %rsi      # 0x20234
movq %r15, %rdi
xorl %eax, %eax
callq 0x8d68
movl %r12d, (%rbx)
movl %r14d, %eax
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/lbitlib.c
// Function: b_rot
static int b_rot (lua_State *L, int i) {
  b_uint r = luaL_checkunsigned(L, 1);
  i &= (LUA_NBITS - 1);  /* i = i % NBITS */
  r = trim(r);
  if (i != 0)  /* avoid undefined shift of LUA_NBITS when i == 0 */
    r = (r << i) | (r >> (LUA_NBITS - i));
  lua_pushunsigned(L, trim(r));
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0x941b
movl %eax, %esi
movl %ebx, %ecx
roll %cl, %esi
testb $0x1f, %bl
cmovel %eax, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7b0b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_concat
void luaK_concat (FuncState *fs, int *l1, int l2) {
  if (l2 == NO_JUMP) return;
  else if (*l1 == NO_JUMP)
    *l1 = l2;
  else {
    int list = *l1;
    int next;
    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */
      list = next;
    fixjump(fs, list, l2);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $-0x1, %edx
je 0x1a0f6
movl %edx, %ebx
movl (%rsi), %eax
cmpl $-0x1, %eax
je 0x1a0f4
movq %rdi, %r14
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
callq 0x1a1ed
cmpl $-0x1, %eax
jne 0x1a0d3
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x1a211
movl %ebx, (%rsi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_patchclose
LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level) {
  level++;  /* argument is +1 to reserve 0 as non-op */
  while (list != NO_JUMP) {
    int next = getjump(fs, list);
    lua_assert(GET_OPCODE(fs->f->code[list]) == OP_JMP &&
                (GETARG_A(fs->f->code[list]) == 0 ||
                 GETARG_A(fs->f->code[list]) >= level));
    SETARG_A(fs->f->code[list], level);
    list = next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
shll $0x6, %ebx
addl $0x40, %ebx
andl $0x3fc0, %ebx           # imm = 0x3FC0
movl $0xffffc03f, %r15d      # imm = 0xFFFFC03F
cmpl $-0x1, %ebp
je 0x1a1e2
movq %r14, %rdi
movl %ebp, %esi
callq 0x1a1ed
movslq %ebp, %rcx
movq (%r14), %rdx
movq 0x18(%rdx), %rdx
movl (%rdx,%rcx,4), %esi
andl %r15d, %esi
orl %ebx, %esi
movl %esi, (%rdx,%rcx,4)
movl %eax, %ebp
jmp 0x1a1ba
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_checkstack
void luaK_checkstack (FuncState *fs, int n) {
  int newstack = fs->freereg + n;
  if (newstack > fs->f->maxstacksize) {
    if (newstack >= MAXSTACK)
      luaX_syntaxerror(fs->ls, "function or expression too complex");
    fs->f->maxstacksize = cast_byte(newstack);
  }
}

// Assembly:
movzbl 0x44(%rdi), %eax
addl %esi, %eax
movq (%rdi), %rcx
movzbl 0x7a(%rcx), %edx
cmpl %edx, %eax
jle 0x1a37e
cmpl $0xfa, %eax
jae 0x1a37f
movb %al, 0x7a(%rcx)
retq
pushq %rax
movq 0x18(%rdi), %rdi
leaq 0x5fb9(%rip), %rsi      # 0x20344
callq 0x1c43d
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: addk
static int addk (FuncState *fs, TValue *key, TValue *v) {
  lua_State *L = fs->ls->L;
  TValue *idx = luaH_set(L, fs->h, key);
  Proto *f = fs->f;
  int k, oldsize;
  if (ttisnumber(idx)) {
    lua_Number n = nvalue(idx);
    lua_number2int(k, n);
    if (luaV_rawequalobj(&f->k[k], v))
      return k;
    /* else may be a collision (e.g., between 0.0 and "\0\0\0\0\0\0\0\0");
       go through and create a new entry for this value */
  }
  /* constant not found; create a new entry */
  oldsize = f->sizek;
  k = fs->nk;
  /* numerical value does not need GC barrier;
     table has no metatable, so it does not need to invalidate cache */
  setnvalue(idx, cast_num(k));
  luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants");
  while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
  setobj(L, &f->k[k], v);
  fs->nk++;
  luaC_barrier(L, f, v);
  return k;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r13
movq 0x8(%rdi), %rsi
movq 0x18(%rdi), %rax
movq 0x38(%rax), %rdi
movq %rdi, 0x8(%rsp)
callq 0x159e4
movq %rax, %rbp
movq (%r13), %r12
cmpl $0x3, 0x8(%rax)
jne 0x1a44a
movsd (%rbp), %xmm0
addsd 0x3eec(%rip), %xmm0     # 0x1e300
movsd %xmm0, 0x10(%rsp)
movslq 0x10(%rsp), %r15
movq 0x10(%r12), %rsi
movq %r15, %rax
shlq $0x4, %rax
movl 0x8(%rsi,%rax), %ecx
cmpl 0x8(%r14), %ecx
jne 0x1a44a
addq %rax, %rsi
xorl %edi, %edi
movq %r14, %rdx
callq 0x174ba
testl %eax, %eax
jne 0x1a500
movslq 0x54(%r12), %rbx
movl 0x34(%r13), %r15d
cvtsi2sd %r15d, %xmm0
movsd %xmm0, (%rbp)
movl $0x3, 0x8(%rbp)
movl 0x54(%r12), %ecx
cmpl %ecx, %r15d
jl 0x1a49c
leaq 0x54(%r12), %rdx
movq 0x10(%r12), %rsi
leaq 0x5f0b(%rip), %r9       # 0x2038a
pushq $0x10
popq %rcx
movq 0x8(%rsp), %rdi
movl $0x3ffffff, %r8d        # imm = 0x3FFFFFF
callq 0xece8
movq %rax, 0x10(%r12)
movl 0x54(%r12), %ecx
movslq %r15d, %rax
movslq %ecx, %rdx
movq 0x10(%r12), %rcx
movq %rbx, %rsi
shlq $0x4, %rsi
addq %rcx, %rsi
addq $0x8, %rsi
cmpq %rdx, %rbx
jge 0x1a4c6
incq %rbx
andl $0x0, (%rsi)
addq $0x10, %rsi
jmp 0x1a4b5
shlq $0x4, %rax
movq (%r14), %rdx
movq %rdx, (%rcx,%rax)
movl 0x8(%r14), %edx
movl %edx, 0x8(%rcx,%rax)
incl 0x34(%r13)
testb $0x40, %dl
je 0x1a500
movq (%r14), %rdx
testb $0x3, 0x9(%rdx)
je 0x1a500
testb $0x4, 0x9(%r12)
je 0x1a500
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xc0bc
movl %r15d, %eax
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/lcode.c
// Function: luaK_numberK
int luaK_numberK (FuncState *fs, lua_Number r) {
  int n;
  lua_State *L = fs->ls->L;
  TValue o;
  setnvalue(&o, r);
  if (r == 0 || luai_numisnan(NULL, r)) {  /* handle -0 and NaN */
    /* use raw representation as key to avoid numeric problems */
    setsvalue(L, L->top++, luaS_newlstr(L, (char *)&r, sizeof(r)));
    n = addk(fs, L->top - 1, &o);
    L->top--;
  }
  else
    n = addk(fs, &o, &o);  /* regular case */
  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movsd %xmm0, 0x18(%rsp)
movq 0x18(%rdi), %rax
movq 0x38(%rax), %rbx
movsd %xmm0, 0x8(%rsp)
movl $0x3, 0x10(%rsp)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
je 0x1a556
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x1a3cd
jmp 0x1a59a
movq 0x10(%rbx), %r15
leaq 0x10(%r15), %rax
movq %rax, 0x10(%rbx)
leaq 0x18(%rsp), %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x13766
movq %rax, (%r15)
movzbl 0x8(%rax), %eax
orl $0x40, %eax
movl %eax, 0x8(%r15)
movq 0x10(%rbx), %rsi
addq $-0x10, %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x1a3cd
addq $-0x10, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_setreturns
void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
  if (e->k == VCALL) {  /* expression is an open function call? */
    SETARG_C(getcode(fs, e), nresults+1);
  }
  else if (e->k == VVARARG) {
    SETARG_B(getcode(fs, e), nresults+1);
    SETARG_A(getcode(fs, e), fs->freereg);
    luaK_reserveregs(fs, 1);
  }
}

// Assembly:
movl (%rsi), %eax
cmpl $0xd, %eax
je 0x1a5d8
cmpl $0xc, %eax
jne 0x1a5d7
movq (%rdi), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0xff803fff, %esi       # imm = 0xFF803FFF
andl (%rax,%rcx,4), %esi
shll $0xe, %edx
addl $0x4000, %edx           # imm = 0x4000
andl $0x7fc000, %edx         # imm = 0x7FC000
orl %esi, %edx
movl %edx, (%rax,%rcx,4)
retq
movq (%rdi), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0x7fffff, %r8d         # imm = 0x7FFFFF
andl (%rax,%rcx,4), %r8d
shll $0x17, %edx
addl %r8d, %edx
addl $0x800000, %edx         # imm = 0x800000
movl %edx, (%rax,%rcx,4)
movslq 0x8(%rsi), %rcx
movl $0xffffc03f, %edx       # imm = 0xFFFFC03F
andl (%rax,%rcx,4), %edx
movzbl 0x44(%rdi), %esi
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax,%rcx,4)
pushq $0x1
popq %rsi
jmp 0x1a390
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_setoneret
void luaK_setoneret (FuncState *fs, expdesc *e) {
  if (e->k == VCALL) {  /* expression is an open function call? */
    e->k = VNONRELOC;
    e->u.info = GETARG_A(getcode(fs, e));
  }
  else if (e->k == VVARARG) {
    SETARG_B(getcode(fs, e), 2);
    e->k = VRELOCABLE;  /* can relocate its simple result */
  }
}

// Assembly:
movl (%rsi), %eax
cmpl $0xd, %eax
je 0x1a646
cmpl $0xc, %eax
jne 0x1a668
movl $0x6, (%rsi)
movq (%rdi), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsi), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x6, %eax
movzbl %al, %eax
movl %eax, 0x8(%rsi)
retq
movq (%rdi), %rax
movq 0x18(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0x7fffff, %edx         # imm = 0x7FFFFF
andl (%rax,%rcx,4), %edx
orl $0x1000000, %edx        # imm = 0x1000000
movl %edx, (%rax,%rcx,4)
movl $0xb, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_dischargevars
void luaK_dischargevars (FuncState *fs, expdesc *e) {
  switch (e->k) {
    case VLOCAL: {
      e->k = VNONRELOC;
      break;
    }
    case VUPVAL: {
      e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0);
      e->k = VRELOCABLE;
      break;
    }
    case VINDEXED: {
      OpCode op = OP_GETTABUP;  /* assume 't' is in an upvalue */
      freereg(fs, e->u.ind.idx);
      if (e->u.ind.vt == VLOCAL) {  /* 't' is in a register? */
        freereg(fs, e->u.ind.t);
        op = OP_GETTABLE;
      }
      e->u.info = luaK_codeABC(fs, op, 0, e->u.ind.t, e->u.ind.idx);
      e->k = VRELOCABLE;
      break;
    }
    case VVARARG:
    case VCALL: {
      luaK_setoneret(fs, e);
      break;
    }
    default: break;  /* there is one value available (somewhere) */
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rsi), %eax
addl $-0x7, %eax
cmpl $0x6, %eax
ja 0x1a6ff
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5bd0(%rip), %rcx      # 0x20258
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a61c
movswl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x1a707
cmpb $0x7, 0xb(%rbx)
jne 0x1a6e0
movzbl 0xa(%rbx), %esi
movq %r14, %rdi
callq 0x1a707
pushq $0x7
jmp 0x1a6e2
movl $0x6, (%rbx)
jmp 0x1a6ff
movl 0x8(%rbx), %esi
shll $0x17, %esi
orl $0x5, %esi
movq %r14, %rdi
callq 0x1a257
jmp 0x1a6f6
pushq $0x6
popq %rsi
movzbl 0xa(%rbx), %ecx
movswl 0x8(%rbx), %r8d
movq %r14, %rdi
xorl %edx, %edx
callq 0x1a05b
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
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/lcode.c
// Function: luaK_exp2anyreg
int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
  luaK_dischargevars(fs, e);
  if (e->k == VNONRELOC) {
    if (!hasjumps(e)) return e->u.info;  /* exp is already in a register */
    if (e->u.info >= fs->nactvar) {  /* reg. is not a local? */
      exp2reg(fs, e, e->u.info);  /* put value on it */
      return e->u.info;
    }
  }
  luaK_exp2nextreg(fs, e);  /* default */
  return e->u.info;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1a669
cmpl $0x6, (%rbx)
jne 0x1a888
movl 0x10(%rbx), %eax
leaq 0x8(%rbx), %r15
cmpl 0x14(%rbx), %eax
je 0x1a89a
movl (%r15), %edx
movzbl 0x42(%r14), %eax
cmpl %eax, %edx
jge 0x1a8a3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a719
addq $0x8, %rbx
movq %rbx, %r15
movl (%r15), %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a75f
jmp 0x1a89a
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_exp2RK
int luaK_exp2RK (FuncState *fs, expdesc *e) {
  luaK_exp2val(fs, e);
  switch (e->k) {
    case VTRUE:
    case VFALSE:
    case VNIL: {
      if (fs->nk <= MAXINDEXRK) {  /* constant fits in RK operand? */
        e->u.info = (e->k == VNIL) ? nilK(fs) : boolK(fs, (e->k == VTRUE));
        e->k = VK;
        return RKASK(e->u.info);
      }
      else break;
    }
    case VKNUM: {
      e->u.info = luaK_numberK(fs, e->u.nval);
      e->k = VK;
      /* go through */
    }
    case VK: {
      if (e->u.info <= MAXINDEXRK)  /* constant fits in argC? */
        return RKASK(e->u.info);
      else break;
    }
    default: break;
  }
  /* not a constant in the right range: put it in a register */
  return luaK_exp2anyreg(fs, e);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1a8c6
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
jae 0x1a923
cmpl $0xff, 0x34(%r14)
jg 0x1a94f
cmpl $0x1, %eax
jne 0x1a961
leaq 0x18(%rsp), %rdx
andl $0x0, 0x8(%rdx)
movq 0x8(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x45, 0x8(%rsi)
movq %r14, %rdi
jmp 0x1a97d
cmpl $0x5, %eax
je 0x1a932
cmpl $0x4, %eax
jne 0x1a94f
movl 0x8(%rbx), %eax
jmp 0x1a948
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x1a512
movl %eax, 0x8(%rbx)
movl $0x4, (%rbx)
cmpl $0xff, %eax
jle 0x1a98b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x1a85b
xorl %ecx, %ecx
cmpl $0x2, %eax
sete %cl
leaq 0x8(%rsp), %rdx
movl %ecx, (%rdx)
movl $0x1, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x1a3cd
movl %eax, 0x8(%rbx)
movl $0x4, (%rbx)
orl $0x100, %eax            # imm = 0x100
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_self
void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
  int ereg;
  luaK_exp2anyreg(fs, e);
  ereg = e->u.info;  /* register where 'e' was placed */
  freeexp(fs, e);
  e->u.info = fs->freereg;  /* base register for op_self */
  e->k = VNONRELOC;
  luaK_reserveregs(fs, 2);  /* function and 'self' produced by op_self */
  luaK_codeABC(fs, OP_SELF, e->u.info, ereg, luaK_exp2RK(fs, key));
  freeexp(fs, key);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1a85b
movl 0x8(%r15), %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a754
movzbl 0x44(%r14), %eax
movl %eax, 0x8(%r15)
movl $0x6, (%r15)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x1a390
movl 0x8(%r15), %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a8d7
pushq $0xc
popq %rsi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
movl %eax, %r8d
callq 0x1a05b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1a754
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_goiftrue
void luaK_goiftrue (FuncState *fs, expdesc *e) {
  int pc;  /* pc of last jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VJMP: {
      invertjump(fs, e);
      pc = e->u.info;
      break;
    }
    case VK: case VKNUM: case VTRUE: {
      pc = NO_JUMP;  /* always true; do nothing */
      break;
    }
    default: {
      pc = jumponcond(fs, e, 0);
      break;
    }
  }
  luaK_concat(fs, &e->f, pc);  /* insert last jump in `f' list */
  luaK_patchtohere(fs, e->t);
  e->t = NO_JUMP;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1a669
movl (%rbx), %eax
pushq $-0x1
popq %rdx
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jb 0x1aaf6
cmpl $0x2, %eax
je 0x1aaf6
movq %r14, %rdi
movq %rbx, %rsi
cmpl $0xa, %eax
jne 0x1aaed
callq 0x1ab19
movl 0x8(%rbx), %edx
jmp 0x1aaf6
xorl %edx, %edx
callq 0x1ab40
movl %eax, %edx
leaq 0x14(%rbx), %rsi
movq %r14, %rdi
callq 0x1a0be
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x1a128
orl $-0x1, 0x10(%rbx)
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/lcode.c
// Function: jumponcond
static int jumponcond (FuncState *fs, expdesc *e, int cond) {
  if (e->k == VRELOCABLE) {
    Instruction ie = getcode(fs, e);
    if (GET_OPCODE(ie) == OP_NOT) {
      fs->pc--;  /* remove previous OP_NOT */
      return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);
    }
    /* else go through */
  }
  discharge2anyreg(fs, e);
  freeexp(fs, e);
  return condjump(fs, OP_TESTSET, NO_REG, e->u.info, cond);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0xb, (%rsi)
jne 0x1ab84
movq (%r14), %rax
movq 0x18(%rax), %rax
movslq 0x8(%r15), %rcx
movl (%rax,%rcx,4), %edx
movl %edx, %eax
andl $0x3f, %eax
cmpl $0x14, %eax
jne 0x1ab84
decl 0x28(%r14)
shrl $0x17, %edx
xorl %r8d, %r8d
testl %ebx, %ebx
sete %r8b
pushq $0x1b
popq %rsi
movq %r14, %rdi
xorl %ecx, %ecx
jmp 0x1abac
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b2d4
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a754
movl 0x8(%r15), %ecx
pushq $0x1c
popq %rsi
movq %r14, %rdi
movl $0xff, %edx
movl %ebx, %r8d
popq %rbx
popq %r14
popq %r15
jmp 0x1b2c2
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_goiffalse
void luaK_goiffalse (FuncState *fs, expdesc *e) {
  int pc;  /* pc of last jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VJMP: {
      pc = e->u.info;
      break;
    }
    case VNIL: case VFALSE: {
      pc = NO_JUMP;  /* always false; do nothing */
      break;
    }
    default: {
      pc = jumponcond(fs, e, 1);
      break;
    }
  }
  luaK_concat(fs, &e->t, pc);  /* insert last jump in `t' list */
  luaK_patchtohere(fs, e->f);
  e->f = NO_JUMP;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1a669
movl (%rbx), %eax
pushq $-0x1
popq %rdx
cmpl $0x1, %eax
je 0x1abee
cmpl $0x3, %eax
je 0x1abee
cmpl $0xa, %eax
jne 0x1abde
movl 0x8(%rbx), %edx
jmp 0x1abee
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ab40
movl %eax, %edx
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x1a0be
movl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x1a128
orl $-0x1, 0x14(%rbx)
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/lcode.c
// Function: luaK_indexed
void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
  lua_assert(!hasjumps(t));
  t->u.ind.t = t->u.info;
  t->u.ind.idx = luaK_exp2RK(fs, k);
  t->u.ind.vt = (t->k == VUPVAL) ? VUPVAL
                                 : check_exp(vkisinreg(t->k), VLOCAL);
  t->k = VINDEXED;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movb 0x8(%rsi), %al
movb %al, 0xa(%rsi)
movq %rdx, %rsi
callq 0x1a8d7
movw %ax, 0x8(%rbx)
cmpl $0x8, (%rbx)
sete %al
addb $0x7, %al
movb %al, 0xb(%rbx)
movl $0x9, (%rbx)
popq %rbx
retq