LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x40(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
movl %eax, 0x1c(%rsp)
subl $0x4, %eax
je 0x287c7
jmp 0x286fd
movl 0x1c(%rsp), %eax
subl $0x5, %eax
jne 0x28817
jmp 0x2870c
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2872e
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x2877e
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movzbl 0xa(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x2874c
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x28774
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x140(%rax), %rdx
movl $0x4, %esi
callq 0x264d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x28795
jmp 0x28853
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x253b0
cvtsi2sd %eax, %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x28(%rsp), %rax
movl $0x3, 0x8(%rax)
jmp 0x28877
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %xmm0
movaps 0xe10b(%rip), %xmm1     # 0x368f0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xe10f(%rip), %xmm1     # 0x36900
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x20(%rsp), %rax
movl $0x3, 0x8(%rax)
jmp 0x28877
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl $0x4, %edx
callq 0x26540
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x28851
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
leaq 0xe999(%rip), %rdx      # 0x371e5
callq 0xee00
jmp 0x28853
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
movl $0x1, %r9d
callq 0x27620
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x27320
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x2891c
movq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x27320
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x2891c
movl 0x44(%rsp), %edi
subl $0x6, %edi
addl $0x0, %edi
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movq 0x10(%rsp), %rax
movsd (%rax), %xmm1
callq 0x196e0
movsd %xmm0, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movsd 0x8(%rsp), %xmm0
movq (%rsp), %rax
movsd %xmm0, (%rax)
movq (%rsp), %rax
movl $0x3, 0x8(%rax)
jmp 0x28955
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x58(%rsp), %rcx
movl 0x44(%rsp), %r8d
callq 0x28630
cmpl $0x0, %eax
jne 0x28953
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0xf490
jmp 0x28955
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lvm.c
// Function: getcached
static Closure *getcached (Proto *p, UpVal **encup, StkId base) {
  Closure *c = p->cache;
  if (c != NULL) {  /* is there a cached closure? */
    int nup = p->sizeupvalues;
    Upvaldesc *uv = p->upvalues;
    int i;
    for (i = 0; i < nup; i++) {  /* check whether it has right upvalues */
      TValue *v = uv[i].instack ? base + uv[i].idx : encup[uv[i].idx]->v;
      if (c->l.upvals[i]->v != v)
        return NULL;  /* wrong upvalue; cannot reuse closure */
    }
  }
  return c;  /* return cached closure (or NULL if no cached closure) */
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
je 0x2c228
movq -0x10(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x2c(%rsp)
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rsp)
movl $0x0, -0x3c(%rsp)
movl -0x3c(%rsp), %eax
cmpl -0x2c(%rsp), %eax
jge 0x2c226
movq -0x38(%rsp), %rax
movslq -0x3c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x8(%rax), %eax
cmpl $0x0, %eax
je 0x2c1be
movq -0x20(%rsp), %rax
movq -0x38(%rsp), %rcx
movslq -0x3c(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movzbl 0x9(%rcx), %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rsp)
jmp 0x2c1e5
movq -0x18(%rsp), %rax
movq -0x38(%rsp), %rcx
movslq -0x3c(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movzbl 0x9(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rsp)
movq -0x50(%rsp), %rax
movq %rax, -0x48(%rsp)
movq -0x28(%rsp), %rax
movslq -0x3c(%rsp), %rcx
movq 0x20(%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
cmpq -0x48(%rsp), %rax
je 0x2c214
movq $0x0, -0x8(%rsp)
jmp 0x2c232
jmp 0x2c216
movl -0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rsp)
jmp 0x2c16b
jmp 0x2c228
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lvm.c
// Function: pushclosure
static void pushclosure (lua_State *L, Proto *p, UpVal **encup, StkId base,
                         StkId ra) {
  int nup = p->sizeupvalues;
  Upvaldesc *uv = p->upvalues;
  int i;
  Closure *ncl = luaF_newLclosure(L, nup);
  ncl->l.p = p;
  setclLvalue(L, ra, ncl);  /* anchor new closure in stack */
  for (i = 0; i < nup; i++) {  /* fill in its upvalues */
    if (uv[i].instack)  /* upvalue refers to local variable? */
      ncl->l.upvals[i] = luaF_findupval(L, base + uv[i].idx);
    else  /* get upvalue from enclosing function */
      ncl->l.upvals[i] = encup[uv[i].idx];
  }
  luaC_barrierproto(L, p, ncl);
  p->cache = ncl;  /* save it on cache for reuse */
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x48(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x48(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x12380
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x46, 0x8(%rax)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x2c368
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpb $0x0, 0x8(%rax)
je 0x2c329
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x9(%rax), %eax
cltq
shlq $0x4, %rax
addq %rax, %rsi
callq 0x12470
movq %rax, %rdx
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq %rdx, 0x20(%rax,%rcx,8)
jmp 0x2c356
movq 0x40(%rsp), %rax
movq 0x20(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movzbl 0x9(%rcx), %ecx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq %rdx, 0x20(%rax,%rcx,8)
jmp 0x2c358
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2c2c3
movq 0x48(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2c38d
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x12dd0
movq 0x10(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x40(%rax)
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x2c649
cmpq $0x20, (%rsp)
jae 0x2c5f0
movq $0x20, (%rsp)
movq (%rsp), %rax
addq $0x1, %rax
cmpq $-0x3, %rax
jbe 0x2c608
movq 0x10(%rsp), %rdi
callq 0x18150
jmp 0x2c60a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdx
shlq $0x0, %rdx
movq (%rsp), %rcx
shlq $0x0, %rcx
callq 0x18170
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movl $0x2, %edx
callq 0xa660
movq (%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movl $0x2, %edx
callq 0xa660
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x9607(%rip), %rdx      # 0x35ca2
callq 0xaad0
movq (%rsp), %rdi
leaq 0x141c5(%rip), %rsi     # 0x40870
xorl %edx, %edx
callq 0xdd90
movq (%rsp), %rdi
leaq 0xaba3(%rip), %rsi      # 0x37260
movl $0x7, %edx
callq 0x9f40
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xab91(%rip), %rdx      # 0x37268
callq 0xaad0
movl $0x1, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xab85(%rip), %rdx      # 0x3730a
leaq 0x14254(%rip), %rcx     # 0x409e0
movl $0x1, %esi
callq 0xcb70
movslq %eax, %rcx
leaq 0xace0(%rip), %rax      # 0x37480
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x2, %esi
callq 0xcfe0
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0xb5e0
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x3, %eax
je 0x2c7f9
jmp 0x2c7e3
movl 0x4(%rsp), %eax
subl $0x5, %eax
je 0x2c84d
jmp 0x2c7ee
movl 0x4(%rsp), %eax
subl $0x9, %eax
je 0x2c84d
jmp 0x2c865
movq 0x18(%rsp), %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0xb5e0
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
cvtsi2sdl 0xc(%rsp), %xmm0
cvtsi2sdl 0x8(%rsp), %xmm1
movsd 0xaa31(%rip), %xmm2     # 0x37258
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
callq 0x9e20
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rsi
callq 0x9e70
movl $0x2, 0x24(%rsp)
jmp 0x2c87c
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xa330
movl $0x1, 0x24(%rsp)
jmp 0x2c87c
movq 0x18(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x9e70
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xcc70
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x8e50
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd580
cmpl $0x0, %eax
je 0x2c8e9
movq 0x8(%rsp), %rdi
callq 0xb7f0
movl %eax, 0x14(%rsp)
jmp 0x2c911
movq 0x8(%rsp), %rdi
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq 0xd24(%rip), %r8        # 0x2d620
movl %ecx, %esi
callq 0xb0e0
movq 0x8(%rsp), %rdi
callq 0x2d620
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0xcfe0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x8e50
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x9480
cmpl $0x0, %eax
je 0x2c997
cmpl $0x0, 0xc(%rsp)
jle 0x2c997
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xc6c0
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x92e0
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0xb880
movq 0x10(%rsp), %rdi
callq 0xb7f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xce50
movq 0x10(%rsp), %rdi
callq 0x9df0
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x90d0
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x8e20
movq (%rsp), %rdi
movl %eax, %esi
subl $0x2, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
leaq 0xc04(%rip), %r9        # 0x2d910
movl %r8d, %ecx
callq 0xb1c0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
cmpl $0x0, 0xc(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x2d950
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8e20
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x84be(%rip), %rsi      # 0x35221
callq 0xa430
movl $0x1, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jg 0x2ce4f
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x92e0
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x92e0
movq 0x18(%rsp), %rdi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
movl %edx, %esi
callq 0xb0e0
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rsp, %rdx
callq 0x9a80
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2cdee
movq 0x18(%rsp), %rdi
leaq 0xa5e9(%rip), %rsi      # 0x373c7
movb $0x0, %al
callq 0xc520
movl %eax, 0x24(%rsp)
jmp 0x2ce84
cmpl $0x1, 0x10(%rsp)
jle 0x2ce13
movq 0x141cc(%rip), %rax     # 0x40fc8
movq (%rax), %rcx
leaq 0xa5ec(%rip), %rdi      # 0x373f2
movl $0x1, %edx
movq %rdx, %rsi
callq 0x7530
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
movq 0x141a5(%rip), %rax     # 0x40fc8
movq (%rax), %rcx
movl $0x1, %esi
callq 0x7530
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x2cd70
movq 0x14172(%rip), %rax     # 0x40fc8
movq (%rax), %rcx
leaq 0xa185(%rip), %rdi      # 0x36fe5
movl $0x1, %edx
movq %rdx, %rsi
callq 0x7530
movq 0x14154(%rip), %rax     # 0x40fc8
movq (%rax), %rdi
callq 0x73b0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8e20
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x9350
cmpl $0x4, %eax
jne 0x2d094
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x9a80
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x2d094
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x9e70
movl $0x1, 0x24(%rsp)
jmp 0x2d111
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0xcf40
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jge 0x2d0bc
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x2d0d0
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jle 0x2d0ce
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x2d0d0
movb $0x1, %al
movl $0x1, %ecx
cmpl 0x10(%rsp), %ecx
movb %al, 0xf(%rsp)
jle 0x2d101
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xa31b(%rip), %rdx      # 0x3740d
callq 0xc3a0
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movl 0x14(%rsp), %eax
subl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8e20
movl %eax, 0x8(%rsp)
movb $0x1, %al
cmpl $0x2, 0x8(%rsp)
movb %al, 0x7(%rsp)
jge 0x2d5a4
movq 0x10(%rsp), %rdi
movl $0x2, %esi
leaq 0x7fb4(%rip), %rdx      # 0x35549
callq 0xc3a0
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x92e0
movq 0x10(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x92a0
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x9190
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
subl $0x2, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
leaq 0x316(%rip), %r9        # 0x2d910
callq 0xb1c0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
cmpl $0x0, 0xc(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x2d950
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl $0x1, %esi
callq 0xdac0
cmpl $0x0, %eax
jne 0x2d6c7
movq 0x20(%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0xcdc0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xa1e0
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x92e0
cmpl $0x0, 0x14(%rsp)
je 0x2d6bb
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9e70
jmp 0x2d6c5
movq 0x20(%rsp), %rdi
callq 0x9df0
jmp 0x2d6f1
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x92e0
movq 0x20(%rsp), %rdi
movl $0x1, %esi
movl $0x3, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xb0e0
movl $0x3, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0xcf40
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0xcdc0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x9e70
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0x1, %esi
callq 0xa660
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9350
movl %eax, %edx
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x8b50
cmpl $0x0, %eax
jne 0x2d9a4
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x8e50
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0xa330
movq 0x8(%rsp), %rdi
leaq 0x8019(%rip), %rsi      # 0x359ae
callq 0x9fe0
movl $0x2, 0x14(%rsp)
jmp 0x2d9cf
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0xa330
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x9190
movq 0x8(%rsp), %rdi
callq 0x8e20
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0xcf90
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0xcf40
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jl 0x2da52
movl 0x4(%rsp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
jne 0x2da6b
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
xorl %edx, %edx
subl (%rsp), %edx
callq 0x2de90
movl %eax, 0x14(%rsp)
jmp 0x2dab2
cmpl $0x20, (%rsp)
jl 0x2da7b
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x2da9c
movl 0x4(%rsp), %eax
movl (%rsp), %ecx
shrl %cl, %eax
movl (%rsp), %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shrl %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
orl %ecx, %eax
andl $-0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x9ec0
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8e20
movl %eax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jg 0x2db84
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xcf90
orl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2db57
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
andl $-0x1, %esi
callq 0x9ec0
movl $0x1, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xcf90
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
leaq 0xc(%rsp), %rdx
callq 0x2df80
movl %eax, 0x4(%rsp)
movl 0x8(%rsp), %eax
movl 0x4(%rsp), %ecx
shrl %cl, %eax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x9ec0
movl $0x1, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xcf90
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0xcf90
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
leaq 0x1c(%rsp), %rdx
callq 0x2df80
movl %eax, 0x10(%rsp)
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
shll %cl, %eax
xorl $-0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
andl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %eax
movl 0xc(%rsp), %edx
movl 0x10(%rsp), %ecx
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x9ec0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jge 0x2dede
xorl %eax, %eax
subl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $-0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x20, 0x8(%rsp)
jl 0x2dece
movl $0x0, 0xc(%rsp)
jmp 0x2dedc
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %eax
shrl %cl, %eax
movl %eax, 0xc(%rsp)
jmp 0x2df08
cmpl $0x20, 0x8(%rsp)
jl 0x2deef
movl $0x0, 0xc(%rsp)
jmp 0x2defd
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %eax
shll %cl, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
andl $-0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x9ec0
movl $0x1, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8e20
movl %eax, 0x8(%rsp)
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jg 0x2df74
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xcf90
andl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2df47
movl 0x4(%rsp), %eax
andl $-0x1, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0xcf40
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
movl $0x1, %edx
callq 0xcfe0
movl %eax, 0x8(%rsp)
movb $0x1, %al
xorl %ecx, %ecx
cmpl 0xc(%rsp), %ecx
movb %al, 0x7(%rsp)
jle 0x2dfeb
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
leaq 0x9518(%rip), %rdx      # 0x374f4
callq 0xc3a0
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
movb $0x1, %al
xorl %ecx, %ecx
cmpl 0x8(%rsp), %ecx
movb %al, 0x6(%rsp)
jl 0x2e01f
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
leaq 0x94fd(%rip), %rdx      # 0x3750d
callq 0xc3a0
cmpl $0x0, %eax
setne %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movl 0xc(%rsp), %eax
addl 0x8(%rsp), %eax
cmpl $0x20, %eax
jle 0x2e043
movq 0x20(%rsp), %rdi
leaq 0x94e8(%rip), %rsi      # 0x37524
movb $0x0, %al
callq 0xc520
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xcf90
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
andl $0x1f, %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
andl $-0x1, %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x2e0be
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
shll %cl, %eax
movl 0x8(%rsp), %edx
movl $0x20, %ecx
subl 0xc(%rsp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
andl $-0x1, %esi
callq 0x9ec0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x2e35b
jmp 0x2e3b2
movq 0x18(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x2e372
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x2e3b0
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x2e5b0
movl %eax, 0xc(%rsp)
cmpl $-0x1, %eax
je 0x2e39e
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x2e37d
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x2e610
jmp 0x2e3b2
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_patchlist
void luaK_patchlist (FuncState *fs, int list, int target) {
  if (target == fs->pc)
    luaK_patchtohere(fs, list);
  else {
    lua_assert(target < fs->pc);
    patchlistaux(fs, list, target, NO_REG, target);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x2e44f
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x2e470
jmp 0x2e46b
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
movl 0x8(%rsp), %r8d
movl $0xff, %ecx
callq 0x2e4b0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
cmpl $-0x1, 0xc(%rsp)
je 0x2e5ab
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x2e5b0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %edx
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
movl 0x8(%rsp), %eax
shll $0x6, %eax
andl $0x3fc0, %eax           # imm = 0x3FC0
orl %eax, %edx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq 0xc(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x4(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x2e54c
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: fixjump
static void fixjump (FuncState *fs, int pc, int dest) {
  Instruction *jmp = &fs->f->code[pc];
  int offset = dest-(pc+1);
  lua_assert(dest != NO_JUMP);
  if (abs(offset) > MAXARG_sBx)
    luaX_syntaxerror(fs->ls, "control structure too long");
  SETARG_sBx(*jmp, offset);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
subl %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0x1ffff, %eax          # imm = 0x1FFFF
jle 0x2e676
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x8ffb(%rip), %rsi      # 0x3766c
callq 0x32300
movq 0x10(%rsp), %rax
movl (%rax), %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
movl 0xc(%rsp), %eax
addl $0x1ffff, %eax          # imm = 0x1FFFF
shll $0xe, %eax
andl $0xffffc000, %eax       # imm = 0xFFFFC000
orl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x44(%rax), %eax
addl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movzbl 0x7a(%rcx), %ecx
cmpl %ecx, %eax
jle 0x2e8d2
cmpl $0xfa, 0x8(%rsp)
jl 0x2e8c1
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x8d78(%rip), %rsi      # 0x37634
callq 0x32300
movl 0x8(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movq (%rax), %rax
movb %cl, 0x7a(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movsd 0x38(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rax
movl $0x3, 0x8(%rax)
movsd 0x38(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2ec29
jp 0x2ec29
jmp 0x2ec3e
movsd 0x38(%rsp), %xmm0
ucomisd 0x38(%rsp), %xmm0
jne 0x2ec3e
jp 0x2ec3e
jmp 0x2ecc1
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movl $0x8, %edx
callq 0x20780
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movzbl 0x8(%rax), %ecx
orl $0x40, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
addq $-0x10, %rsi
leaq 0x18(%rsp), %rdx
callq 0x2e980
movl %eax, 0x34(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
jmp 0x2ecd7
movq 0x40(%rsp), %rdi
leaq 0x18(%rsp), %rdx
movq %rdx, %rsi
callq 0x2e980
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x8(%rsp), %rax
cmpl $0xc, (%rax)
jne 0x2ed48
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %edx
andl $0xff803fff, %edx       # imm = 0xFF803FFF
movl 0x4(%rsp), %eax
addl $0x1, %eax
shll $0xe, %eax
andl $0x7fc000, %eax         # imm = 0x7FC000
orl %eax, %edx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2edf7
movq 0x8(%rsp), %rax
cmpl $0xd, (%rax)
jne 0x2edf5
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
movl 0x4(%rsp), %eax
addl $0x1, %eax
shll $0x17, %eax
andl $0xff800000, %eax       # imm = 0xFF800000
orl %eax, %edx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %edx
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
movq 0x10(%rsp), %rax
movzbl 0x44(%rax), %eax
shll $0x6, %eax
andl $0x3fc0, %eax           # imm = 0x3FC0
orl %eax, %edx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x2e8e0
jmp 0x2edf7
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpl $0xc, (%rax)
jne 0x2ee4a
movq -0x10(%rsp), %rax
movl $0x6, (%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %ecx
shrl $0x6, %ecx
andl $0xff, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
jmp 0x2ee9d
movq -0x10(%rsp), %rax
cmpl $0xd, (%rax)
jne 0x2ee9b
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %edx
andl $0x7fffff, %edx         # imm = 0x7FFFFF
orl $0x1000000, %edx        # imm = 0x1000000
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rsp), %rax
movl $0xb, (%rax)
jmp 0x2ee9d
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
addl $-0x7, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x6, %eax
ja 0x2efb3
movq 0x8(%rsp), %rax
leaq 0x8674(%rip), %rcx      # 0x37548
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rax
movl $0x6, (%rax)
jmp 0x2efb5
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
movl $0x5, %esi
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x2e250
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl $0xb, (%rax)
jmp 0x2efb5
movl $0x6, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movswl 0x8(%rax), %esi
callq 0x2efc0
movq 0x18(%rsp), %rax
movzbl 0xb(%rax), %eax
cmpl $0x7, %eax
jne 0x2ef68
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movzbl 0xa(%rax), %esi
callq 0x2efc0
movl $0x7, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x18(%rsp), %rax
movzbl 0xa(%rax), %ecx
movq 0x18(%rsp), %rax
movswl 0x8(%rax), %r8d
xorl %edx, %edx
callq 0x2e250
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl $0xb, (%rax)
jmp 0x2efb5
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2ee00
jmp 0x2efb5
jmp 0x2efb5
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x2eea0
movq (%rsp), %rax
cmpl $0x6, (%rax)
jne 0x2f299
movq (%rsp), %rax
movl 0x10(%rax), %eax
movq (%rsp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x2f261
movq (%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x2f2b2
movq (%rsp), %rax
movl 0x8(%rax), %eax
movq 0x8(%rsp), %rcx
movzbl 0x42(%rcx), %ecx
cmpl %ecx, %eax
jl 0x2f297
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq (%rsp), %rax
movl 0x8(%rax), %edx
callq 0x2f090
movq (%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x2f2b2
jmp 0x2f299
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x2f000
movq (%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)