LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lapi.c
// Function: lua_rawsetp
LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) {
  StkId t;
  TValue k;
  lua_lock(L);
  api_checknelems(L, 1);
  t = index2addr(L, idx);
  api_check(L, ttistable(t), "table expected");
  setpvalue(&k, cast(void *, p));
  setobj2t(L, luaH_set(L, hvalue(t), &k), L->top - 1);
  luaC_barrierback(L, gcvalue(t), L->top - 1);
  L->top--;
  lua_unlock(L);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x8f90
movq %rax, 0x28(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl $0x2, 0x8(%rax)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
addq $-0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rsi
leaq 0x18(%rsp), %rdx
callq 0x24890
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movl -0x8(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0xae16
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xae16
movq 0x28(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xae16
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rsi
callq 0x12d70
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lapi.c
// Function: lua_setmetatable
LUA_API int lua_setmetatable (lua_State *L, int objindex) {
  TValue *obj;
  Table *mt;
  lua_lock(L);
  api_checknelems(L, 1);
  obj = index2addr(L, objindex);
  if (ttisnil(L->top - 1))
    mt = NULL;
  else {
    api_check(L, ttistable(L->top - 1), "table expected");
    mt = hvalue(L->top - 1);
  }
  switch (ttypenv(obj)) {
    case LUA_TTABLE: {
      hvalue(obj)->metatable = mt;
      if (mt) {
        luaC_objbarrierback(L, gcvalue(obj), mt);
        luaC_checkfinalizer(L, gcvalue(obj), mt);
      }
      break;
    }
    case LUA_TUSERDATA: {
      uvalue(obj)->metatable = mt;
      if (mt) {
        luaC_objbarrier(L, rawuvalue(obj), mt);
        luaC_checkfinalizer(L, gcvalue(obj), mt);
      }
      break;
    }
    default: {
      G(L)->mt[ttypenv(obj)] = mt;
      break;
    }
  }
  L->top--;
  lua_unlock(L);
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x8f90
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, -0x8(%rax)
jne 0xae6a
movq $0x0, 0x8(%rsp)
jmp 0xae7c
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
movl %eax, 0x4(%rsp)
subl $0x5, %eax
je 0xaea0
jmp 0xae92
movl 0x4(%rsp), %eax
subl $0x7, %eax
je 0xaf0c
jmp 0xaf7a
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x8(%rsp)
je 0xaf07
movq 0x8(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xaef0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xaef0
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x12d70
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x13020
jmp 0xaf9e
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x8(%rsp)
je 0xaf78
movq 0x8(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xaf61
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xaf61
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x12aa0
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x13020
jmp 0xaf9e
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movq %rdx, 0x1a8(%rax,%rcx,8)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lapi.c
// Function: lua_setuservalue
LUA_API void lua_setuservalue (lua_State *L, int idx) {
  StkId o;
  lua_lock(L);
  api_checknelems(L, 1);
  o = index2addr(L, idx);
  api_check(L, ttisuserdata(o), "userdata expected");
  if (ttisnil(L->top - 1))
    uvalue(o)->env = NULL;
  else {
    api_check(L, ttistable(L->top - 1), "table expected");
    uvalue(o)->env = hvalue(L->top - 1);
    luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));
  }
  L->top--;
  lua_unlock(L);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x8f90
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, -0x8(%rax)
jne 0xafff
movq (%rsp), %rax
movq (%rax), %rax
movq $0x0, 0x18(%rax)
jmp 0xb063
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rcx
movq (%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xb061
movq (%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xb061
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rdx
callq 0x12aa0
jmp 0xb063
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lapi.c
// Function: lua_getctx
LUA_API int lua_getctx (lua_State *L, int *ctx) {
  if (L->ci->callstatus & CIST_YIELDED) {
    if (ctx) *ctx = L->ci->u.c.ctx;
    return L->ci->u.c.status;
  }
  else return LUA_OK;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movzbl 0x22(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xb0cd
cmpq $0x0, -0x18(%rsp)
je 0xb0ba
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x30(%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movzbl 0x49(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0xb0d5
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lapi.c
// Function: lua_callk
LUA_API void lua_callk (lua_State *L, int nargs, int nresults, int ctx,
                        lua_CFunction k) {
  StkId func;
  lua_lock(L);
  api_check(L, k == NULL || !isLua(L->ci),
    "cannot use continuations inside hooks");
  api_checknelems(L, nargs+1);
  api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
  checkresults(L, nargs, nresults);
  func = L->top - (nargs+1);
  if (k != NULL && L->nny == 0) {  /* need to prepare continuation? */
    L->ci->u.c.k = k;  /* save continuation */
    L->ci->u.c.ctx = ctx;  /* save context */
    luaD_call(L, func, nresults, 1);  /* do the call */
  }
  else  /* no continuation or no yieldable */
    luaD_call(L, func, nresults, 0);  /* just do the call */
  adjustresults(L, nresults);
  lua_unlock(L);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq %r8, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xb16e
movq 0x20(%rsp), %rax
movzwl 0x44(%rax), %eax
cmpl $0x0, %eax
jne 0xb16e
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x38(%rax)
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movl %ecx, 0x30(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movl 0x18(%rsp), %edx
movl $0x1, %ecx
callq 0x10e90
jmp 0xb182
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movl 0x18(%rsp), %edx
xorl %ecx, %ecx
callq 0x10e90
cmpl $-0x1, 0x18(%rsp)
jne 0xb1b7
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xb1b7
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lapi.c
// Function: lua_load
LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,
                      const char *chunkname, const char *mode) {
  ZIO z;
  int status;
  lua_lock(L);
  if (!chunkname) chunkname = "?";
  luaZ_init(L, &z, reader, data);
  status = luaD_protectedparser(L, &z, chunkname, mode);
  if (status == LUA_OK) {  /* no errors? */
    LClosure *f = clLvalue(L->top - 1);  /* get newly created function */
    if (f->nupvalues == 1) {  /* does it have one upvalue? */
      /* get global table from registry */
      Table *reg = hvalue(&G(L)->l_registry);
      const TValue *gt = luaH_getint(reg, LUA_RIDX_GLOBALS);
      /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */
      setobj(L, f->upvals[0]->v, gt);
      luaC_barrier(L, f->upvals[0], gt);
    }
  }
  lua_unlock(L);
  return status;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
cmpq $0x0, 0x68(%rsp)
jne 0xb417
leaq 0x2a556(%rip), %rax     # 0x35968
movq %rax, 0x68(%rsp)
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rdx
movq 0x70(%rsp), %rcx
leaq 0x38(%rsp), %rsi
callq 0x2c440
movq 0x80(%rsp), %rdi
movq 0x68(%rsp), %rdx
movq 0x60(%rsp), %rcx
leaq 0x38(%rsp), %rsi
callq 0x116f0
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
jne 0xb545
movq 0x80(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movzbl 0xa(%rax), %eax
cmpl $0x1, %eax
jne 0xb543
movq 0x80(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x25070
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0xb541
movq 0x18(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xb541
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xb541
movq 0x80(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
callq 0x12aa0
jmp 0xb543
jmp 0xb545
movl 0x34(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lapi.c
// Function: lua_dump
LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) {
  int status;
  TValue *o;
  lua_lock(L);
  api_checknelems(L, 1);
  o = L->top - 1;
  if (isLfunction(o))
    status = luaU_dump(L, getproto(o), writer, data, 0);
  else
    status = 1;
  lua_unlock(L);
  return status;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
addq $-0x10, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x46, 0x8(%rax)
jne 0xb5b6
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
xorl %r8d, %r8d
callq 0x11c80
movl %eax, 0xc(%rsp)
jmp 0xb5be
movl $0x1, 0xc(%rsp)
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/lapi.c
// Function: lua_newuserdata
LUA_API void *lua_newuserdata (lua_State *L, size_t size) {
  Udata *u;
  lua_lock(L);
  luaC_checkGC(L);
  u = luaS_newudata(L, size, NULL);
  setuvalue(L, L->top, u);
  api_incr_top(L);
  lua_unlock(L);
  return u + 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x18(%rax)
jle 0xba28
movq 0x20(%rsp), %rdi
callq 0x13f90
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x20a40
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x47, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %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/lapi.c
// Function: aux_upvalue
static const char *aux_upvalue (StkId fi, int n, TValue **val,
                                GCObject **owner) {
  switch (ttype(fi)) {
    case LUA_TCCL: {  /* C closure */
      CClosure *f = clCvalue(fi);
      if (!(1 <= n && n <= f->nupvalues)) return NULL;
      *val = &f->upvalue[n-1];
      if (owner) *owner = obj2gco(f);
      return "";
    }
    case LUA_TLCL: {  /* Lua closure */
      LClosure *f = clLvalue(fi);
      TString *name;
      Proto *p = f->p;
      if (!(1 <= n && n <= p->sizeupvalues)) return NULL;
      *val = f->upvals[n-1]->v;
      if (owner) *owner = obj2gco(f->upvals[n - 1]);
      name = p->upvalues[n-1].name;
      return (name == NULL) ? "" : getstr(name);
    }
    default: return NULL;  /* not a closure */
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x3f, %eax
movl %eax, -0x4c(%rsp)
subl $0x6, %eax
je 0xbbea
jmp 0xbb5d
movl -0x4c(%rsp), %eax
subl $0x26, %eax
jne 0xbcc2
jmp 0xbb6c
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rsp)
movl $0x1, %eax
cmpl -0x14(%rsp), %eax
jg 0xbb95
movl -0x14(%rsp), %eax
movq -0x30(%rsp), %rcx
movzbl 0xa(%rcx), %ecx
cmpl %ecx, %eax
jle 0xbba3
movq $0x0, -0x8(%rsp)
jmp 0xbccb
movq -0x30(%rsp), %rcx
addq $0x20, %rcx
movl -0x14(%rsp), %eax
subl $0x1, %eax
cltq
shlq $0x4, %rax
addq %rax, %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rsp)
je 0xbbd9
movq -0x30(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
leaq 0x2a647(%rip), %rax     # 0x36227
movq %rax, -0x8(%rsp)
jmp 0xbccb
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rsp)
movl $0x1, %eax
cmpl -0x14(%rsp), %eax
jg 0xbc1e
movl -0x14(%rsp), %eax
movq -0x48(%rsp), %rcx
cmpl 0x50(%rcx), %eax
jle 0xbc2c
movq $0x0, -0x8(%rsp)
jmp 0xbccb
movq -0x38(%rsp), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x20(%rax,%rcx,8), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rsp)
je 0xbc70
movq -0x38(%rsp), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x20(%rax,%rcx,8), %rcx
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
movq -0x48(%rsp), %rax
movq 0x38(%rax), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x40(%rsp)
cmpq $0x0, -0x40(%rsp)
jne 0xbca8
leaq 0x2a586(%rip), %rax     # 0x36227
movq %rax, -0x58(%rsp)
jmp 0xbcb6
movq -0x40(%rsp), %rax
addq $0x18, %rax
movq %rax, -0x58(%rsp)
movq -0x58(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xbccb
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lapi.c
// Function: lua_setupvalue
LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
  const char *name;
  TValue *val = NULL;  /* to avoid warnings */
  GCObject *owner = NULL;  /* to avoid warnings */
  StkId fi;
  lua_lock(L);
  fi = index2addr(L, funcindex);
  api_checknelems(L, 1);
  name = aux_upvalue(fi, n, &val, &owner);
  if (name) {
    L->top--;
    setobj(L, val, L->top);
    luaC_barrier(L, owner, L->top);
  }
  lua_unlock(L);
  return name;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x8f90
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl 0x38(%rsp), %esi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0xbb30
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0xbde2
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0xbde0
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xbde0
movq 0x20(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xbde0
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdx
callq 0x12aa0
jmp 0xbde2
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lapi.c
// Function: lua_upvaluejoin
LUA_API void lua_upvaluejoin (lua_State *L, int fidx1, int n1,
                                            int fidx2, int n2) {
  LClosure *f1;
  UpVal **up1 = getupvalref(L, fidx1, n1, &f1);
  UpVal **up2 = getupvalref(L, fidx2, n2, NULL);
  *up1 = *up2;
  luaC_objbarrier(L, f1, *up2);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
leaq 0x18(%rsp), %rcx
callq 0xbea0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0xbea0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xbfad
movq 0x18(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xbfad
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
callq 0x12aa0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_traceback
LUALIB_API void luaL_traceback (lua_State *L, lua_State *L1,
                                const char *msg, int level) {
  lua_Debug ar;
  int top = lua_gettop(L);
  int numlevels = countlevels(L1);
  int mark = (numlevels > LEVELS1 + LEVELS2) ? LEVELS1 : 0;
  if (msg) lua_pushfstring(L, "%s\n", msg);
  lua_pushliteral(L, "stack traceback:");
  while (lua_getstack(L1, level++, &ar)) {
    if (level == mark) {  /* too many levels? */
      lua_pushliteral(L, "\n\t...");  /* add a '...' */
      level = numlevels - LEVELS2;  /* and skip to last ones */
    }
    else {
      lua_getinfo(L1, "Slnt", &ar);
      lua_pushfstring(L, "\n\t%s:", ar.short_src);
      if (ar.currentline > 0)
        lua_pushfstring(L, "%d:", ar.currentline);
      lua_pushliteral(L, " in ");
      pushfuncname(L, &ar);
      if (ar.istailcall)
        lua_pushliteral(L, "\n\t(...tail calls...)");
      lua_concat(L, lua_gettop(L) - top);
    }
  }
  lua_concat(L, lua_gettop(L) - top);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movl %ecx, 0xac(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x8e20
movl %eax, 0x24(%rsp)
movq 0xb8(%rsp), %rdi
callq 0xc1d0
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %edx
xorl %eax, %eax
movl $0xc, %ecx
cmpl $0x16, %edx
cmovgl %ecx, %eax
movl %eax, 0x1c(%rsp)
cmpq $0x0, 0xb0(%rsp)
je 0xc046
movq 0xc0(%rsp), %rdi
movq 0xb0(%rsp), %rdx
leaq 0x28ffd(%rip), %rsi     # 0x3503c
movb $0x0, %al
callq 0xa0f0
movq 0xc0(%rsp), %rdi
leaq 0x29423(%rip), %rsi     # 0x35478
movl $0x10, %edx
callq 0x9f40
movq 0xb8(%rsp), %rdi
movl 0xac(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
leaq 0x28(%rsp), %rdx
callq 0xe5a0
cmpl $0x0, %eax
je 0xc199
movl 0xac(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jne 0xc0c6
movq 0xc0(%rsp), %rdi
leaq 0x293e0(%rip), %rsi     # 0x35489
movl $0x5, %edx
callq 0x9f40
movl 0x20(%rsp), %eax
subl $0xa, %eax
movl %eax, 0xac(%rsp)
jmp 0xc194
movq 0xb8(%rsp), %rdi
leaq 0x293ba(%rip), %rsi     # 0x3548f
leaq 0x28(%rsp), %rdx
callq 0xe960
movq 0xc0(%rsp), %rdi
leaq 0x28(%rsp), %rdx
addq $0x38, %rdx
leaq 0x2939d(%rip), %rsi     # 0x35494
movb $0x0, %al
callq 0xa0f0
cmpl $0x0, 0x50(%rsp)
jle 0xc11f
movq 0xc0(%rsp), %rdi
movl 0x50(%rsp), %edx
leaq 0x29382(%rip), %rsi     # 0x3549a
movb $0x0, %al
callq 0xa0f0
movq 0xc0(%rsp), %rdi
leaq 0x29370(%rip), %rsi     # 0x3549e
movl $0x4, %edx
callq 0x9f40
movq 0xc0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc280
cmpb $0x0, 0x5f(%rsp)
je 0xc16a
movq 0xc0(%rsp), %rdi
leaq 0x29343(%rip), %rsi     # 0x354a3
movl $0x14, %edx
callq 0x9f40
movq 0xc0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x8e20
movq 0x10(%rsp), %rdi
movl %eax, %esi
subl 0x24(%rsp), %esi
callq 0xb880
jmp 0xc05f
movq 0xc0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x8e20
movq 0x8(%rsp), %rdi
movl %eax, %esi
subl 0x24(%rsp), %esi
callq 0xb880
addq $0xc8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: pushfuncname
static void pushfuncname (lua_State *L, lua_Debug *ar) {
  if (*ar->namewhat != '\0')  /* is there a name? */
    lua_pushfstring(L, "function " LUA_QS, ar->name);
  else if (*ar->what == 'm')  /* main? */
      lua_pushliteral(L, "main chunk");
  else if (*ar->what == 'C') {
    if (pushglobalfuncname(L, ar)) {
      lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1));
      lua_remove(L, -2);  /* remove name */
    }
    else
      lua_pushliteral(L, "?");
  }
  else
    lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xc2c0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x293a6(%rip), %rsi     # 0x3565a
movb $0x0, %al
callq 0xa0f0
jmp 0xc393
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %eax
cmpl $0x6d, %eax
jne 0xc2ec
movq 0x10(%rsp), %rdi
leaq 0x2938b(%rip), %rsi     # 0x35668
movl $0xa, %edx
callq 0x9f40
jmp 0xc391
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %eax
cmpl $0x43, %eax
jne 0xc36b
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xc610
cmpl $0x0, %eax
je 0xc353
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x9a80
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x2931f(%rip), %rsi     # 0x3565a
movb $0x0, %al
callq 0xa0f0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8f00
jmp 0xc369
movq 0x10(%rsp), %rdi
leaq 0x29609(%rip), %rsi     # 0x35968
movl $0x1, %edx
callq 0x9f40
jmp 0xc38f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
addq $0x38, %rdx
movq 0x8(%rsp), %rax
movl 0x2c(%rax), %ecx
leaq 0x292eb(%rip), %rsi     # 0x35673
movb $0x0, %al
callq 0xa0f0
jmp 0xc391
jmp 0xc393
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_argerror
LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
  lua_Debug ar;
  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
    return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
  lua_getinfo(L, "n", &ar);
  if (strcmp(ar.namewhat, "method") == 0) {
    narg--;  /* do not count `self' */
    if (narg == 0)  /* error is in the self argument itself? */
      return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
                           ar.name, extramsg);
  }
  if (ar.name == NULL)
    ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?";
  return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",
                        narg, ar.name, extramsg);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movl %esi, 0x94(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x98(%rsp), %rdi
xorl %esi, %esi
leaq 0x8(%rsp), %rdx
callq 0xe5a0
cmpl $0x0, %eax
jne 0xc408
movq 0x98(%rsp), %rdi
movl 0x94(%rsp), %edx
movq 0x88(%rsp), %rcx
leaq 0x290c3(%rip), %rsi     # 0x354b8
movb $0x0, %al
callq 0xc520
movl %eax, 0xa4(%rsp)
jmp 0xc505
movq 0x98(%rsp), %rdi
leaq 0x2ab26(%rip), %rsi     # 0x36f3d
leaq 0x8(%rsp), %rdx
callq 0xe960
movq 0x18(%rsp), %rdi
leaq 0x29553(%rip), %rsi     # 0x35980
callq 0x72d0
cmpl $0x0, %eax
jne 0xc483
movl 0x94(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x94(%rsp)
cmpl $0x0, 0x94(%rsp)
jne 0xc481
movq 0x98(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x88(%rsp), %rcx
leaq 0x29060(%rip), %rsi     # 0x354ce
movb $0x0, %al
callq 0xc520
movl %eax, 0xa4(%rsp)
jmp 0xc505
jmp 0xc483
cmpq $0x0, 0x10(%rsp)
jne 0xc4d4
movq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc610
cmpl $0x0, %eax
je 0xc4be
movq 0x98(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x9a80
movq %rax, (%rsp)
jmp 0xc4cb
leaq 0x294a3(%rip), %rax     # 0x35968
movq %rax, (%rsp)
jmp 0xc4cb
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rdi
movl 0x94(%rsp), %edx
movq 0x10(%rsp), %rcx
movq 0x88(%rsp), %r8
leaq 0x28ff5(%rip), %rsi     # 0x354ec
movb $0x0, %al
callq 0xc520
movl %eax, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: pushglobalfuncname
static int pushglobalfuncname (lua_State *L, lua_Debug *ar) {
  int top = lua_gettop(L);
  lua_getinfo(L, "f", ar);  /* push function */
  lua_pushglobaltable(L);
  if (findfield(L, top + 1, 2)) {
    lua_copy(L, -1, top + 1);  /* move name to proper place */
    lua_pop(L, 2);  /* remove pushed values */
    return 1;
  }
  else {
    lua_settop(L, top);  /* remove function and global table */
    return 0;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8e20
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x28fd7(%rip), %rsi     # 0x35614
callq 0xe960
movq 0x18(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movl $0x2, %edx
callq 0xa660
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
addl $0x1, %esi
movl $0x2, %edx
callq 0xe2d0
cmpl $0x0, %eax
je 0xc6a0
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %edx
addl $0x1, %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x92a0
movq 0x18(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x8e50
movl $0x1, 0x24(%rsp)
jmp 0xc6b6
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x8e50
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_execresult
LUALIB_API int luaL_execresult (lua_State *L, int stat) {
  const char *what = "exit";  /* type of termination */
  if (stat == -1)  /* error? */
    return luaL_fileresult(L, 0, NULL);
  else {
    inspectstat(stat, what);  /* interpret result */
    if (*what == 'e' && stat == 0)  /* successful termination? */
      lua_pushboolean(L, 1);
    else
      lua_pushnil(L);
    lua_pushstring(L, what);
    lua_pushinteger(L, stat);
    return 3;  /* return true/nil,what,code */
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
leaq 0x28cd1(%rip), %rax     # 0x35515
movq %rax, 0x8(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0xc869
movq 0x18(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xc760
movl %eax, 0x24(%rsp)
jmp 0xc909
movl 0x14(%rsp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0xc887
movl 0x14(%rsp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, 0x14(%rsp)
jmp 0xc8b4
movl 0x14(%rsp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0xc8b2
movl 0x14(%rsp), %eax
andl $0x7f, %eax
movl %eax, 0x14(%rsp)
leaq 0x28c6d(%rip), %rax     # 0x3551a
movq %rax, 0x8(%rsp)
jmp 0xc8b4
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x65, %eax
jne 0xc8d9
cmpl $0x0, 0x14(%rsp)
jne 0xc8d9
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0xa330
jmp 0xc8e3
movq 0x18(%rsp), %rdi
callq 0x9df0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9fe0
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x9e70
movl $0x3, 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/lauxlib.c
// Function: luaL_newmetatable
LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
  luaL_getmetatable(L, tname);  /* try to get metatable */
  if (!lua_isnil(L, -1))  /* name already in use? */
    return 0;  /* leave previous value on top, but return 0 */
  lua_pop(L, 1);
  lua_newtable(L);  /* create metatable */
  lua_pushvalue(L, -1);
  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xa530
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9350
cmpl $0x0, %eax
je 0xc95e
movl $0x0, 0x14(%rsp)
jmp 0xc9a5
movq 0x8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
movq 0x8(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xa780
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x92e0
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xaad0
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_checkoption
LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
                                 const char *const lst[]) {
  const char *name = (def) ? luaL_optstring(L, narg, def) :
                             luaL_checkstring(L, narg);
  int i;
  for (i=0; lst[i]; i++)
    if (strcmp(lst[i], name) == 0)
      return i;
  return luaL_argerror(L, narg,
                       lua_pushfstring(L, "invalid option " LUA_QS, name));
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0xcbad
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
movq 0x38(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xcc70
movq %rax, 0x18(%rsp)
jmp 0xcbc4
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xcd00
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x30(%rsp), %rax
movslq 0x24(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xcc1d
movq 0x30(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x28(%rsp), %rsi
callq 0x72d0
cmpl $0x0, %eax
jne 0xcc0e
movl 0x24(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0xcc5c
jmp 0xcc10
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xcbd6
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x288e1(%rip), %rsi     # 0x35521
movb $0x0, %al
callq 0xa0f0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %rax, %rdx
callq 0xc3a0
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_optlstring
LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,
                                        const char *def, size_t *len) {
  if (lua_isnoneornil(L, narg)) {
    if (len)
      *len = (def ? strlen(def) : 0);
    return def;
  }
  else return luaL_checklstring(L, narg, len);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x9350
cmpl $0x0, %eax
jg 0xccdd
cmpq $0x0, 0x10(%rsp)
je 0xccd1
cmpq $0x0, 0x18(%rsp)
je 0xccbb
movq 0x18(%rsp), %rdi
callq 0x7170
movq %rax, 0x8(%rsp)
jmp 0xccc4
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xccc4
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xccf5
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0xcd00
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_checkstack
LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) {
  /* keep some extra space to run error routines, if needed */
  const int extra = LUA_MINSTACK;
  if (!lua_checkstack(L, space + extra)) {
    if (msg)
      luaL_error(L, "stack overflow (%s)", msg);
    else
      luaL_error(L, "stack overflow");
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x14, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
addl $0x14, %esi
callq 0x8b50
cmpl $0x0, %eax
jne 0xcdb7
cmpq $0x0, 0x10(%rsp)
je 0xcda2
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x2879c(%rip), %rsi     # 0x35535
movb $0x0, %al
callq 0xc520
jmp 0xcdb5
movq 0x20(%rsp), %rdi
leaq 0x28c00(%rip), %rsi     # 0x359ae
movb $0x0, %al
callq 0xc520
jmp 0xcdb7
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_checknumber
LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
  int isnum;
  lua_Number d = lua_tonumberx(L, narg, &isnum);
  if (!isnum)
    tag_error(L, narg, LUA_TNUMBER);
  return d;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
leaq 0x8(%rsp), %rdx
callq 0x9810
movsd %xmm0, (%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0xcecf
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x3, %edx
callq 0xce00
movsd (%rsp), %xmm0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_checkinteger
LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
  int isnum;
  lua_Integer d = lua_tointegerx(L, narg, &isnum);
  if (!isnum)
    tag_error(L, narg, LUA_TNUMBER);
  return d;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
leaq 0x8(%rsp), %rdx
callq 0x98a0
movq %rax, (%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0xcf7e
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x3, %edx
callq 0xce00
movq (%rsp), %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/lauxlib.c
// Function: luaL_checkunsigned
LUALIB_API lua_Unsigned luaL_checkunsigned (lua_State *L, int narg) {
  int isnum;
  lua_Unsigned d = lua_tounsignedx(L, narg, &isnum);
  if (!isnum)
    tag_error(L, narg, LUA_TNUMBER);
  return d;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
leaq 0x8(%rsp), %rdx
callq 0x9950
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0xcfce
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl $0x3, %edx
callq 0xce00
movl 0x4(%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/lauxlib.c
// Function: luaL_prepbuffsize
LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) {
  lua_State *L = B->L;
  if (B->size - B->n < sz) {  /* not enough space? */
    char *newbuff;
    size_t newsize = B->size * 2;  /* double buffer size */
    if (newsize - B->n < sz)  /* not big enough? */
      newsize = B->n + sz;
    if (newsize < B->n || newsize - B->n < sz)
      luaL_error(L, "buffer too large");
    /* create larger buffer */
    newbuff = (char *)lua_newuserdata(L, newsize * sizeof(char));
    /* move content to new buffer */
    memcpy(newbuff, B->b, B->n * sizeof(char));
    if (buffonstack(B))
      lua_remove(L, -2);  /* remove old buffer */
    B->b = newbuff;
    B->size = newsize;
  }
  return &B->b[B->n];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
subq 0x10(%rcx), %rax
cmpq 0x18(%rsp), %rax
jae 0xd19a
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
subq 0x10(%rcx), %rax
cmpq 0x18(%rsp), %rax
jae 0xd0ef
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
addq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0xd112
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
subq 0x10(%rcx), %rax
cmpq 0x18(%rsp), %rax
jae 0xd125
movq 0x10(%rsp), %rdi
leaq 0x2843a(%rip), %rsi     # 0x35558
movb $0x0, %al
callq 0xc520
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
shlq $0x0, %rsi
callq 0xba00
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdx
shlq $0x0, %rdx
callq 0x7350
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
je 0xd180
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8f00
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
addq 0x10(%rcx), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_pushresult
LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
  lua_State *L = B->L;
  lua_pushlstring(L, B->b, B->n);
  if (buffonstack(B))
    lua_remove(L, -2);  /* remove old buffer */
}

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xa820
cmpl $0x0, %eax
jne 0xdaef
movl $0x0, 0x24(%rsp)
jmp 0xdb51
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9fe0
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xa5e0
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9350
cmpl $0x0, %eax
jne 0xdb3a
movq 0x18(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x8e50
movl $0x0, 0x24(%rsp)
jmp 0xdb51
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8f00
movl $0x1, 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/lauxlib.c
// Function: luaL_callmeta
LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
  obj = lua_absindex(L, obj);
  if (!luaL_getmetafield(L, obj, event))  /* no metafield? */
    return 0;
  lua_pushvalue(L, obj);
  lua_call(L, 1, 1);
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x8dc0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0xdac0
cmpl $0x0, %eax
jne 0xdba6
movl $0x0, 0x24(%rsp)
jmp 0xdbd4
movq 0x18(%rsp), %rdi
movl 0x14(%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
movl $0x1, 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/lauxlib.c
// Function: luaL_len
LUALIB_API int luaL_len (lua_State *L, int idx) {
  int l;
  int isnum;
  lua_len(L, idx);
  l = (int)lua_tointegerx(L, -1, &isnum);
  if (!isnum)
    luaL_error(L, "object length is not a number");
  lua_pop(L, 1);  /* remove object */
  return l;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xb930
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x4(%rsp), %rdx
callq 0x98a0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0xdc2d
movq 0x10(%rsp), %rdi
leaq 0x27956(%rip), %rsi     # 0x3557c
movb $0x0, %al
callq 0xc520
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
movl 0x8(%rsp), %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/lauxlib.c
// Function: luaL_checkversion_
LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver) {
  const lua_Number *v = lua_version(L);
  if (v != lua_version(NULL))
    luaL_error(L, "multiple Lua VMs detected");
  else if (*v != ver)
    luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
                  ver, *v);
  /* check conversions number -> integer types */
  lua_pushnumber(L, -(lua_Number)0x1234);
  if (lua_tointeger(L, -1) != -0x1234 ||
      lua_tounsigned(L, -1) != (lua_Unsigned)-0x1234)
    luaL_error(L, "bad conversion number->int;"
                  " must recompile Lua with proper settings");
  lua_pop(L, 1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x8d80
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x8d80
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0xdeb3
movq 0x20(%rsp), %rdi
leaq 0x2771c(%rip), %rsi     # 0x355c6
movb $0x0, %al
callq 0xc520
jmp 0xdeec
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
ucomisd 0x18(%rsp), %xmm0
jne 0xdec8
jp 0xdec8
jmp 0xdeea
movq 0x20(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd (%rax), %xmm1
leaq 0x276fd(%rip), %rsi     # 0x355e0
movb $0x2, %al
callq 0xc520
jmp 0xdeec
movq 0x20(%rsp), %rdi
movsd 0x27577(%rip), %xmm0    # 0x35470
callq 0x9e20
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x98a0
cmpq $-0x1234, %rax          # imm = 0xEDCC
jne 0xdf33
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x9950
cmpl $0xffffedcc, %eax       # imm = 0xFFFFEDCC
je 0xdf46
movq 0x20(%rsp), %rdi
leaq 0x276d7(%rip), %rsi     # 0x35616
movb $0x0, %al
callq 0xc520
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lauxlib.c
// Function: luaL_getsubtable
LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) {
  lua_getfield(L, idx, fname);
  if (lua_istable(L, -1)) return 1;  /* table already there */
  else {
    lua_pop(L, 1);  /* remove previous result */
    idx = lua_absindex(L, idx);
    lua_newtable(L);
    lua_pushvalue(L, -1);  /* copy to be left at top */
    lua_setfield(L, idx, fname);  /* assign new table to field */
    return 0;  /* false, because did not find table there */
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0xa530
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9350
cmpl $0x5, %eax
jne 0xdfa3
movl $0x1, 0x24(%rsp)
jmp 0xdffc
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x8dc0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xa780
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x92e0
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0xaad0
movl $0x0, 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/lauxlib.c
// Function: luaL_requiref
LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
                               lua_CFunction openf, int glb) {
  lua_pushcfunction(L, openf);
  lua_pushstring(L, modname);  /* argument to open function */
  lua_call(L, 1, 1);  /* open module */
  luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
  lua_pushvalue(L, -2);  /* make copy of module (call result) */
  lua_setfield(L, -2, modname);  /* _LOADED[modname] = module */
  lua_pop(L, 1);  /* remove _LOADED table */
  if (glb) {
    lua_pushvalue(L, -1);  /* copy of 'mod' */
    lua_setglobal(L, modname);  /* _G[modname] = module */
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0xa1e0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x9fe0
movq 0x20(%rsp), %rdi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
movl %edx, %esi
callq 0xb0e0
movq 0x20(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x2754e(%rip), %rdx     # 0x355be
callq 0xdf60
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x92e0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xaad0
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
cmpl $0x0, 0xc(%rsp)
je 0xe0cc
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x92e0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xa9a0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)