LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: lua_setlocal
LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
  StkId pos = 0;  /* to avoid warnings */
  const char *name = findlocal(L, ar->i_ci, n, &pos);
  lua_lock(L);
  if (name)
    setobjs2s(L, pos, L->top - 1);
  L->top--;  /* pop value */
  lua_unlock(L);
  return name;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x78(%rax), %rsi
movl 0x24(%rsp), %edx
leaq 0x18(%rsp), %rcx
callq 0xe750
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xe93d
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
addq $-0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
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 0x30(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: luaG_typeerror
l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
  CallInfo *ci = L->ci;
  const char *name = NULL;
  const char *t = objtypename(o);
  const char *kind = NULL;
  if (isLua(ci)) {
    kind = getupvalname(ci, o, &name);  /* check whether 'o' is an upvalue */
    if (!kind && isinstack(ci, o))  /* no? try a register */
      kind = getobjname(ci_func(ci)->p, currentpc(ci),
                        cast_int(o - ci->u.l.base), &name);
  }
  if (kind)
    luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)",
                op, kind, name, t);
  else
    luaG_runerror(L, "attempt to %s a %s value", op, t);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x38(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x3193e(%rip), %rax     # 0x40780
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rax
movzbl 0x22(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xeeeb
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xef40
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xeee9
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xeff0
cmpl $0x0, %eax
je 0xeee9
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xf330
movq 0x8(%rsp), %rdi
movl %eax, %esi
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x30(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movl %eax, %edx
leaq 0x20(%rsp), %rcx
callq 0xf050
movq %rax, 0x10(%rsp)
jmp 0xeeeb
cmpq $0x0, 0x10(%rsp)
je 0xef1a
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
leaq 0x26999(%rip), %rsi     # 0x358ac
movb $0x0, %al
callq 0xf360
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x2699f(%rip), %rsi     # 0x358cf
movb $0x0, %al
callq 0xf360
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: isinstack
static int isinstack (CallInfo *ci, const TValue *o) {
  StkId p;
  for (p = ci->u.l.base; p < ci->top; p++)
    if (o == p) return 1;
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xf040
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jne 0xf02e
movl $0x1, -0x4(%rsp)
jmp 0xf048
jmp 0xf030
movq -0x20(%rsp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rsp)
jmp 0xf008
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: luaG_runerror
l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
  va_list argp;
  va_start(argp, fmt);
  addinfo(L, luaO_pushvfstring(L, fmt, argp));
  va_end(argp);
  luaG_errormsg(L);
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0xf39f
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm4, 0x80(%rsp)
movaps %xmm5, 0x90(%rsp)
movaps %xmm6, 0xa0(%rsp)
movaps %xmm7, 0xb0(%rsp)
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
leaq 0xc0(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x19bd0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xf690
leaq 0xc0(%rsp), %rax
movq 0xe0(%rsp), %rdi
callq 0xf580
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: luaG_aritherror
l_noret luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) {
  TValue temp;
  if (luaV_tonumber(p1, &temp) == NULL)
    p2 = p1;  /* first operand is wrong */
  luaG_typeerror(L, p2, "perform arithmetic on");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x27320
cmpq $0x0, %rax
jne 0xf4c0
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x26423(%rip), %rdx     # 0x358f4
callq 0xee00
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: luaG_ordererror
l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
  const char *t1 = objtypename(p1);
  const char *t2 = objtypename(p2);
  if (t1 == t2)
    luaG_runerror(L, "attempt to compare two %s values", t1);
  else
    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x31275(%rip), %rax     # 0x40780
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x31254(%rip), %rax     # 0x40780
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jne 0xf557
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x263ba(%rip), %rsi     # 0x3590a
movb $0x0, %al
callq 0xf360
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x263bf(%rip), %rsi     # 0x3592b
movb $0x0, %al
callq 0xf360
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: luaG_errormsg
l_noret luaG_errormsg (lua_State *L) {
  if (L->errfunc != 0) {  /* is there an error handling function? */
    StkId errfunc = restorestack(L, L->errfunc);
    if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR);
    setobjs2s(L, L->top, L->top - 1);  /* move argument */
    setobjs2s(L, L->top - 1, errfunc);  /* push function */
    L->top++;
    luaD_call(L, L->top - 2, 1, 0);  /* call it */
  }
  luaD_throw(L, LUA_ERRRUN);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0xf67a
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x30(%rsp), %rcx
addq 0x78(%rcx), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x6, %eax
je 0xf5cf
movq 0x30(%rsp), %rdi
movl $0x6, %esi
callq 0xfe30
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
addq $-0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
addq $-0x10, %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 0x30(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rsi
addq $-0x20, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x10e90
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0xfe30
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: addinfo
static void addinfo (lua_State *L, const char *msg) {
  CallInfo *ci = L->ci;
  if (isLua(ci)) {  /* is Lua code? */
    char buff[LUA_IDSIZE];  /* add file:line information */
    int line = currentline(ci);
    TString *src = ci_func(ci)->p->source;
    if (src)
      luaO_chunkid(buff, getstr(src), LUA_IDSIZE);
    else {  /* no source available; use "?" instead */
      buff[0] = '?'; buff[1] = '\0';
    }
    luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movzbl 0x22(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xf72d
movq 0x50(%rsp), %rdi
callq 0xf900
movl %eax, 0xc(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x48(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0xf702
leaq 0x10(%rsp), %rdi
movq (%rsp), %rsi
addq $0x18, %rsi
movl $0x3c, %edx
callq 0x1a280
jmp 0xf70c
movb $0x3f, 0x10(%rsp)
movb $0x0, 0x11(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
movq 0x58(%rsp), %r8
leaq 0x2627c(%rip), %rsi     # 0x359a2
movb $0x0, %al
callq 0x1a1b0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldebug.c
// Function: findvararg
static const char *findvararg (CallInfo *ci, int n, StkId *pos) {
  int nparams = clLvalue(ci->func)->p->numparams;
  if (n >= ci->u.l.base - ci->func - nparams)
    return NULL;  /* no such vararg */
  else {
    *pos = ci->func + nparams + n;
    return "(*vararg)";  /* generic name for any vararg */
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movzbl 0x78(%rax), %eax
movl %eax, -0x24(%rsp)
movslq -0x14(%rsp), %rax
movq -0x10(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq -0x10(%rsp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
movslq -0x24(%rsp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jl 0xf79a
movq $0x0, -0x8(%rsp)
jmp 0xf7ce
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movslq -0x24(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movslq -0x14(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
leaq 0x2618d(%rip), %rax     # 0x35956
movq %rax, -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/ldebug.c
// Function: getfuncname
static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
  TMS tm;
  Proto *p = ci_func(ci)->p;  /* calling function */
  int pc = currentpc(ci);  /* calling instruction index */
  Instruction i = p->code[pc];  /* calling instruction */
  switch (GET_OPCODE(i)) {
    case OP_CALL:
    case OP_TAILCALL:  /* get function name */
      return getobjname(p, pc, GETARG_A(i), name);
    case OP_TFORCALL: {  /* for iterator */
      *name = "for iterator";
       return "for iterator";
    }
    /* all other instructions can call only through metamethods */
    case OP_SELF:
    case OP_GETTABUP:
    case OP_GETTABLE: tm = TM_INDEX; break;
    case OP_SETTABUP:
    case OP_SETTABLE: tm = TM_NEWINDEX; break;
    case OP_EQ: tm = TM_EQ; break;
    case OP_ADD: tm = TM_ADD; break;
    case OP_SUB: tm = TM_SUB; break;
    case OP_MUL: tm = TM_MUL; break;
    case OP_DIV: tm = TM_DIV; break;
    case OP_MOD: tm = TM_MOD; break;
    case OP_POW: tm = TM_POW; break;
    case OP_UNM: tm = TM_UNM; break;
    case OP_LEN: tm = TM_LEN; break;
    case OP_LT: tm = TM_LT; break;
    case OP_LE: tm = TM_LE; break;
    case OP_CONCAT: tm = TM_CONCAT; break;
    default:
      return NULL;  /* else no useful name can be found */
  }
  *name = getstr(G(L)->tmname[tm]);
  return "metamethod";
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0xf330
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
andl $0x3f, %eax
addl $-0x6, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x1c, %eax
ja 0xfac5
movq 0x8(%rsp), %rax
leaq 0x25ddc(%rip), %rcx     # 0x357bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
shrl $0x6, %edx
andl $0xff, %edx
movq 0x28(%rsp), %rcx
callq 0xf050
movq %rax, 0x40(%rsp)
jmp 0xfafd
movq 0x28(%rsp), %rax
leaq 0x25f50(%rip), %rcx     # 0x3596f
movq %rcx, (%rax)
leaq 0x25f46(%rip), %rax     # 0x3596f
movq %rax, 0x40(%rsp)
jmp 0xfafd
movl $0x0, 0x24(%rsp)
jmp 0xfad0
movl $0x1, 0x24(%rsp)
jmp 0xfad0
movl $0x5, 0x24(%rsp)
jmp 0xfad0
movl $0x6, 0x24(%rsp)
jmp 0xfad0
movl $0x7, 0x24(%rsp)
jmp 0xfad0
movl $0x8, 0x24(%rsp)
jmp 0xfad0
movl $0x9, 0x24(%rsp)
jmp 0xfad0
movl $0xa, 0x24(%rsp)
jmp 0xfad0
movl $0xb, 0x24(%rsp)
jmp 0xfad0
movl $0xc, 0x24(%rsp)
jmp 0xfad0
movl $0x4, 0x24(%rsp)
jmp 0xfad0
movl $0xd, 0x24(%rsp)
jmp 0xfad0
movl $0xe, 0x24(%rsp)
jmp 0xfad0
movl $0xf, 0x24(%rsp)
jmp 0xfad0
movq $0x0, 0x40(%rsp)
jmp 0xfafd
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x24(%rsp), %ecx
movq 0x120(%rax,%rcx,8), %rcx
addq $0x18, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
leaq 0x25e84(%rip), %rax     # 0x3597c
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: luaD_throw
l_noret luaD_throw (lua_State *L, int errcode) {
  if (L->errorJmp) {  /* thread has an error handler? */
    L->errorJmp->status = errcode;  /* set status */
    LUAI_THROW(L, L->errorJmp);  /* jump to it */
  }
  else {  /* thread has no error handler */
    L->status = cast_byte(errcode);  /* mark it as dead */
    if (G(L)->mainthread->errorJmp) {  /* main thread has a handler? */
      setobjs2s(L, G(L)->mainthread->top++, L->top - 1);  /* copy error obj. */
      luaD_throw(G(L)->mainthread, errcode);  /* re-throw in main thread */
    }
    else {  /* no handler at all; abort */
      if (G(L)->panic) {  /* panic function? */
        lua_unlock(L);
        G(L)->panic(L);  /* call it (last chance to jump out) */
      }
      abort();
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0xfe73
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movq 0x70(%rax), %rax
movl %ecx, 0xd0(%rax)
movq 0x20(%rsp), %rax
movq 0x70(%rax), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x7440
movl 0x1c(%rsp), %eax
movb %al, %cl
movq 0x20(%rsp), %rax
movb %cl, 0xa(%rax)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x108(%rax), %rax
cmpq $0x0, 0x70(%rax)
je 0xff07
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
addq $-0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x108(%rax), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
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 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x108(%rax), %rdi
movl 0x1c(%rsp), %esi
callq 0xfe30
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x100(%rax)
je 0xff31
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x100(%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
callq 0x7060
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: correctstack
static void correctstack (lua_State *L, TValue *oldstack) {
  CallInfo *ci;
  GCObject *up;
  L->top = (L->top - oldstack) + L->stack;
  for (up = L->openupval; up != NULL; up = up->gch.next)
    gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;
  for (ci = L->ci; ci != NULL; ci = ci->previous) {
    ci->top = (ci->top - oldstack) + L->stack;
    ci->func = (ci->func - oldstack) + L->stack;
    if (isLua(ci))
      ci->u.l.base = (ci->u.l.base - oldstack) + L->stack;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rsp), %rax
subq %rax, %rcx
sarq $0x4, %rcx
movq -0x8(%rsp), %rax
shlq $0x4, %rcx
addq 0x38(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0x10185
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rsp), %rax
subq %rax, %rcx
sarq $0x4, %rcx
movq -0x8(%rsp), %rax
shlq $0x4, %rcx
addq 0x38(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x10143
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x10244
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
subq %rax, %rcx
sarq $0x4, %rcx
movq -0x8(%rsp), %rax
shlq $0x4, %rcx
addq 0x38(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
subq %rax, %rcx
sarq $0x4, %rcx
movq -0x8(%rsp), %rax
shlq $0x4, %rcx
addq 0x38(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movzbl 0x22(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1022f
movq -0x18(%rsp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rsp), %rax
subq %rax, %rcx
sarq $0x4, %rcx
movq -0x8(%rsp), %rax
shlq $0x4, %rcx
addq 0x38(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x10231
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x10193
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: luaD_shrinkstack
void luaD_shrinkstack (lua_State *L) {
  int inuse = stackinuse(L);
  int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK;
  if (goodsize > LUAI_MAXSTACK) goodsize = LUAI_MAXSTACK;
  if (inuse > LUAI_MAXSTACK ||  /* handling stack overflow? */
      goodsize >= L->stacksize)  /* would grow instead of shrink? */
    condmovestack(L);  /* don't change stack (change only for debugging) */
  else
    luaD_reallocstack(L, goodsize);  /* shrink it */
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x10390
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x4(%rsp), %eax
addl %ecx, %eax
addl $0xa, %eax
movl %eax, 0x8(%rsp)
cmpl $0xf4240, 0x8(%rsp)     # imm = 0xF4240
jle 0x1035c
movl $0xf4240, 0x8(%rsp)     # imm = 0xF4240
cmpl $0xf4240, 0xc(%rsp)     # imm = 0xF4240
jg 0x10374
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x40(%rcx), %eax
jl 0x10376
jmp 0x10384
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x10000
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: luaD_poscall
int luaD_poscall (lua_State *L, StkId firstResult) {
  StkId res;
  int wanted, i;
  CallInfo *ci = L->ci;
  if (L->hookmask & (LUA_MASKRET | LUA_MASKLINE)) {
    if (L->hookmask & LUA_MASKRET) {
      ptrdiff_t fr = savestack(L, firstResult);  /* hook may change stack */
      luaD_hook(L, LUA_HOOKRET, -1);
      firstResult = restorestack(L, fr);
    }
    L->oldpc = ci->previous->u.l.savedpc;  /* 'oldpc' for caller function */
  }
  res = ci->func;  /* res == final position of 1st result */
  wanted = ci->nresults;
  L->ci = ci = ci->previous;  /* back to caller */
  /* move results to correct place */
  for (i = wanted; i != 0 && firstResult < L->top; i--)
    setobjs2s(L, res++, firstResult++);
  while (i-- > 0)
    setnilvalue(res++);
  L->top = res;
  return (wanted - LUA_MULTRET);  /* 0 iff wanted == LUA_MULTRET */
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movzbl 0x48(%rax), %eax
andl $0x6, %eax
cmpl $0x0, %eax
je 0x10a61
movq 0x40(%rsp), %rax
movzbl 0x48(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x10a4b
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x10410
movq 0x40(%rsp), %rax
movq 0x38(%rax), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rax
movswl 0x20(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rcx, 0x20(%rax)
movl 0x2c(%rsp), %eax
movl %eax, 0x28(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x28(%rsp)
movb %al, 0x7(%rsp)
je 0x10abc
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpq 0x10(%rcx), %rax
setb %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x10ac6
jmp 0x10b22
movq 0x38(%rsp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x38(%rsp)
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x30(%rsp)
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)
movl 0x28(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x10a9a
jmp 0x10b24
movl 0x28(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x28(%rsp)
cmpl $0x0, %eax
jle 0x10b50
movq 0x30(%rsp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x30(%rsp)
movl $0x0, 0x8(%rax)
jmp 0x10b24
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x2c(%rsp), %eax
subl $-0x1, %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: adjust_varargs
static StkId adjust_varargs (lua_State *L, Proto *p, int actual) {
  int i;
  int nfixargs = p->numparams;
  StkId base, fixed;
  lua_assert(actual >= nfixargs);
  /* move fixed parameters to final position */
  luaD_checkstack(L, p->maxstacksize);  /* check again for new 'base' */
  fixed = L->top - actual;  /* first fixed argument */
  base = L->top;  /* final position of first argument */
  for (i=0; i<nfixargs; i++) {
    setobjs2s(L, L->top++, fixed + i);
    setnilvalue(fixed + i);
  }
  return base;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x38(%rsp), %rax
movzbl 0x78(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x40(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movq 0x38(%rsp), %rcx
movzbl 0x7a(%rcx), %ecx
cmpq %rcx, %rax
jg 0x10bcb
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rax
movzbl 0x7a(%rax), %esi
callq 0x10250
jmp 0x10bcd
jmp 0x10bcd
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x34(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x10c80
movq 0x18(%rsp), %rax
movslq 0x30(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
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
movslq 0x30(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x10c02
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: tryfuncTM
static StkId tryfuncTM (lua_State *L, StkId func) {
  const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);
  StkId p;
  ptrdiff_t funcr = savestack(L, func);
  if (!ttisfunction(tm))
    luaG_typeerror(L, func, "call");
  /* Open a hole inside the stack at `func' */
  for (p = L->top; p > func; p--) setobjs2s(L, p, p-1);
  incr_top(L);
  func = restorestack(L, funcr);  /* previous call may change stack */
  setobj2s(L, func, tm);  /* tag method is the new function to be called */
  return func;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0x10, %edx
callq 0x26540
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x6, %eax
je 0x10d93
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
leaq 0x26b5c(%rip), %rdx     # 0x378ea
callq 0xee00
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x38(%rsp), %rax
jbe 0x10df5
movq 0x28(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x28(%rsp)
jmp 0x10da1
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x40(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
cmpq $0x0, %rax
jg 0x10e33
movq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x10250
jmp 0x10e35
jmp 0x10e35
movq 0x40(%rsp), %rax
movq 0x38(%rax), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
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 0x38(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: luaD_call
void luaD_call (lua_State *L, StkId func, int nResults, int allowyield) {
  if (++L->nCcalls >= LUAI_MAXCCALLS) {
    if (L->nCcalls == LUAI_MAXCCALLS)
      luaG_runerror(L, "C stack overflow");
    else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
      luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
  }
  if (!allowyield) L->nny++;
  if (!luaD_precall(L, func, nResults))  /* is a Lua function? */
    luaV_execute(L);  /* call it */
  if (!allowyield) L->nny--;
  L->nCcalls--;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl %ecx, (%rsp)
movq 0x10(%rsp), %rcx
movw 0x46(%rcx), %ax
addw $0x1, %ax
movw %ax, 0x46(%rcx)
movzwl %ax, %eax
cmpl $0xc8, %eax
jl 0x10f06
movq 0x10(%rsp), %rax
movzwl 0x46(%rax), %eax
cmpl $0xc8, %eax
jne 0x10ee3
movq 0x10(%rsp), %rdi
leaq 0x24ad0(%rip), %rsi     # 0x359ac
movb $0x0, %al
callq 0xf360
movq 0x10(%rsp), %rax
movzwl 0x46(%rax), %eax
cmpl $0xe1, %eax
jl 0x10f02
movq 0x10(%rsp), %rdi
movl $0x6, %esi
callq 0xfe30
jmp 0x10f04
jmp 0x10f06
cmpl $0x0, (%rsp)
jne 0x10f1d
movq 0x10(%rsp), %rax
movw 0x44(%rax), %cx
addw $0x1, %cx
movw %cx, 0x44(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x105e0
cmpl $0x0, %eax
jne 0x10f3f
movq 0x10(%rsp), %rdi
callq 0x28c60
cmpl $0x0, (%rsp)
jne 0x10f56
movq 0x10(%rsp), %rax
movw 0x44(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x44(%rax)
movq 0x10(%rsp), %rax
movw 0x46(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x46(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: lua_resume
LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) {
  int status;
  int oldnny = L->nny;  /* save 'nny' */
  lua_lock(L);
  luai_userstateresume(L, nargs);
  L->nCcalls = (from) ? from->nCcalls + 1 : 1;
  L->nny = 0;  /* allow yields */
  api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs);
  status = luaD_rawrunprotected(L, resume, L->top - nargs);
  if (status == -1)  /* error calling 'lua_resume'? */
    status = LUA_ERRRUN;
  else {  /* yield or regular error */
    while (status != LUA_OK && status != LUA_YIELD) {  /* error? */
      if (recover(L, status))  /* recover point? */
        status = luaD_rawrunprotected(L, unroll, NULL);  /* run continuation */
      else {  /* unrecoverable error */
        L->status = cast_byte(status);  /* mark thread as `dead' */
        seterrorobj(L, status, L->top);
        L->ci->top = L->top;
        break;
      }
    }
    lua_assert(status == L->status);
  }
  L->nny = oldnny;  /* restore 'nny' */
  L->nCcalls--;
  lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));
  lua_unlock(L);
  return status;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movzwl 0x44(%rax), %eax
movl %eax, 0xc(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x10fa9
movq 0x18(%rsp), %rax
movzwl 0x46(%rax), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10fb4
movl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10fb4
movl 0x8(%rsp), %eax
movw %ax, %cx
movq 0x20(%rsp), %rax
movw %cx, 0x46(%rax)
movq 0x20(%rsp), %rax
movw $0x0, 0x44(%rax)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdx
movslq 0x14(%rsp), %rcx
xorl %eax, %eax
subq %rcx, %rax
shlq $0x4, %rax
addq %rax, %rdx
leaq 0xeb(%rip), %rsi        # 0x110e0
callq 0xff40
movl %eax, 0x10(%rsp)
cmpl $-0x1, 0x10(%rsp)
jne 0x11012
movl $0x2, 0x10(%rsp)
jmp 0x110a9
jmp 0x11014
xorl %eax, %eax
cmpl $0x0, 0x10(%rsp)
movb %al, 0x7(%rsp)
je 0x1102d
cmpl $0x1, 0x10(%rsp)
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x11037
jmp 0x110a7
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x11280
cmpl $0x0, %eax
je 0x11065
movq 0x20(%rsp), %rdi
leaq 0x30a(%rip), %rsi       # 0x11360
xorl %eax, %eax
movl %eax, %edx
callq 0xff40
movl %eax, 0x10(%rsp)
jmp 0x110a2
movl 0x10(%rsp), %eax
movb %al, %cl
movq 0x20(%rsp), %rax
movb %cl, 0xa(%rax)
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x113d0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x110a7
jmp 0x11014
jmp 0x110a9
movl 0xc(%rsp), %eax
movw %ax, %cx
movq 0x20(%rsp), %rax
movw %cx, 0x44(%rax)
movq 0x20(%rsp), %rax
movw 0x46(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x46(%rax)
movl 0x10(%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/ldo.c
// Function: recover
static int recover (lua_State *L, int status) {
  StkId oldtop;
  CallInfo *ci = findpcall(L);
  if (ci == NULL) return 0;  /* no recovery point */
  /* "finish" luaD_pcall */
  oldtop = restorestack(L, ci->extra);
  luaF_close(L, oldtop);
  seterrorobj(L, status, oldtop);
  L->ci = ci;
  L->allowhook = ci->u.c.old_allowhook;
  L->nny = 0;  /* should be zero to be yieldable */
  luaD_shrinkstack(L);
  L->errfunc = ci->u.c.old_errfunc;
  ci->callstatus |= CIST_STAT;  /* call has error status */
  ci->u.c.status = status;  /* (here it is) */
  return 1;  /* continue running the coroutine */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x11ab0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x112af
movl $0x0, 0x24(%rsp)
jmp 0x1134c
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rsp), %rcx
addq 0x28(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x12660
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x113d0
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movb 0x48(%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, 0x49(%rax)
movq 0x18(%rsp), %rax
movw $0x0, 0x44(%rax)
movq 0x18(%rsp), %rdi
callq 0x10310
movq (%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x78(%rax)
movq (%rsp), %rax
movzbl 0x22(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x22(%rax)
movl 0x14(%rsp), %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0x49(%rax)
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/ldo.c
// Function: unroll
static void unroll (lua_State *L, void *ud) {
  UNUSED(ud);
  for (;;) {
    if (L->ci == &L->base_ci)  /* stack is empty? */
      return;  /* coroutine finished normally */
    if (!isLua(L->ci))  /* C function? */
      finishCcall(L);
    else {  /* Lua function */
      luaV_finishOp(L);  /* finish interrupted instruction */
      luaV_execute(L);  /* execute down to higher C 'boundary' */
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
addq $0x80, %rcx
cmpq %rcx, %rax
jne 0x1138d
addq $0x18, %rsp
retq
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movzbl 0x22(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x113ae
movq 0x10(%rsp), %rdi
callq 0x11b10
jmp 0x113c2
movq 0x10(%rsp), %rdi
callq 0x28960
movq 0x10(%rsp), %rdi
callq 0x28c60
jmp 0x1136e
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: f_parser
static void f_parser (lua_State *L, void *ud) {
  int i;
  Closure *cl;
  struct SParser *p = cast(struct SParser *, ud);
  int c = zgetc(p->z);  /* read first character */
  if (c == LUA_SIGNATURE[0]) {
    checkmode(L, p->mode, "binary");
    cl = luaU_undump(L, p->z, &p->buff, p->name);
  }
  else {
    checkmode(L, p->mode, "text");
    cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
  }
  lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues);
  for (i = 0; i < cl->l.nupvalues; i++) {  /* initialize upvalues */
    UpVal *up = luaF_newupval(L);
    cl->l.upvals[i] = up;
    luaC_objbarrier(L, cl, up);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0x118d3
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x118e4
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x2c3a0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movsbl 0x23c76(%rip), %ecx     # 0x3556d
cmpl %ecx, %eax
jne 0x11940
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rsi
leaq 0x2415c(%rip), %rdx     # 0x35a6c
callq 0x11c10
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rdx
addq $0x8, %rdx
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rcx
callq 0x26610
movq %rax, 0x28(%rsp)
jmp 0x11991
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rsi
leaq 0x2411e(%rip), %rdx     # 0x35a73
callq 0x11c10
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rdx
addq $0x8, %rdx
movq 0x20(%rsp), %rcx
addq $0x20, %rcx
movq 0x20(%rsp), %rax
movq 0x58(%rax), %r8
movl 0x1c(%rsp), %r9d
callq 0x1b1f0
movq %rax, 0x28(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movq 0x28(%rsp), %rcx
movzbl 0xa(%rcx), %ecx
cmpl %ecx, %eax
jge 0x11a12
movq 0x40(%rsp), %rdi
callq 0x12410
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdx
movq 0x28(%rsp), %rax
movslq 0x34(%rsp), %rcx
movq %rdx, 0x20(%rax,%rcx,8)
movq 0x10(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x11a03
movq 0x28(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x11a03
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x12aa0
jmp 0x11a05
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x11999
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldo.c
// Function: finishCcall
static void finishCcall (lua_State *L) {
  CallInfo *ci = L->ci;
  int n;
  lua_assert(ci->u.c.k != NULL);  /* must have a continuation */
  lua_assert(L->nny == 0);
  if (ci->callstatus & CIST_YPCALL) {  /* was inside a pcall? */
    ci->callstatus &= ~CIST_YPCALL;  /* finish 'lua_pcall' */
    L->errfunc = ci->u.c.old_errfunc;
  }
  /* finish 'lua_callk'/'lua_pcall' */
  adjustresults(L, ci->nresults);
  /* call continuation function */
  if (!(ci->callstatus & CIST_STAT))  /* no call status? */
    ci->u.c.status = LUA_YIELD;  /* 'default' status */
  lua_assert(ci->u.c.status != LUA_OK);
  ci->callstatus = (ci->callstatus & ~(CIST_YPCALL | CIST_STAT)) | CIST_YIELDED;
  lua_unlock(L);
  n = (*ci->u.c.k)(L);
  lua_lock(L);
  api_checknelems(L, n);
  /* finish 'luaD_precall' */
  luaD_poscall(L, L->top - n);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl 0x22(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x11b59
movq 0x8(%rsp), %rax
movzbl 0x22(%rax), %ecx
andl $-0x11, %ecx
movb %cl, 0x22(%rax)
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x78(%rax)
movq 0x8(%rsp), %rax
movswl 0x20(%rax), %eax
cmpl $-0x1, %eax
jne 0x11b95
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x11b95
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movzbl 0x22(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x11baf
movq 0x8(%rsp), %rax
movb $0x1, 0x49(%rax)
movq 0x8(%rsp), %rax
movzbl 0x22(%rax), %eax
andl $-0x31, %eax
orl $0x8, %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0x22(%rax)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movslq 0x4(%rsp), %rcx
xorl %eax, %eax
subq %rcx, %rax
shlq $0x4, %rax
addq %rax, %rsi
callq 0x109d0
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/ldo.c
// Function: checkmode
static void checkmode (lua_State *L, const char *mode, const char *x) {
  if (mode && strchr(mode, x[0]) == NULL) {
    luaO_pushfstring(L,
       "attempt to load a %s chunk (mode is " LUA_QS ")", x, mode);
    luaD_throw(L, LUA_ERRSYNTAX);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x11c6c
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movsbl (%rax), %esi
callq 0x7190
cmpq $0x0, %rax
jne 0x11c6c
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0x23e22(%rip), %rsi     # 0x35a78
movb $0x0, %al
callq 0x1a1b0
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0xfe30
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldump.c
// Function: luaU_dump
int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
{
 DumpState D;
 D.L=L;
 D.writer=w;
 D.data=data;
 D.strip=strip;
 D.status=0;
 DumpHeader(&D);
 DumpFunction(f,&D);
 return D.status;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x18(%rsp)
movl $0x0, 0x1c(%rsp)
movq %rsp, %rdi
callq 0x11cf0
movq 0x38(%rsp), %rdi
movq %rsp, %rsi
callq 0x11d20
movl 0x1c(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldump.c
// Function: DumpFunction
static void DumpFunction(const Proto* f, DumpState* D)
{
 DumpInt(f->linedefined,D);
 DumpInt(f->lastlinedefined,D);
 DumpChar(f->numparams,D);
 DumpChar(f->is_vararg,D);
 DumpChar(f->maxstacksize,D);
 DumpCode(f,D);
 DumpConstants(f,D);
 DumpUpvalues(f,D);
 DumpDebug(f,D);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x68(%rax), %edi
movq 0x8(%rsp), %rsi
callq 0x11e30
movq 0x10(%rsp), %rax
movl 0x6c(%rax), %edi
movq 0x8(%rsp), %rsi
callq 0x11e30
movq 0x10(%rsp), %rax
movzbl 0x78(%rax), %edi
movq 0x8(%rsp), %rsi
callq 0x11e60
movq 0x10(%rsp), %rax
movzbl 0x79(%rax), %edi
movq 0x8(%rsp), %rsi
callq 0x11e60
movq 0x10(%rsp), %rax
movzbl 0x7a(%rax), %edi
movq 0x8(%rsp), %rsi
callq 0x11e60
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x58(%rax), %esi
movq 0x8(%rsp), %rcx
movl $0x4, %edx
callq 0x11e90
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11ee0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x12030
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x120c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldump.c
// Function: DumpConstants
static void DumpConstants(const Proto* f, DumpState* D)
{
 int i,n=f->sizek;
 DumpInt(n,D);
 for (i=0; i<n; i++)
 {
  const TValue* o=&f->k[i];
  DumpChar(ttypenv(o),D);
  switch (ttypenv(o))
  {
   case LUA_TNIL:
	break;
   case LUA_TBOOLEAN:
	DumpChar(bvalue(o),D);
	break;
   case LUA_TNUMBER:
	DumpNumber(nvalue(o),D);
	break;
   case LUA_TSTRING:
	DumpString(rawtsvalue(o),D);
	break;
    default: lua_assert(0);
  }
 }
 n=f->sizep;
 DumpInt(n,D);
 for (i=0; i<n; i++) DumpFunction(f->p[i],D);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl 0x54(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x11e30
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x11fc9
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edi
andl $0xf, %edi
movq 0x18(%rsp), %rsi
callq 0x11e60
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
andl $0xf, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x4, %eax
ja 0x11fb5
movq (%rsp), %rax
leaq 0x23b36(%rip), %rcx     # 0x35aa4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x11fb7
movq 0x8(%rsp), %rax
movl (%rax), %edi
movq 0x18(%rsp), %rsi
callq 0x11e60
jmp 0x11fb7
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
movq 0x18(%rsp), %rdi
callq 0x12280
jmp 0x11fb7
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x122b0
jmp 0x11fb7
jmp 0x11fb7
jmp 0x11fb9
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x11f10
movq 0x20(%rsp), %rax
movl 0x60(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x11e30
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x1201e
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rsi
callq 0x11d20
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x11feb
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/ldump.c
// Function: DumpUpvalues
static void DumpUpvalues(const Proto* f, DumpState* D)
{
 int i,n=f->sizeupvalues;
 DumpInt(n,D);
 for (i=0; i<n; i++)
 {
  DumpChar(f->upvalues[i].instack,D);
  DumpChar(f->upvalues[i].idx,D);
 }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, (%rsp)
movl (%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x11e30
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jge 0x120ba
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x8(%rax), %edi
movq 0x8(%rsp), %rsi
callq 0x11e60
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x9(%rax), %edi
movq 0x8(%rsp), %rsi
callq 0x11e60
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1205e
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldump.c
// Function: DumpDebug
static void DumpDebug(const Proto* f, DumpState* D)
{
 int i,n;
 DumpString((D->strip) ? NULL : f->source,D);
 n= (D->strip) ? 0 : f->sizelineinfo;
 DumpVector(f->lineinfo,n,sizeof(int),D);
 n= (D->strip) ? 0 : f->sizelocvars;
 DumpInt(n,D);
 for (i=0; i<n; i++)
 {
  DumpString(f->locvars[i].varname,D);
  DumpInt(f->locvars[i].startpc,D);
  DumpInt(f->locvars[i].endpc,D);
 }
 n= (D->strip) ? 0 : f->sizeupvalues;
 DumpInt(n,D);
 for (i=0; i<n; i++) DumpString(f->upvalues[i].name,D);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x120e2
xorl %eax, %eax
movq %rax, 0x18(%rsp)
jmp 0x120f0
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x122b0
movq 0x28(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x12112
xorl %eax, %eax
movl %eax, 0x14(%rsp)
jmp 0x1211e
movq 0x30(%rsp), %rax
movl 0x5c(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rdi
movl 0x20(%rsp), %esi
movq 0x28(%rsp), %rcx
movl $0x4, %edx
callq 0x11e90
movq 0x28(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x12155
xorl %eax, %eax
movl %eax, 0x10(%rsp)
jmp 0x12161
movq 0x30(%rsp), %rax
movl 0x64(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %edi
movq 0x28(%rsp), %rsi
callq 0x11e30
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x121fc
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x122b0
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edi
movq 0x28(%rsp), %rsi
callq 0x11e30
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rax
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %edi
movq 0x28(%rsp), %rsi
callq 0x11e30
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1217f
movq 0x28(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0x1220f
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x1221b
movq 0x30(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %edi
movq 0x28(%rsp), %rsi
callq 0x11e30
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x12272
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x122b0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x12239
addq $0x38, %rsp
retq
nopw (%rax,%rax)