LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldebug.c
// Function: lua_getlocal
LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
  const char *name;
  lua_lock(L);
  swapextra(L);
  if (ar == NULL) {  /* information about non-active function? */
    if (!isLfunction(L->top - 1))  /* not a Lua function? */
      name = NULL;
    else  /* consider live variables at function start (parameters) */
      name = luaF_getlocalname(clLvalue(L->top - 1)->p, n, 0);
  }
  else {  /* active function; get information through 'ar' */
    StkId pos = NULL;  /* to avoid warnings */
    name = findlocal(L, ar->i_ci, n, &pos);
    if (name) {
      setobj2s(L, L->top, pos);
      api_incr_top(L);
    }
  }
  swapextra(L);
  lua_unlock(L);
  return name;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x1, 0xc(%rdi)
jne 0x7776
movq 0x20(%rbx), %rax
movq 0x38(%rbx), %rcx
movq (%rax), %rdi
movq 0x38(%rax), %r8
addq %rcx, %r8
movq %r8, (%rax)
subq %rcx, %rdi
movq %rdi, 0x38(%rax)
testq %rsi, %rsi
je 0x77ae
leaq 0x8(%rsp), %rcx
movq $0x0, (%rcx)
movq 0x78(%rsi), %rsi
movq %rbx, %rdi
callq 0x77f5
testq %rax, %rax
je 0x77cd
movq 0x10(%rbx), %rcx
movq 0x8(%rsp), %rdx
movups (%rdx), %xmm0
movups %xmm0, (%rcx)
addq $0x10, 0x10(%rbx)
jmp 0x77cd
movq 0x10(%rbx), %rax
cmpl $0x46, -0x8(%rax)
jne 0x77cb
movq -0x10(%rax), %rax
movq 0x18(%rax), %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0xa0ff
jmp 0x77cd
xorl %eax, %eax
cmpb $0x1, 0xc(%rbx)
jne 0x77ef
movq 0x20(%rbx), %rcx
movq 0x38(%rbx), %rdx
movq (%rcx), %rsi
movq 0x38(%rcx), %rdi
addq %rdx, %rdi
movq %rdi, (%rcx)
subq %rdx, %rsi
movq %rsi, 0x38(%rcx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldebug.c
// Function: findlocal
static const char *findlocal (lua_State *L, CallInfo *ci, int n,
                              StkId *pos) {
  const char *name = NULL;
  StkId base;
  if (isLua(ci)) {
    if (n < 0)  /* access to vararg values? */
      return findvararg(ci, -n, pos);
    else {
      base = ci->u.l.base;
      name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci));
    }
  }
  else
    base = ci->func + 1;
  if (name == NULL) {  /* no 'standard' name? */
    StkId limit = (ci == L->ci) ? L->top : ci->next->func;
    if (limit - base >= n && n > 0)  /* is 'n' inside 'ci' stack? */
      name = "(*temporary)";  /* generic name for any valid slot */
    else
      return NULL;  /* no name */
  }
  *pos = base + (n - 1);
  return name;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
testb $0x2, 0x42(%rsi)
movslq %edx, %r12
jne 0x7827
movq (%r15), %r13
addq $0x10, %r13
cmpq %r15, 0x20(%r14)
je 0x7855
movq 0x18(%r15), %r14
jmp 0x7859
testl %ebp, %ebp
js 0x7893
movq (%r15), %rax
movq 0x20(%r15), %r13
movq (%rax), %rax
movq 0x18(%rax), %rdi
movq 0x28(%r15), %rdx
subq 0x38(%rdi), %rdx
shrq $0x2, %rdx
decl %edx
movl %ebp, %esi
callq 0xa0ff
testq %rax, %rax
jne 0x7875
jmp 0x781b
addq $0x10, %r14
xorl %eax, %eax
testl %ebp, %ebp
jle 0x7884
movq (%r14), %rcx
subq %r13, %rcx
sarq $0x4, %rcx
cmpq %r12, %rcx
jl 0x7884
leaq 0x1aafe(%rip), %rax     # 0x22373
shlq $0x4, %r12
leaq (%r12,%r13), %rcx
addq $-0x10, %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
negl %ebp
movq (%r15), %rcx
movq 0x20(%r15), %rdx
movq (%rcx), %rax
movq 0x18(%rax), %rax
movzbl 0xa(%rax), %eax
subq %rcx, %rdx
shrq $0x4, %rdx
subl %eax, %edx
cmpl %ebp, %edx
jle 0x78cc
shll $0x4, %eax
movl %ebp, %edx
shlq $0x4, %rdx
addq %rdx, %rcx
addq %rax, %rcx
leaq 0x1aab6(%rip), %rax     # 0x22380
jmp 0x7881
xorl %eax, %eax
jmp 0x7884
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldebug.c
// Function: luaG_runerror
l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
  CallInfo *ci = L->ci;
  const char *msg;
  va_list argp;
  va_start(argp, fmt);
  msg = luaO_pushvfstring(L, fmt, argp);  /* format message */
  va_end(argp);
  if (isLua(ci))  /* if Lua function, add source:line information */
    luaG_addinfo(L, msg, ci_func(ci)->p->source, currentline(ci));
  luaG_errormsg(L);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x7e30
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x20(%rbx), %r14
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq %rbx, %rdi
callq 0xbfc5
testb $0x2, 0x42(%r14)
je 0x7eaa
movq (%r14), %rcx
movq (%rcx), %rcx
movq 0x18(%rcx), %rdi
movq 0x48(%rdi), %rsi
movq 0x68(%rdi), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x7e9f
movq 0x28(%r14), %rcx
subq 0x38(%rdi), %rcx
shlq $0x1e, %rcx
movabsq $-0x100000000, %rdi     # imm = 0xFFFFFFFF00000000
addq %rcx, %rdi
sarq $0x20, %rdi
movl (%rsi,%rdi,4), %ecx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8097
movq %rbx, %rdi
callq 0x80ef
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldebug.c
// Function: varinfo
static const char *varinfo (lua_State *L, const TValue *o) {
  const char *name = NULL;  /* to avoid warnings */
  CallInfo *ci = L->ci;
  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);
  }
  return (kind) ? luaO_pushfstring(L, " (%s '%s')", kind, name) : "";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
movq 0x20(%rdi), %rax
testb $0x2, 0x42(%rax)
je 0x7f3b
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rax), %rcx
movq (%rcx), %rcx
movzbl 0xa(%rcx), %esi
testq %rsi, %rsi
je 0x7ef7
shll $0x3, %esi
xorl %edi, %edi
movq 0x20(%rcx,%rdi), %r8
cmpq %rdx, (%r8)
je 0x7f48
addq $0x8, %rdi
cmpq %rdi, %rsi
jne 0x7ee4
movq 0x20(%rax), %rsi
subq %rsi, %rdx
js 0x7f3b
movq 0x8(%rax), %rdi
subq %rsi, %rdi
cmpq %rdi, %rdx
jge 0x7f3b
movq 0x18(%rcx), %rdi
movq 0x28(%rax), %rsi
subq 0x38(%rdi), %rsi
shrq $0x2, %rsi
decl %esi
shrq $0x4, %rdx
leaq 0x8(%rsp), %rcx
callq 0x829d
testq %rax, %rax
je 0x7f3b
movq %rax, %rdx
movq 0x8(%rsp), %rcx
jmp 0x7f6d
leaq 0x1ce46(%rip), %rax     # 0x24d88
addq $0x10, %rsp
popq %rbx
retq
movq 0x18(%rcx), %rax
movq 0x58(%rax), %rax
movq (%rax,%rdi,2), %rax
leaq 0x18(%rax), %rdx
testq %rax, %rax
leaq 0x1a430(%rip), %rcx     # 0x22392
cmovneq %rdx, %rcx
leaq 0x1bde3(%rip), %rdx     # 0x23d50
leaq 0x1a458(%rip), %rsi     # 0x223cc
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0xc391
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldebug.c
// Function: luaG_opinterror
l_noret luaG_opinterror (lua_State *L, const TValue *p1,
                         const TValue *p2, const char *msg) {
  lua_Number temp;
  if (!tonumber(p1, &temp))  /* first operand is wrong? */
    p2 = p1;  /* now second is wrong */
  luaG_typeerror(L, p2, msg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
cmpl $0x3, 0x8(%rsi)
jne 0x7fc7
movsd (%r12), %xmm0
movsd %xmm0, (%rsp)
jmp 0x7fd8
movq %rsp, %rsi
movq %r12, %rdi
callq 0x11634
testl %eax, %eax
cmoveq %r12, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7d95
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldebug.c
// Function: luaG_tointerror
l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) {
  lua_Integer temp;
  if (!tointeger(p1, &temp))
    p2 = p1;
  luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x13, 0x8(%rsi)
jne 0x8008
movq (%r15), %rax
movq %rax, 0x8(%rsp)
jmp 0x801d
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x116b2
testl %eax, %eax
cmoveq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7eb2
leaq 0x1a2d4(%rip), %rsi     # 0x22303
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x7dd3
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldebug.c
// Function: luaG_ordererror
l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
  const char *t1 = luaT_objtypename(L, p1);
  const char *t2 = luaT_objtypename(L, p2);
  if (strcmp(t1, t2) == 0)
    luaG_runerror(L, "attempt to compare two %s values", t1);
  else
    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
callq 0x109cb
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x109cb
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x5280
testl %eax, %eax
jne 0x8080
leaq 0x1a2b7(%rip), %rsi     # 0x2232a
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x7dd3
leaq 0x1a2c4(%rip), %rsi     # 0x2234b
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x7dd3
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldebug.c
// Function: luaG_addinfo
const char *luaG_addinfo (lua_State *L, const char *msg, TString *src,
                                        int line) {
  char buff[LUA_IDSIZE];
  if (src)
    luaO_chunkid(buff, getstr(src), LUA_IDSIZE);
  else {  /* no source available; use "?" instead */
    buff[0] = '?'; buff[1] = '\0';
  }
  return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x80c6
movq %rdx, %rax
addq $0x18, %rax
movq %rsp, %rdi
movl $0x3c, %edx
movq %rax, %rsi
callq 0xc415
jmp 0x80cc
movw $0x3f, (%rsp)
leaq 0x1a296(%rip), %rsi     # 0x22369
movq %rsp, %rdx
movq %r15, %rdi
movl %ebx, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0xc391
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/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);
    setobjs2s(L, L->top, L->top - 1);  /* move argument */
    setobjs2s(L, L->top - 1, errfunc);  /* push function */
    L->top++;  /* assume EXTRA_STACK */
    luaD_callnoyield(L, L->top - 2, 1);  /* call it */
  }
  luaD_throw(L, LUA_ERRRUN);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xb0(%rdi), %rax
testq %rax, %rax
je 0x8137
movq 0x10(%rbx), %rcx
movq 0x38(%rbx), %rdx
movups -0x10(%rcx), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rbx), %rcx
movups (%rdx,%rax), %xmm0
movups %xmm0, -0x10(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x10(%rsi), %rax
movq %rax, 0x10(%rbx)
addq $-0x10, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x90be
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8578
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldebug.c
// Function: kname
static void kname (Proto *p, int pc, int c, const char **name) {
  if (ISK(c)) {  /* is 'c' a constant? */
    TValue *kvalue = &p->k[INDEXK(c)];
    if (ttisstring(kvalue)) {  /* literal constant? */
      *name = svalue(kvalue);  /* it is its own name */
      return;
    }
    /* else no reasonable name found */
  }
  else {  /* 'c' is a register */
    const char *what = getobjname(p, pc, c, name); /* search for 'c' */
    if (what && *what == 'c') {  /* found a constant name? */
      return;  /* 'name' already filled */
    }
    /* else no reasonable name found */
  }
  *name = "?";  /* no reasonable name found */
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
btl $0x8, %edx
jb 0x8544
movq %rbx, %rcx
callq 0x829d
leaq 0x19e5a(%rip), %rcx     # 0x22392
testq %rax, %rax
je 0x8571
cmpb $0x63, (%rax)
jne 0x8571
jmp 0x8574
movq 0x30(%rdi), %rax
andl $0xfffffeff, %edx       # imm = 0xFFFFFEFF
shlq $0x4, %rdx
movl 0x8(%rax,%rdx), %ecx
andl $0xf, %ecx
cmpl $0x4, %ecx
jne 0x856a
addq %rdx, %rax
movq (%rax), %rcx
addq $0x18, %rcx
jmp 0x8571
leaq 0x19e21(%rip), %rcx     # 0x22392
movq %rcx, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/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 */
    global_State *g = G(L);
    L->status = cast_byte(errcode);  /* mark it as dead */
    if (g->mainthread->errorJmp) {  /* main thread has a handler? */
      setobjs2s(L, g->mainthread->top++, L->top - 1);  /* copy error obj. */
      luaD_throw(g->mainthread, errcode);  /* re-throw in main thread */
    }
    else {  /* no handler at all; abort */
      if (g->panic) {  /* panic function? */
        seterrorobj(L, errcode, L->top);  /* assume EXTRA_STACK */
        if (L->ci->top < L->top)
          L->ci->top = L->top;  /* pushing msg. can break this invariant */
        lua_unlock(L);
        g->panic(L);  /* call panic function (last chance to jump out) */
      }
      abort();
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
jne 0x85d5
movq 0x18(%rbx), %r14
movb %sil, 0xc(%rbx)
movq 0xc8(%r14), %rax
cmpq $0x0, 0x58(%rax)
jne 0x85e9
cmpq $0x0, 0xc0(%r14)
je 0x85d0
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
callq 0x860c
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
cmpq %rax, 0x8(%rcx)
jae 0x85c6
movq %rax, 0x8(%rcx)
movq %rbx, %rdi
callq *0xc0(%r14)
callq 0x5080
movl %esi, 0xd0(%rdi)
addq $0x8, %rdi
movl $0x1, %esi
callq 0x5410
movq 0x10(%rax), %rcx
leaq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x10(%rbx), %rax
movups -0x10(%rax), %xmm0
movups %xmm0, (%rcx)
movq 0xc8(%r14), %rdi
callq 0x8578
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: seterrorobj
static void seterrorobj (lua_State *L, int errcode, StkId oldtop) {
  switch (errcode) {
    case LUA_ERRMEM: {  /* memory error? */
      setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */
      break;
    }
    case LUA_ERRERR: {
      setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
      break;
    }
    default: {
      setobjs2s(L, oldtop, L->top - 1);  /* error message on current top */
      break;
    }
  }
  L->top = oldtop + 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x6, %esi
je 0x862d
cmpl $0x4, %esi
jne 0x8650
movq 0x18(%r14), %rax
movq 0xd8(%rax), %rax
jmp 0x8641
leaq 0x19df7(%rip), %rsi     # 0x2242b
movl $0x17, %edx
movq %r14, %rdi
callq 0xf828
movq %rax, (%rbx)
movzbl 0x8(%rax), %eax
orl $0x40, %eax
movl %eax, 0x8(%rbx)
jmp 0x865b
movq 0x10(%r14), %rax
movups -0x10(%rax), %xmm0
movups %xmm0, (%rbx)
addq $0x10, %rbx
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: luaD_rawrunprotected
int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
  unsigned short oldnCcalls = L->nCcalls;
  struct lua_longjmp lj;
  lj.status = LUA_OK;
  lj.previous = L->errorJmp;  /* chain new error handler */
  L->errorJmp = &lj;
  LUAI_TRY(L, &lj,
    (*f)(L, ud);
  );
  L->errorJmp = lj.previous;  /* restore old error handler */
  L->nCcalls = oldnCcalls;
  return lj.status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0xc6(%rdi), %ebp
movq %rsp, %rax
movl $0x0, 0xd0(%rax)
movq 0x58(%rdi), %rcx
movq %rcx, (%rax)
movq %rax, 0x58(%rdi)
leaq 0x8(%rsp), %rdi
callq 0x5270
testl %eax, %eax
jne 0x86b7
movq %rbx, %rdi
movq %r15, %rsi
callq *%r14
movq (%rsp), %rax
movq %rax, 0x58(%rbx)
movw %bp, 0xc6(%rbx)
movl 0xd0(%rsp), %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: luaD_reallocstack
void luaD_reallocstack (lua_State *L, int newsize) {
  TValue *oldstack = L->stack;
  int lim = L->stacksize;
  lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE);
  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK);
  luaM_reallocvector(L, L->stack, L->stacksize, newsize, TValue);
  for (; lim < newsize; lim++)
    setnilvalue(L->stack + lim); /* erase new segment */
  L->stacksize = newsize;
  L->stack_last = L->stack + newsize - EXTRA_STACK;
  correctstack(L, oldstack);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %r14
movslq 0xb8(%rdi), %rbp
movq %rbp, %r12
shlq $0x4, %r12
movl %esi, 0x4(%rsp)
movslq %esi, %r13
movq %r13, %r15
shlq $0x4, %r15
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0xb897
movq %rax, 0x38(%rbx)
cmpl %r13d, %ebp
jge 0x8824
subq %rbp, %r13
leaq 0x3(%r13), %rcx
andq $-0x4, %rcx
decq %r13
movq %r13, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%r12,%rax), %rdx
addq $0x38, %rdx
xorl %esi, %esi
movdqa 0x19992(%rip), %xmm1    # 0x220e0
movdqa 0x1999a(%rip), %xmm2    # 0x220f0
movdqa 0x199a2(%rip), %xmm3    # 0x22100
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rsi, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0x87b0
movl $0x0, -0x30(%rdx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x87c6
movl $0x0, -0x20(%rdx)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edi
testb $0x1, %dil
je 0x8802
movl $0x0, -0x10(%rdx)
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x8813
movl $0x0, (%rdx)
addq $0x4, %rsi
addq $0x40, %rdx
cmpq %rsi, %rcx
jne 0x8766
movl 0x4(%rsp), %ecx
movl %ecx, 0xb8(%rbx)
leaq (%rax,%r15), %rcx
addq $-0x50, %rcx
movq %rcx, 0x30(%rbx)
movq 0x10(%rbx), %rdx
movq 0x40(%rbx), %rcx
subq %r14, %rdx
addq %rax, %rdx
movq %rdx, 0x10(%rbx)
testq %rcx, %rcx
je 0x8869
movq (%rcx), %rdx
movq 0x10(%rcx), %rsi
subq %r14, %rdx
addq %rax, %rdx
movq %rdx, (%rcx)
movq %rsi, %rcx
testq %rsi, %rsi
jne 0x8851
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x88aa
movq (%rax), %rdx
movq 0x8(%rax), %rsi
subq %r14, %rsi
movq 0x38(%rbx), %rcx
addq %rcx, %rsi
movq %rsi, 0x8(%rax)
subq %r14, %rdx
addq %rcx, %rdx
movq %rdx, (%rax)
testb $0x2, 0x42(%rax)
je 0x88a4
movq 0x20(%rax), %rdx
subq %r14, %rdx
addq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rax), %rax
jmp 0x886d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: luaD_growstack
void luaD_growstack (lua_State *L, int n) {
  int size = L->stacksize;
  if (size > LUAI_MAXSTACK)  /* error after extra size? */
    luaD_throw(L, LUA_ERRERR);
  else {
    int needed = cast_int(L->top - L->stack) + n + EXTRA_STACK;
    int newsize = 2 * size;
    if (newsize > LUAI_MAXSTACK) newsize = LUAI_MAXSTACK;
    if (newsize < needed) newsize = needed;
    if (newsize > LUAI_MAXSTACK) {  /* stack overflow? */
      luaD_reallocstack(L, ERRORSTACKSIZE);
      luaG_runerror(L, "stack overflow");
    }
    else
      luaD_reallocstack(L, newsize);
  }
}

// Assembly:
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
movl 0xb8(%rdi), %esi
cmpl $0xf4241, %esi          # imm = 0xF4241
jge 0x8900
movq 0x10(%rbx), %rcx
subq 0x38(%rbx), %rcx
shrq $0x4, %rcx
addl %eax, %ecx
cmpl $0xf423c, %ecx          # imm = 0xF423C
jge 0x890d
addl $0x5, %ecx
addl %esi, %esi
movl $0xf4240, %eax          # imm = 0xF4240
cmpl %eax, %esi
cmovgel %eax, %esi
cmpl %ecx, %esi
cmovlel %ecx, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x86db
movq %rbx, %rdi
movl $0x6, %esi
callq 0x8578
movq %rbx, %rdi
movl $0xf4308, %esi          # imm = 0xF4308
callq 0x86db
leaq 0x19b24(%rip), %rsi     # 0x22445
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7dd3
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/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 (L->stacksize > LUAI_MAXSTACK)  /* was handling stack overflow? */
    luaE_freeCI(L);  /* free all CIs (list grew because of an error) */
  else
    luaE_shrinkCI(L);  /* shrink list */
  if (inuse <= LUAI_MAXSTACK &&  /* not handling stack overflow? */
      goodsize < L->stacksize)  /* trying to shrink? */
    luaD_reallocstack(L, goodsize);  /* shrink it */
  else
    condmovestack(L,,);  /* don't change stack (change only for debugging) */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x8950
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
cmpq %rcx, %r14
cmovbq %rcx, %r14
jmp 0x893a
subq 0x38(%rbx), %r14
shrq $0x4, %r14
leal 0x1(%r14), %eax
leal 0x8(%r14), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x3, %ecx
leal (%rcx,%r14), %eax
incl %eax
movl $0xf4236, %ebp          # imm = 0xF4236
cmpl %ebp, %eax
cmovll %eax, %ebp
cmpl $0xf4241, 0xb8(%rbx)    # imm = 0xF4241
jl 0x898e
movq %rbx, %rdi
callq 0xf030
jmp 0x8996
movq %rbx, %rdi
callq 0xf073
cmpl $0xf423f, %r14d         # imm = 0xF423F
jg 0x89b8
addl $0xa, %ebp
cmpl 0xb8(%rbx), %ebp
jge 0x89b8
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x86db
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: luaD_hook
void luaD_hook (lua_State *L, int event, int line) {
  lua_Hook hook = L->hook;
  if (hook && L->allowhook) {  /* make sure there is a hook */
    CallInfo *ci = L->ci;
    ptrdiff_t top = savestack(L, L->top);
    ptrdiff_t ci_top = savestack(L, ci->top);
    lua_Debug ar;
    ar.event = event;
    ar.currentline = line;
    ar.i_ci = ci;
    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
    ci->top = L->top + LUA_MINSTACK;
    lua_assert(ci->top <= L->stack_last);
    L->allowhook = 0;  /* cannot call hooks inside a hook */
    ci->callstatus |= CIST_HOOKED;
    lua_unlock(L);
    (*hook)(L, &ar);
    lua_lock(L);
    lua_assert(!L->allowhook);
    L->allowhook = 1;
    ci->top = restorestack(L, ci_top);
    L->top = restorestack(L, top);
    ci->callstatus &= ~CIST_HOOKED;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq 0xa8(%rdi), %r14
testq %r14, %r14
je 0x8aa0
movq %rdi, %rbx
cmpb $0x0, 0xcc(%rdi)
je 0x8aa0
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %r15
movq 0x38(%rbx), %rcx
movq %rax, %r12
subq %rcx, %r12
movq 0x8(%r15), %r13
subq %rcx, %r13
movl %esi, (%rsp)
movl %edx, 0x28(%rsp)
movq %r15, 0x78(%rsp)
movq 0x30(%rbx), %rcx
subq %rax, %rcx
cmpq $0x14f, %rcx            # imm = 0x14F
jg 0x8a63
movq %rbx, %rdi
movl $0x14, %esi
callq 0x88b9
movq 0x10(%rbx), %rax
addq $0x140, %rax            # imm = 0x140
movq %rax, 0x8(%r15)
movb $0x0, 0xcc(%rbx)
orb $0x4, 0x42(%r15)
movq %rsp, %rsi
movq %rbx, %rdi
callq *%r14
movb $0x1, 0xcc(%rbx)
movq 0x38(%rbx), %rax
addq %rax, %r13
movq %r13, 0x8(%r15)
addq %rax, %r12
movq %r12, 0x10(%rbx)
andb $-0x5, 0x42(%r15)
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: luaD_call
void luaD_call (lua_State *L, StkId func, int nResults) {
  if (++L->nCcalls >= LUAI_MAXCCALLS)
    stackerror(L);
  if (!luaD_precall(L, func, nResults))  /* is a Lua function? */
    luaV_execute(L);  /* call it */
  L->nCcalls--;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzwl 0xc6(%rdi), %eax
incl %eax
movw %ax, 0xc6(%rdi)
movzwl %ax, %eax
cmpl $0xc8, %eax
jb 0x9083
je 0x90a0
cmpl $0xe1, %eax
jae 0x90b1
movq %rbx, %rdi
callq 0x8ab1
testl %eax, %eax
jne 0x9097
movq %rbx, %rdi
callq 0x12560
decw 0xc6(%rbx)
popq %rbx
retq
leaq 0x1939c(%rip), %rsi     # 0x22443
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7dd3
movq %rbx, %rdi
movl $0x6, %esi
callq 0x8578
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: lua_resume
LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) {
  int status;
  unsigned short oldnny = L->nny;  /* save "number of non-yieldable" calls */
  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, &nargs);
  if (status == -1)  /* error calling 'lua_resume'? */
    status = LUA_ERRRUN;
  else {  /* continue running after recoverable errors */
    while (errorstatus(status) && recover(L, status)) {
      /* unroll continuation */
      status = luaD_rawrunprotected(L, unroll, &status);
    }
    if (errorstatus(status)) {  /* unrecoverable error? */
      L->status = cast_byte(status);  /* mark thread as 'dead' */
      seterrorobj(L, status, L->top);  /* push error message */
      L->ci->top = L->top;
    }
    else lua_assert(status == L->status);  /* normal end or yield */
  }
  L->nny = oldnny;  /* restore 'nny' */
  L->nCcalls--;
  lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));
  lua_unlock(L);
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %edx, 0x14(%rsp)
testq %rsi, %rsi
je 0x90fc
movzwl 0xc6(%rsi), %eax
incl %eax
jmp 0x9100
movw $0x1, %ax
movzwl 0xc4(%rbx), %r13d
movw %ax, 0xc6(%rbx)
movw $0x0, 0xc4(%rbx)
leaq 0x124(%rip), %rsi       # 0x9243
leaq 0x14(%rsp), %rdx
movq %rbx, %rdi
callq 0x866b
movl %eax, 0xc(%rsp)
cmpl $-0x1, %eax
je 0x91f5
movl %eax, %ebp
cmpl $0x2, %eax
jl 0x9223
leaq 0x1f0(%rip), %r12       # 0x933b
leaq 0xc(%rsp), %r15
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x9201
testb $0x10, 0x42(%r14)
jne 0x9172
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x915d
jmp 0x91fc
movw %r13w, 0x12(%rsp)
movq %r15, %r13
movq %r12, %r15
movq 0x38(%rbx), %r12
addq 0x38(%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9fbd
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r15, %r12
movq %r13, %r15
movzwl 0x12(%rsp), %r13d
callq 0x860c
movq %r14, 0x20(%rbx)
movb 0x42(%r14), %al
andb $0x1, %al
movb %al, 0xcc(%rbx)
movw $0x0, 0xc4(%rbx)
movq %rbx, %rdi
callq 0x892b
movq 0x28(%r14), %rax
movq %rax, 0xb0(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x866b
movl %eax, %ebp
movl %eax, 0xc(%rsp)
cmpl $0x1, %eax
jg 0x9150
jmp 0x9223
movl $0x2, %ebp
jmp 0x9223
cmpl $0x2, %ebp
jl 0x9223
movb %bpl, 0xc(%rbx)
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x860c
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rax, 0x8(%rcx)
movl 0xc(%rsp), %ebp
movw %r13w, 0xc4(%rbx)
decw 0xc6(%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: resume
static void resume (lua_State *L, void *ud) {
  int nCcalls = L->nCcalls;
  int n = *(cast(int*, ud));  /* number of arguments */
  StkId firstArg = L->top - n;  /* first argument */
  CallInfo *ci = L->ci;
  if (nCcalls >= LUAI_MAXCCALLS)
    resume_error(L, "C stack overflow", firstArg);
  if (L->status == LUA_OK) {  /* may be starting a coroutine */
    if (ci != &L->base_ci)  /* not in base level? */
      resume_error(L, "cannot resume non-suspended coroutine", firstArg);
    /* coroutine is in base level; start running it */
    if (!luaD_precall(L, firstArg - 1, LUA_MULTRET))  /* Lua function? */
      luaV_execute(L);  /* call it */
  }
  else if (L->status != LUA_YIELD)
    resume_error(L, "cannot resume dead coroutine", firstArg);
  else {  /* resuming from previous yield */
    L->status = LUA_OK;  /* mark that it is running (again) */
    ci->func = restorestack(L, ci->extra);
    if (isLua(ci))  /* yielded inside a hook? */
      luaV_execute(L);  /* just continue running Lua code */
    else {  /* 'common' yield */
      if (ci->u.c.k != NULL) {  /* does it have a continuation function? */
        lua_unlock(L);
        n = (*ci->u.c.k)(L, LUA_YIELD, ci->u.c.ctx); /* call continuation */
        lua_lock(L);
        api_checknelems(L, n);
        firstArg = L->top - n;  /* yield results come from continuation */
      }
      luaD_poscall(L, ci, firstArg, n);  /* finish 'luaD_precall' */
    }
    unroll(L, NULL);  /* run continuation */
  }
  lua_assert(nCcalls == L->nCcalls);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rsi), %rcx
movq %rcx, %rax
shlq $0x4, %rax
movq 0x10(%rdi), %rdx
subq %rax, %rdx
cmpw $0xc8, 0xc6(%rdi)
jae 0x931a
movq 0x20(%rbx), %r14
movzbl 0xc(%rbx), %eax
cmpl $0x1, %eax
je 0x92ac
testl %eax, %eax
jne 0x9323
leaq 0x60(%rbx), %rax
cmpq %rax, %r14
jne 0x932c
addq $-0x10, %rdx
movq %rbx, %rdi
movq %rdx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x8ab1
testl %eax, %eax
je 0x930b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x0, 0xc(%rbx)
movq 0x38(%rbx), %rax
addq 0x38(%r14), %rax
movq %rax, (%r14)
testb $0x2, 0x42(%r14)
jne 0x92f5
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x92e8
movq 0x30(%r14), %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq *%rax
movl %eax, %ecx
movq 0x10(%rbx), %rdx
cltq
shlq $0x4, %rax
subq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8e05
jmp 0x92fd
movq %rbx, %rdi
callq 0x12560
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x933b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12560
leaq 0x19122(%rip), %rsi     # 0x22443
jmp 0x9333
leaq 0x19150(%rip), %rsi     # 0x2247a
jmp 0x9333
leaq 0x19121(%rip), %rsi     # 0x22454
movq %rbx, %rdi
callq 0x9614
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: unroll
static void unroll (lua_State *L, void *ud) {
  if (ud != NULL)  /* error status? */
    finishCcall(L, *(int *)ud);  /* finish 'lua_pcallk' callee */
  while (L->ci != &L->base_ci) {  /* something in the stack */
    if (!isLua(L->ci))  /* C function? */
      finishCcall(L, LUA_YIELD);  /* complete its execution */
    else {  /* Lua function */
      luaV_finishOp(L);  /* finish interrupted instruction */
      luaV_execute(L);  /* execute down to higher C 'boundary' */
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x9351
movl (%rsi), %esi
movq %rbx, %rdi
callq 0x9646
leaq 0x60(%rbx), %r14
movq 0x20(%rbx), %rax
cmpq %r14, %rax
je 0x9385
testb $0x2, 0x42(%rax)
jne 0x9373
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9646
jmp 0x9355
movq %rbx, %rdi
callq 0x1243d
movq %rbx, %rdi
callq 0x12560
jmp 0x9355
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: lua_yieldk
LUA_API int lua_yieldk (lua_State *L, int nresults, lua_KContext ctx,
                        lua_KFunction k) {
  CallInfo *ci = L->ci;
  luai_userstateyield(L, nresults);
  lua_lock(L);
  api_checknelems(L, nresults);
  if (L->nny > 0) {
    if (L != G(L)->mainthread)
      luaG_runerror(L, "attempt to yield across a C-call boundary");
    else
      luaG_runerror(L, "attempt to yield from outside a coroutine");
  }
  L->status = LUA_YIELD;
  ci->extra = savestack(L, ci->func);  /* save current 'func' */
  if (isLua(ci)) {  /* inside a hook? */
    api_check(L, k == NULL, "hooks cannot continue after yielding");
  }
  else {
    if ((ci->u.c.k = k) != NULL)  /* is there a continuation? */
      ci->u.c.ctx = ctx;  /* save context */
    ci->func = L->top - nresults - 1;  /* protect stack below results */
    luaD_throw(L, LUA_YIELD);
  }
  lua_assert(ci->callstatus & CIST_HOOKED);  /* must be inside a hook */
  lua_unlock(L);
  return 0;  /* return to 'luaD_hook' */
}

// Assembly:
pushq %rax
cmpw $0x0, 0xc4(%rdi)
jne 0x93c3
movq 0x20(%rdi), %rax
movb $0x1, 0xc(%rdi)
movq (%rax), %r8
subq 0x38(%rdi), %r8
movq %r8, 0x38(%rax)
testb $0x2, 0x42(%rax)
je 0x93d9
xorl %eax, %eax
popq %rcx
retq
movq 0x18(%rdi), %rax
cmpq %rdi, 0xc8(%rax)
jne 0x9408
leaq 0x1902a(%rip), %rsi     # 0x22401
jmp 0x940f
movq %rcx, 0x20(%rax)
testq %rcx, %rcx
je 0x93e6
movq %rdx, 0x30(%rax)
movq 0x10(%rdi), %rcx
movslq %esi, %rdx
shlq $0x4, %rdx
negq %rdx
addq %rdx, %rcx
addq $-0x10, %rcx
movq %rcx, (%rax)
movl $0x1, %esi
callq 0x8578
leaq 0x18fc8(%rip), %rsi     # 0x223d7
xorl %eax, %eax
callq 0x7dd3
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: luaD_pcall
int luaD_pcall (lua_State *L, Pfunc func, void *u,
                ptrdiff_t old_top, ptrdiff_t ef) {
  int status;
  CallInfo *old_ci = L->ci;
  lu_byte old_allowhooks = L->allowhook;
  unsigned short old_nny = L->nny;
  ptrdiff_t old_errfunc = L->errfunc;
  L->errfunc = ef;
  status = luaD_rawrunprotected(L, func, u);
  if (status != LUA_OK) {  /* an error occurred? */
    StkId oldtop = restorestack(L, old_top);
    luaF_close(L, oldtop);  /* close possible pending closures */
    seterrorobj(L, status, oldtop);
    L->ci = old_ci;
    L->allowhook = old_allowhooks;
    L->nny = old_nny;
    luaD_shrinkstack(L);
  }
  L->errfunc = old_errfunc;
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq %rax, (%rsp)
movq 0xb0(%rdi), %r15
movb 0xcc(%rdi), %r13b
movzwl 0xc4(%rdi), %r12d
movq %r8, 0xb0(%rdi)
callq 0x866b
movl %eax, %ebp
testl %eax, %eax
je 0x9492
addq 0x38(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9fbd
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x860c
movq (%rsp), %rax
movq %rax, 0x20(%rbx)
movb %r13b, 0xcc(%rbx)
movw %r12w, 0xc4(%rbx)
movq %rbx, %rdi
callq 0x892b
movq %r15, 0xb0(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: luaD_protectedparser
int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
                                        const char *mode) {
  struct SParser p;
  int status;
  L->nny++;  /* cannot yield during parsing */
  p.z = z; p.name = name; p.mode = mode;
  p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0;
  p.dyd.gt.arr = NULL; p.dyd.gt.size = 0;
  p.dyd.label.arr = NULL; p.dyd.label.size = 0;
  luaZ_initbuffer(L, &p.buff);
  status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
  luaZ_freebuffer(L, &p.buff);
  luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size);
  luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size);
  luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size);
  L->nny--;
  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
incw 0xc4(%rdi)
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
movq %rdx, 0x58(%r14)
movq %rcx, 0x50(%r14)
xorl %r15d, %r15d
movl %r15d, 0x2c(%r14)
movq %r15, 0x30(%r14)
movl %r15d, 0x3c(%r14)
movq %r15, 0x40(%r14)
movl %r15d, 0x4c(%r14)
movq %r15, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq 0x10(%rdi), %rcx
movq 0xb0(%rdi), %r8
subq 0x38(%rdi), %rcx
leaq 0x81(%rip), %rsi        # 0x9588
movq %r14, %rdx
callq 0x9416
movl %eax, %ebp
movq 0x8(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xb897
movq %rax, 0x8(%r14)
movq %r15, 0x18(%r14)
movq 0x20(%r14), %rsi
movslq 0x2c(%r14), %rdx
addq %rdx, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xb897
movq 0x30(%r14), %rsi
movslq 0x3c(%r14), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xb897
movq 0x40(%r14), %rsi
movslq 0x4c(%r14), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xb897
decw 0xc4(%rbx)
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: f_parser
static void f_parser (lua_State *L, void *ud) {
  LClosure *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->name);
  }
  else {
    checkmode(L, p->mode, "text");
    cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
  }
  lua_assert(cl->nupvalues == cl->p->sizeupvalues);
  luaF_initupvals(L, cl);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
subq $0x1, (%rdi)
jae 0x95a4
callq 0x14598
movl %eax, %ebp
jmp 0x95b3
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %ebp
movq 0x50(%r14), %rsi
cmpl $0x1b, %ebp
jne 0x95dc
leaq 0x18ed4(%rip), %rdx     # 0x22497
movq %rbx, %rdi
callq 0x96aa
movq (%r14), %rsi
movq 0x58(%r14), %rdx
movq %rbx, %rdi
callq 0x10c38
jmp 0x9605
leaq 0x18ebb(%rip), %rdx     # 0x2249e
movq %rbx, %rdi
callq 0x96aa
leaq 0x8(%r14), %rdx
leaq 0x20(%r14), %rcx
movq (%r14), %rsi
movq 0x58(%r14), %r8
movq %rbx, %rdi
movl %ebp, %r9d
callq 0xc59c
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x9edc
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: resume_error
static l_noret resume_error (lua_State *L, const char *msg, StkId firstArg) {
  L->top = firstArg;  /* remove args from the stack */
  setsvalue2s(L, L->top, luaS_new(L, msg));  /* push error message */
  api_incr_top(L);
  luaD_throw(L, -1);  /* jump back to 'lua_resume' */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rdx, 0x10(%rdi)
callq 0xfa60
movq %rax, (%rbx)
movzbl 0x8(%rax), %eax
orl $0x40, %eax
movl %eax, 0x8(%rbx)
addq $0x10, 0x10(%r14)
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8578
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: finishCcall
static void finishCcall (lua_State *L, int status) {
  CallInfo *ci = L->ci;
  int n;
  /* must have a continuation and must be able to call it */
  lua_assert(ci->u.c.k != NULL && L->nny == 0);
  /* error status can only happen in a protected call */
  lua_assert((ci->callstatus & CIST_YPCALL) || status == LUA_YIELD);
  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'; CIST_YPCALL and 'errfunc' already
     handled */
  adjustresults(L, ci->nresults);
  /* call continuation function */
  lua_unlock(L);
  n = (*ci->u.c.k)(L, status, ci->u.c.ctx);
  lua_lock(L);
  api_checknelems(L, n);
  /* finish 'luaD_precall' */
  luaD_poscall(L, ci, L->top - n, n);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x20(%rdi), %rbx
movb 0x42(%rbx), %al
testb $0x10, %al
je 0x9668
andb $-0x11, %al
movb %al, 0x42(%rbx)
movq 0x28(%rbx), %rax
movq %rax, 0xb0(%r14)
cmpw $-0x1, 0x40(%rbx)
jne 0x967d
movq 0x10(%r14), %rax
cmpq %rax, 0x8(%rbx)
jae 0x967d
movq %rax, 0x8(%rbx)
movq 0x30(%rbx), %rdx
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x10(%r14), %rdx
movslq %eax, %rcx
movq %rcx, %rax
shlq $0x4, %rax
subq %rax, %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8e05
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/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 '%s')", x, mode);
    luaD_throw(L, LUA_ERRSYNTAX);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x96cd
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsbl (%rdx), %esi
movq %r14, %rdi
callq 0x5160
testq %rax, %rax
je 0x96d3
popq %rbx
popq %r14
popq %r15
retq
leaq 0x18dc9(%rip), %rsi     # 0x224a3
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0xc391
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8578
nop
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/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);
  DumpByte(f->sizeupvalues, &D);
  DumpFunction(f, NULL, &D);
  return D.status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq %rdi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x28(%rsp)
leaq 0x18da1(%rip), %rsi     # 0x224cd
movl $0x4, %edx
callq *%r14
movl %eax, 0x2c(%rsp)
movb $0x53, 0x8(%rsp)
testl %eax, %eax
jne 0x98db
leaq 0x8(%rsp), %r13
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq *%r14
movl %eax, 0x2c(%rsp)
movb $0x0, (%r13)
testl %eax, %eax
jne 0x98db
leaq 0x8(%rsp), %rsi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
callq *%r14
movl %eax, 0x2c(%rsp)
testl %eax, %eax
jne 0x98db
leaq 0x18d40(%rip), %rsi     # 0x224d2
movl $0x6, %edx
movq %r12, %rdi
movq %r15, %rcx
callq *%r14
movl %eax, 0x2c(%rsp)
movb $0x4, 0x8(%rsp)
testl %eax, %eax
jne 0x98db
leaq 0x8(%rsp), %r13
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq *%r14
movl %eax, 0x2c(%rsp)
movb $0x8, (%r13)
testl %eax, %eax
jne 0x98db
leaq 0x8(%rsp), %r13
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq *%r14
movl %eax, 0x2c(%rsp)
movb $0x4, (%r13)
testl %eax, %eax
jne 0x98db
leaq 0x8(%rsp), %r13
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq *%r14
movl %eax, 0x2c(%rsp)
movb $0x8, (%r13)
testl %eax, %eax
jne 0x98db
leaq 0x8(%rsp), %r13
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq *%r14
movl %eax, 0x2c(%rsp)
movb $0x8, (%r13)
testl %eax, %eax
jne 0x98db
leaq 0x8(%rsp), %r13
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq *%r14
movl %eax, 0x2c(%rsp)
movq $0x5678, (%r13)         # imm = 0x5678
testl %eax, %eax
jne 0x98db
leaq 0x8(%rsp), %r13
movl $0x8, %edx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq *%r14
movl %eax, 0x2c(%rsp)
movabsq $0x4077280000000000, %rcx # imm = 0x4077280000000000
movq %rcx, (%r13)
testl %eax, %eax
jne 0x98db
leaq 0x8(%rsp), %r13
movl $0x8, %edx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq *%r14
movl %eax, 0x2c(%rsp)
movb 0x10(%rbx), %cl
movb %cl, (%r13)
testl %eax, %eax
jne 0x98db
leaq 0x8(%rsp), %rsi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
callq *%r14
movl %eax, 0x2c(%rsp)
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x98ff
movl 0x1c(%r14), %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/ldump.c
// Function: DumpString
static void DumpString (const TString *s, DumpState *D) {
  if (s == NULL)
    DumpByte(0, D);
  else {
    size_t size = tsslen(s) + 1;  /* include trailing '\0' */
    const char *str = getstr(s);
    if (size < 0xFF)
      DumpByte(cast_int(size), D);
    else {
      DumpByte(0xFF, D);
      DumpVar(size, D);
    }
    DumpVector(str, size - 1, D);  /* no need to save '\0' */
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x9d8d
movq %rdi, %r14
cmpb $0x4, 0x8(%rdi)
jne 0x9db2
movzbl 0xb(%r14), %r15d
jmp 0x9db6
movb $0x0, 0x5(%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0x9e51
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
leaq 0x5(%rsp), %rsi
movl $0x1, %edx
jmp 0x9e4b
movq 0x10(%r14), %r15
leaq 0x1(%r15), %rax
movq %rax, 0x8(%rsp)
cmpq $0xfe, %rax
ja 0x9deb
movb %al, 0x6(%rsp)
movl 0x1c(%rbx), %eax
testl %eax, %eax
jne 0x9e31
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
leaq 0x6(%rsp), %rsi
movl $0x1, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
jmp 0x9e31
movb $-0x1, 0x7(%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0x9e51
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
testl %eax, %eax
jne 0x9e51
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
leaq 0x8(%rsp), %r15
movl $0x8, %edx
movq %r15, %rsi
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
movq (%r15), %r15
decq %r15
testq %r15, %r15
je 0x9e51
testl %eax, %eax
jne 0x9e51
addq $0x18, %r14
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %r14, %rsi
movq %r15, %rdx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lfunc.c
// Function: luaF_newCclosure
CClosure *luaF_newCclosure (lua_State *L, int n) {
  GCObject *o = luaC_newobj(L, LUA_TCCL, sizeCclosure(n));
  CClosure *c = gco2ccl(o);
  c->nupvalues = cast_byte(n);
  return c;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
movl %esi, %eax
shll $0x4, %eax
addl $0x20, %eax
movslq %eax, %rdx
movl $0x26, %esi
callq 0xa297
movb %bl, 0xa(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lfunc.c
// Function: luaF_newLclosure
LClosure *luaF_newLclosure (lua_State *L, int n) {
  GCObject *o = luaC_newobj(L, LUA_TLCL, sizeLclosure(n));
  LClosure *c = gco2lcl(o);
  c->p = NULL;
  c->nupvalues = cast_byte(n);
  while (n--) c->upvals[n] = NULL;
  return c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
leal 0x20(,%r14,8), %eax
movslq %eax, %rdx
movl $0x6, %esi
callq 0xa297
movq %rax, %rbx
movq $0x0, 0x18(%rax)
movb %r14b, 0xa(%rax)
testl %r14d, %r14d
je 0x9ed1
leal -0x1(%r14), %eax
movslq %eax, %rcx
shlq $0x3, %rcx
shlq $0x3, %rax
subq %rax, %rcx
leaq (%rcx,%rbx), %rdi
addq $0x20, %rdi
movl %r14d, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x51c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lfunc.c
// Function: luaF_initupvals
void luaF_initupvals (lua_State *L, LClosure *cl) {
  int i;
  for (i = 0; i < cl->nupvalues; i++) {
    UpVal *uv = luaM_new(L, UpVal);
    uv->refcount = 1;
    uv->v = &uv->u.value;  /* make it closed */
    setnilvalue(uv->v);
    cl->upvals[i] = uv;
  }
}

// Assembly:
cmpb $0x0, 0xa(%rsi)
je 0x9f2d
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movl $0x20, %ecx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb897
movq $0x1, 0x8(%rax)
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movl $0x0, 0x18(%rax)
movq %rax, 0x20(%rbx,%r15,8)
incq %r15
movzbl 0xa(%rbx), %eax
cmpq %rax, %r15
jb 0x9ef0
popq %rbx
popq %r14
popq %r15
retq