LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x8ff7
movq 0x20(%rbx), %r14
movzbl 0xc(%rbx), %eax
cmpl $0x1, %eax
je 0x8f89
testl %eax, %eax
jne 0x9000
leaq 0x60(%rbx), %rax
cmpq %rax, %r14
jne 0x9009
addq $-0x10, %rdx
movq %rbx, %rdi
movq %rdx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x88c9
testl %eax, %eax
je 0x8fe8
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 0x8fd2
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x8fc5
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 0x8c0d
jmp 0x8fda
movq %rbx, %rdi
callq 0x11cf3
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9018
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11cf3
leaq 0x18419(%rip), %rsi     # 0x21417
jmp 0x9010
leaq 0x18447(%rip), %rsi     # 0x2144e
jmp 0x9010
leaq 0x18418(%rip), %rsi     # 0x21428
movq %rbx, %rdi
callq 0x92f1
// File: /workspace/github_c_makefile_star2_O1/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 0x902e
movl (%rsi), %esi
movq %rbx, %rdi
callq 0x9323
leaq 0x60(%rbx), %r14
movq 0x20(%rbx), %rax
cmpq %r14, %rax
je 0x9062
testb $0x2, 0x42(%rax)
jne 0x9050
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9323
jmp 0x9032
movq %rbx, %rdi
callq 0x11bd0
movq %rbx, %rdi
callq 0x11cf3
jmp 0x9032
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x90a0
movq 0x20(%rdi), %rax
movb $0x1, 0xc(%rdi)
movq (%rax), %r8
subq 0x38(%rdi), %r8
movq %r8, 0x38(%rax)
testb $0x2, 0x42(%rax)
je 0x90b6
xorl %eax, %eax
popq %rcx
retq
movq 0x18(%rdi), %rax
cmpq %rdi, 0xc8(%rax)
jne 0x90e5
leaq 0x18321(%rip), %rsi     # 0x213d5
jmp 0x90ec
movq %rcx, 0x20(%rax)
testq %rcx, %rcx
je 0x90c3
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 0x848c
leaq 0x182bf(%rip), %rsi     # 0x213ab
xorl %eax, %eax
callq 0x7cd8
// File: /workspace/github_c_makefile_star2_O1/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 0x857f
movl %eax, %ebp
testl %eax, %eax
je 0x916f
addq 0x38(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9c59
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x8520
movq (%rsp), %rax
movq %rax, 0x20(%rbx)
movb %r13b, 0xcc(%rbx)
movw %r12w, 0xc4(%rbx)
movq %rbx, %rdi
callq 0x8755
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_O1/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        # 0x9265
movq %r14, %rdx
callq 0x90f3
movl %eax, %ebp
movq 0x8(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xb3eb
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 0xb3eb
movq 0x30(%r14), %rsi
movslq 0x3c(%r14), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xb3eb
movq 0x40(%r14), %rsi
movslq 0x4c(%r14), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xb3eb
decw 0xc4(%rbx)
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9281
callq 0x13ad0
movl %eax, %ebp
jmp 0x9290
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %ebp
movq 0x50(%r14), %rsi
cmpl $0x1b, %ebp
jne 0x92b9
leaq 0x181cb(%rip), %rdx     # 0x2146b
movq %rbx, %rdi
callq 0x9387
movq (%r14), %rsi
movq 0x58(%r14), %rdx
movq %rbx, %rdi
callq 0x105c4
jmp 0x92e2
leaq 0x181b2(%rip), %rdx     # 0x21472
movq %rbx, %rdi
callq 0x9387
leaq 0x8(%r14), %rdx
leaq 0x20(%r14), %rcx
movq (%r14), %rsi
movq 0x58(%r14), %r8
movq %rbx, %rdi
movl %ebp, %r9d
callq 0xc118
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x9b78
// File: /workspace/github_c_makefile_star2_O1/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 0xf52a
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 0x848c
// File: /workspace/github_c_makefile_star2_O1/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 0x9345
andb $-0x11, %al
movb %al, 0x42(%rbx)
movq 0x28(%rbx), %rax
movq %rax, 0xb0(%r14)
cmpw $-0x1, 0x40(%rbx)
jne 0x935a
movq 0x10(%r14), %rax
cmpq %rax, 0x8(%rbx)
jae 0x935a
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 0x8c0d
// File: /workspace/github_c_makefile_star2_O1/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 0x93aa
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsbl (%rdx), %esi
movq %r14, %rdi
callq 0x5170
testq %rax, %rax
je 0x93b0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x180c0(%rip), %rsi     # 0x21477
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0xbf04
movq %rbx, %rdi
movl $0x3, %esi
callq 0x848c
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rax
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x20(%rsp)
movl $0x0, 0x24(%rsp)
leaq 0x1809d(%rip), %rsi     # 0x214a1
movl $0x4, %edx
callq *%rax
movl %eax, 0x24(%rsp)
movb $0x53, (%rsp)
testl %eax, %eax
jne 0x9431
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq %rsp, %rsi
movl $0x1, %edx
callq *0x10(%rsp)
movl %eax, 0x24(%rsp)
movb $0x0, (%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x9456
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq %rsp, %rsi
movl $0x1, %edx
callq *0x10(%rsp)
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x947b
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
leaq 0x18038(%rip), %rsi     # 0x214a6
movl $0x6, %edx
callq *0x10(%rsp)
movl %eax, 0x24(%rsp)
movb $0x4, (%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x94a0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq %rsp, %rsi
movl $0x1, %edx
callq *0x10(%rsp)
movl %eax, 0x24(%rsp)
movb $0x8, (%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x94c5
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq %rsp, %rsi
movl $0x1, %edx
callq *0x10(%rsp)
movl %eax, 0x24(%rsp)
movb $0x4, (%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x94ea
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq %rsp, %rsi
movl $0x1, %edx
callq *0x10(%rsp)
movl %eax, 0x24(%rsp)
movb $0x8, (%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x950f
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq %rsp, %rsi
movl $0x1, %edx
callq *0x10(%rsp)
movl %eax, 0x24(%rsp)
movb $0x8, (%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x9534
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq %rsp, %rsi
movl $0x1, %edx
callq *0x10(%rsp)
movl %eax, 0x24(%rsp)
movq $0x5678, (%rsp)         # imm = 0x5678
cmpl $0x0, 0x24(%rsp)
jne 0x955d
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq %rsp, %rsi
movl $0x8, %edx
callq *0x10(%rsp)
movl %eax, 0x24(%rsp)
movabsq $0x4077280000000000, %rax # imm = 0x4077280000000000
movq %rax, (%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x958c
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq %rsp, %rsi
movl $0x8, %edx
callq *0x10(%rsp)
movl %eax, 0x24(%rsp)
movb 0x10(%rbx), %al
movb %al, (%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x95b3
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq %rsp, %rsi
movl $0x1, %edx
callq *0x10(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x95d1
movl 0x1c(%r14), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x9a36
movq %rdi, %r14
cmpb $0x4, 0x8(%rdi)
jne 0x9a5b
movzbl 0xb(%r14), %eax
jmp 0x9a5f
movb $0x0, 0xd(%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0x9aef
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
leaq 0xd(%rsp), %rsi
movl $0x1, %edx
jmp 0x9ae9
movq 0x10(%r14), %rax
incq %rax
movq %rax, 0x10(%rsp)
cmpq $0xfe, %rax
ja 0x9a8c
movb %al, 0xe(%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0x9acb
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
leaq 0xe(%rsp), %rsi
movl $0x1, %edx
jmp 0x9ac5
movb $-0x1, 0xf(%rsp)
cmpl $0x0, 0x1c(%rbx)
jne 0x9aae
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
cmpl $0x0, 0x1c(%rbx)
jne 0x9acb
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
movq 0x10(%rsp), %rdx
decq %rdx
je 0x9aef
cmpl $0x0, 0x1c(%rbx)
jne 0x9aef
addq $0x18, %r14
movq (%rbx), %rdi
movq 0x10(%rbx), %rcx
movq %r14, %rsi
callq *0x8(%rbx)
movl %eax, 0x1c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x9f37
movb %bl, 0xa(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9f37
movq %rax, %rbx
movq $0x0, 0x18(%rax)
movb %r14b, 0xa(%rax)
testl %r14d, %r14d
je 0x9b6d
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 0x51d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9bc9
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 0xb3eb
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 0x9b8c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lfunc.c
// Function: luaF_findupval
UpVal *luaF_findupval (lua_State *L, StkId level) {
  UpVal **pp = &L->openupval;
  UpVal *p;
  UpVal *uv;
  lua_assert(isintwups(L) || L->openupval == NULL);
  while (*pp != NULL && (p = *pp)->v >= level) {
    lua_assert(upisopen(p));
    if (p->v == level)  /* found a corresponding upvalue? */
      return p;  /* return it */
    pp = &p->u.open.next;
  }
  /* not found: create a new upvalue */
  uv = luaM_new(L, UpVal);
  uv->refcount = 0;
  uv->u.open.next = *pp;  /* link it to list of open upvalues */
  uv->u.open.touched = 1;
  *pp = uv;
  uv->v = level;  /* current value lives in the stack */
  if (!isintwups(L)) {  /* thread not in list of threads with upvalues? */
    L->twups = G(L)->twups;  /* link it to the list */
    G(L)->twups = L;
  }
  return uv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rdi), %r15
movq 0x40(%rdi), %rcx
testq %rcx, %rcx
je 0x9c0a
movq (%rcx), %rdx
cmpq %r14, %rdx
jb 0x9c0a
movq %rcx, %rax
cmpq %r14, %rdx
je 0x9c53
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x9c03
movq (%rcx), %rdx
cmpq %r14, %rdx
jae 0x9bea
addq $0x10, %rax
movq %rax, %r15
movl $0x20, %ecx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb3eb
movq $0x0, 0x8(%rax)
movq (%r15), %rcx
movq %rcx, 0x10(%rax)
movl $0x1, 0x18(%rax)
movq %rax, (%r15)
movq %r14, (%rax)
cmpq %rbx, 0x50(%rbx)
jne 0x9c53
movq 0x18(%rbx), %rcx
movq 0xa8(%rcx), %rdx
movq %rdx, 0x50(%rbx)
movq %rbx, 0xa8(%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lfunc.c
// Function: luaF_close
void luaF_close (lua_State *L, StkId level) {
  UpVal *uv;
  while (L->openupval != NULL && (uv = L->openupval)->v >= level) {
    lua_assert(upisopen(uv));
    L->openupval = uv->u.open.next;  /* remove from 'open' list */
    if (uv->refcount == 0)  /* no references? */
      luaM_free(L, uv);  /* free upvalue */
    else {
      setobj(L, &uv->u.value, uv->v);  /* move value to upvalue slot */
      uv->v = &uv->u.value;  /* now current value lives here */
      luaC_upvalbarrier(L, uv);
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x40(%rdi), %rsi
testq %rsi, %rsi
je 0x9cb8
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rbx, %rax
jb 0x9cb8
movq 0x10(%rsi), %rcx
movq %rcx, 0x40(%r14)
cmpq $0x0, 0x8(%rsi)
je 0x9ca0
leaq 0x10(%rsi), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq %rcx, (%rsi)
testb $0x40, 0x18(%rsi)
je 0x9caf
movq %r14, %rdi
callq 0x9efb
jmp 0x9caf
movl $0x20, %edx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb3eb
movq 0x40(%r14), %rsi
testq %rsi, %rsi
jne 0x9c6c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lfunc.c
// Function: luaF_freeproto
void luaF_freeproto (lua_State *L, Proto *f) {
  luaM_freearray(L, f->code, f->sizecode);
  luaM_freearray(L, f->p, f->sizep);
  luaM_freearray(L, f->k, f->sizek);
  luaM_freearray(L, f->lineinfo, f->sizelineinfo);
  luaM_freearray(L, f->locvars, f->sizelocvars);
  luaM_freearray(L, f->upvalues, f->sizeupvalues);
  luaM_free(L, f);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rsi), %rsi
movslq 0x18(%rbx), %rdx
shlq $0x2, %rdx
xorl %ecx, %ecx
callq 0xb3eb
movq 0x40(%rbx), %rsi
movslq 0x20(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb3eb
movq 0x30(%rbx), %rsi
movslq 0x14(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb3eb
movq 0x48(%rbx), %rsi
movslq 0x1c(%rbx), %rdx
shlq $0x2, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb3eb
movq 0x50(%rbx), %rsi
movslq 0x24(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb3eb
movq 0x58(%rbx), %rsi
movslq 0x10(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb3eb
movl $0x78, %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb3eb
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lfunc.c
// Function: luaF_getlocalname
const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
  int i;
  for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
    if (pc < f->locvars[i].endpc) {  /* is variable active? */
      local_number--;
      if (local_number == 0)
        return getstr(f->locvars[i].varname);
    }
  }
  return NULL;  /* not found */
}

// Assembly:
movslq 0x24(%rdi), %rcx
testq %rcx, %rcx
jle 0x9dcd
movq 0x50(%rdi), %rdi
shlq $0x4, %rcx
xorl %eax, %eax
xorl %r8d, %r8d
cmpl %edx, 0x8(%rdi,%r8)
jg 0x9dcc
cmpl %edx, 0xc(%rdi,%r8)
jle 0x9dc3
decl %esi
je 0x9dd0
addq $0x10, %r8
cmpq %r8, %rcx
jne 0x9db1
retq
xorl %eax, %eax
retq
movq (%rdi,%r8), %rax
addq $0x18, %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_barrier_
void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v) {
  global_State *g = G(L);
  lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
  if (keepinvariant(g))  /* must keep invariant? */
    reallymarkobject(g, v);  /* restore invariant */
  else {  /* sweep phase */
    lua_assert(issweepphase(g));
    makewhite(g, o);  /* mark main obj. as white to avoid other barriers */
  }
}

// Assembly:
movq 0x18(%rdi), %rdi
cmpb $0x1, 0x55(%rdi)
ja 0x9deb
movq %rdx, %rsi
jmp 0x9dfc
movb 0x9(%rsi), %al
andb $-0x8, %al
movb 0x54(%rdi), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: reallymarkobject
static void reallymarkobject (global_State *g, GCObject *o) {
 reentry:
  white2gray(o);
  switch (o->tt) {
    case LUA_TSHRSTR: {
      gray2black(o);
      g->GCmemtrav += sizelstring(gco2ts(o)->shrlen);
      break;
    }
    case LUA_TLNGSTR: {
      gray2black(o);
      g->GCmemtrav += sizelstring(gco2ts(o)->u.lnglen);
      break;
    }
    case LUA_TUSERDATA: {
      TValue uvalue;
      markobjectN(g, gco2u(o)->metatable);  /* mark its metatable */
      gray2black(o);
      g->GCmemtrav += sizeudata(gco2u(o));
      getuservalue(g->mainthread, gco2u(o), &uvalue);
      if (valiswhite(&uvalue)) {  /* markvalue(g, &uvalue); */
        o = gcvalue(&uvalue);
        goto reentry;
      }
      break;
    }
    case LUA_TLCL: {
      linkgclist(gco2lcl(o), g->gray);
      break;
    }
    case LUA_TCCL: {
      linkgclist(gco2ccl(o), g->gray);
      break;
    }
    case LUA_TTABLE: {
      linkgclist(gco2t(o), g->gray);
      break;
    }
    case LUA_TTHREAD: {
      linkgclist(gco2th(o), g->gray);
      break;
    }
    case LUA_TPROTO: {
      linkgclist(gco2p(o), g->gray);
      break;
    }
    default: lua_assert(0); break;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0x9(%r14), %al
andb $-0x4, %al
movb %al, 0x9(%r14)
movzbl 0x8(%r14), %ecx
cmpl $0x7, %ecx
jne 0x9e6a
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x9e31
testb $0x3, 0x9(%rsi)
je 0x9e31
movq %rbx, %rdi
callq 0x9dfc
orb $0x4, 0x9(%r14)
movq 0x18(%r14), %rax
movq 0x20(%rbx), %rcx
addq %rcx, %rax
addq $0x28, %rax
movq %rax, 0x20(%rbx)
testb $0x40, 0xa(%r14)
je 0x9e5c
movq 0x20(%r14), %rcx
movb $0x1, %al
testb $0x3, 0x9(%rcx)
jne 0x9e61
xorl %eax, %eax
movq %r14, %rcx
movq %rcx, %r14
testb %al, %al
jne 0x9e06
jmp 0x9ede
leal -0x4(%rcx), %edx
cmpl $0x5, %edx
ja 0x9e8f
leaq 0x17637(%rip), %rcx     # 0x214b0
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
orb $0x4, %al
movb %al, 0x9(%r14)
movzbl 0xb(%r14), %eax
jmp 0x9ecf
cmpl $0x14, %ecx
je 0x9ec5
cmpl $0x26, %ecx
jne 0x9ede
movq 0x70(%rbx), %rax
movq %rax, 0x10(%r14)
jmp 0x9ebf
movq 0x70(%rbx), %rax
movq %rax, 0x30(%r14)
jmp 0x9ebf
movq 0x70(%rbx), %rax
movq %rax, 0x48(%r14)
jmp 0x9ebf
movq 0x70(%rbx), %rax
movq %rax, 0x70(%r14)
movq %r14, 0x70(%rbx)
jmp 0x9ede
orb $0x4, %al
movb %al, 0x9(%r14)
movq 0x10(%r14), %rax
movq 0x20(%rbx), %rcx
addq %rcx, %rax
addq $0x19, %rax
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_fix
void luaC_fix (lua_State *L, GCObject *o) {
  global_State *g = G(L);
  lua_assert(g->allgc == o);  /* object must be 1st in 'allgc' list! */
  white2gray(o);  /* they will be gray forever */
  g->allgc = o->next;  /* remove object from 'allgc' list */
  o->next = g->fixedgc;  /* link it to 'fixedgc' list */
  g->fixedgc = o;
}

// Assembly:
movq 0x18(%rdi), %rax
andb $-0x4, 0x9(%rsi)
movq (%rsi), %rcx
movq %rcx, 0x58(%rax)
movq 0xa0(%rax), %rcx
movq %rcx, (%rsi)
movq %rsi, 0xa0(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_newobj
GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) {
  global_State *g = G(L);
  GCObject *o = cast(GCObject *, luaM_newobject(L, novariant(tt), sz));
  o->marked = luaC_white(g);
  o->tt = tt;
  o->next = g->allgc;
  g->allgc = o;
  return o;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rcx
movl %esi, %ebx
movq 0x18(%rdi), %r14
movl %esi, %edx
andl $0xf, %edx
xorl %esi, %esi
callq 0xb3eb
movb 0x54(%r14), %cl
andb $0x3, %cl
movb %cl, 0x9(%rax)
movb %bl, 0x8(%rax)
movq 0x58(%r14), %rcx
movq %rcx, (%rax)
movq %rax, 0x58(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_checkfinalizer
void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) {
  global_State *g = G(L);
  if (tofinalize(o) ||                 /* obj. is already marked... */
      gfasttm(g, mt, TM_GC) == NULL)   /* or has no finalizer? */
    return;  /* nothing to be done */
  else {  /* move 'o' to 'finobj' list */
    GCObject **p;
    if (issweepphase(g)) {
      makewhite(g, o);  /* "sweep" object 'o' */
      if (g->sweepgc == &o->next)  /* should not remove 'sweepgc' object */
        g->sweepgc = sweeptolive(L, g->sweepgc);  /* change 'sweepgc' */
    }
    /* search for pointer pointing to 'o' */
    for (p = &g->allgc; *p != o; p = &(*p)->next) { /* empty */ }
    *p = o->next;  /* remove 'o' from 'allgc' list */
    o->next = g->finobj;  /* link it in 'finobj' list */
    g->finobj = o;
    l_setbit(o->marked, FINALIZEDBIT);  /* mark it as such */
  }
}

// Assembly:
testq %rdx, %rdx
je 0xa047
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb 0x9(%rsi), %al
andb $0x8, %al
jne 0xa03c
testb $0x4, 0xa(%rdx)
jne 0xa03c
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq 0xf0(%r15), %rax
movq %rdx, %rdi
movl $0x2, %esi
movq %rax, %rdx
callq 0x102d9
testq %rax, %rax
je 0xa03c
movb 0x55(%r15), %al
addb $-0x2, %al
cmpb $0x3, %al
ja 0xa018
movb 0x9(%rbx), %al
andb $-0x8, %al
movb 0x54(%r15), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rbx)
movq 0x60(%r15), %r12
cmpq %rbx, %r12
jne 0xa018
movq %r12, %rax
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xa0f8
cmpq %r12, %rax
je 0x9fff
movq %rax, 0x60(%r15)
leaq 0x58(%r15), %rcx
movq %rcx, %rax
movq (%rcx), %rcx
cmpq %rbx, %rcx
jne 0xa01c
movq (%rbx), %rcx
movq %rcx, (%rax)
movq 0x68(%r15), %rax
movq %rax, (%rbx)
movq %rbx, 0x68(%r15)
orb $0x8, 0x9(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_freeallobjects
void luaC_freeallobjects (lua_State *L) {
  global_State *g = G(L);
  separatetobefnz(g, 1);  /* separate all objects with finalizers */
  lua_assert(g->finobj == NULL);
  callallpendingfinalizers(L);
  lua_assert(g->tobefnz == NULL);
  g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */
  g->gckind = KGC_NORMAL;
  sweepwholelist(L, &g->finobj);
  sweepwholelist(L, &g->allgc);
  sweepwholelist(L, &g->fixedgc);  /* collect fixed objects */
  lua_assert(g->strt.nuse == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x98(%r14), %rcx
movq %rcx, %rax
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0xa05e
leaq 0x68(%r14), %r15
movq 0x68(%r14), %rcx
testq %rcx, %rcx
je 0xa08d
movq (%rcx), %rdx
movq %rdx, (%r15)
movq (%rax), %rdx
movq %rdx, (%rcx)
movq %rcx, (%rax)
movq %rcx, %rax
movq (%r15), %rcx
jmp 0xa071
movq 0x18(%rbx), %r12
cmpq $0x0, 0x98(%r12)
je 0xa0a8
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa8a6
jmp 0xa091
movb $0x3, 0x54(%r14)
movb $0x0, 0x56(%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq $-0x1, %rdx
callq 0xa0f8
leaq 0x58(%r14), %rsi
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0xa0f8
addq $0xa0, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa0f8
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: sweeplist
static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
  global_State *g = G(L);
  int ow = otherwhite(g);
  int white = luaC_white(g);  /* current white */
  while (*p != NULL && count-- > 0) {
    GCObject *curr = *p;
    int marked = curr->marked;
    if (isdeadm(ow, marked)) {  /* is 'curr' dead? */
      *p = curr->next;  /* remove 'curr' from list */
      freeobj(L, curr);  /* erase 'curr' */
    }
    else {  /* change mark to 'white' */
      curr->marked = cast_byte((marked & maskcolors) | white);
      p = &curr->next;  /* go to next element */
    }
  }
  return (*p == NULL) ? NULL : p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r12
testq %r12, %r12
je 0xa23a
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rax
movb 0x54(%rax), %bpl
movl %ebp, %r13d
xorb $0x3, %r13b
andb $0x3, %bpl
subq $0x1, %r14
jb 0xa23c
movb 0x9(%r12), %al
movl %eax, %ecx
xorb $0x3, %cl
testb %r13b, %cl
je 0xa156
andb $-0x8, %al
orb %bpl, %al
movb %al, 0x9(%r12)
movq %r12, %rbx
jmp 0xa205
movq (%r12), %rax
movq %rax, (%rbx)
movzbl 0x8(%r12), %eax
leal -0x4(%rax), %ecx
cmpl $0x10, %ecx
ja 0xa18e
leaq 0x17356(%rip), %rdx     # 0x214c8
movslq (%rdx,%rcx,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %r15, %rdi
movq %r12, %rsi
callq 0xf4f6
movzbl 0xb(%r12), %edx
jmp 0xa1a7
cmpl $0x26, %eax
jne 0xa205
movzbl 0xa(%r12), %edx
shll $0x4, %edx
addq $0x20, %rdx
jmp 0xa1f8
movq 0x10(%r12), %rdx
addq $0x19, %rdx
jmp 0xa1f8
movb 0xa(%r12), %al
testb %al, %al
je 0xa1e2
movb %bpl, 0x7(%rsp)
xorl %ebp, %ebp
movq 0x20(%r12,%rbp,8), %rsi
testq %rsi, %rsi
je 0xa1cf
movq %r15, %rdi
callq 0x9f70
incq %rbp
movzbl 0xa(%r12), %eax
cmpq %rax, %rbp
jb 0xa1bd
movb 0x7(%rsp), %bpl
movzbl %al, %eax
leaq 0x20(,%rax,8), %rdx
jmp 0xa1f8
movq 0x18(%r12), %rdx
addq $0x28, %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0xb3eb
movq (%rbx), %r12
testq %r12, %r12
jne 0xa12b
jmp 0xa23a
movq %r15, %rdi
movq %r12, %rsi
callq 0xfabd
jmp 0xa205
movq %r15, %rdi
movq %r12, %rsi
callq 0xed21
jmp 0xa205
movq %r15, %rdi
movq %r12, %rsi
callq 0x9cf7
jmp 0xa205
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_step
void luaC_step (lua_State *L) {
  global_State *g = G(L);
  l_mem debt = getdebt(g);  /* GC deficit (be paid now) */
  if (!g->gcrunning) {  /* not running? */
    luaE_setdebt(g, -GCSTEPSIZE * 10);  /* avoid being called too often */
    return;
  }
  do {  /* repeat until pause or enough "credit" (negative debt) */
    lu_mem work = singlestep(L);  /* perform one single step */
    debt -= work;
  } while (debt > -GCSTEPSIZE && g->gcstate != GCSpause);
  if (g->gcstate == GCSpause)
    setpause(g);  /* pause until next cycle */
  else {
    debt = (debt / g->gcstepmul) * STEPMULADJ;  /* convert 'work units' to Kb */
    luaE_setdebt(g, debt);
    runafewfinalizers(L);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rbx
movq 0x18(%rbx), %rax
testq %rax, %rax
jle 0xa6b3
movslq 0xb8(%rbx), %r15
shrq $0x3, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
movq %rdx, %rcx
shrq $0x2, %rcx
incq %rcx
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movq %rsi, %rax
xorl %edx, %edx
idivq %r15
imulq %rcx, %r15
cmpq %rax, %rcx
cmovgeq %rsi, %r15
jmp 0xa6b6
xorl %r15d, %r15d
cmpb $0x0, 0x57(%rbx)
je 0xa72c
movq %r14, %rdi
callq 0xa27e
subq %rax, %r15
cmpq $-0x95f, %r15           # imm = 0xF6A1
jl 0xa6d6
cmpb $0x7, 0x55(%rbx)
jne 0xa6bc
cmpb $0x7, 0x55(%rbx)
jne 0xa740
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
movq %rdx, %rcx
shrq $0x2, %rcx
movslq 0xb4(%rbx), %r8
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
movq %rdi, %rax
xorl %edx, %edx
divq %rcx
imulq %r8, %rcx
cmpq %r8, %rax
cmovleq %rdi, %rcx
addq 0x10(%rbx), %rsi
subq %rcx, %rsi
movq %rbx, %rdi
jmp 0xa736
movq %rbx, %rdi
movq $-0x5dc0, %rsi          # imm = 0xA240
popq %rbx
popq %r14
popq %r15
jmp 0xeaa4
movslq 0xb8(%rbx), %rcx
movq %r15, %rax
cqto
idivq %rcx
imulq $0xc8, %rax, %rsi
movq %rbx, %rdi
callq 0xeaa4
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xa768
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: runafewfinalizers
static int runafewfinalizers (lua_State *L) {
  global_State *g = G(L);
  unsigned int i;
  lua_assert(!g->tobefnz || g->gcfinnum > 0);
  for (i = 0; g->tobefnz && i < g->gcfinnum; i++)
    GCTM(L, 1);  /* call one finalizer */
  g->gcfinnum = (!g->tobefnz) ? 0  /* nothing more to finalize? */
                    : g->gcfinnum * 2;  /* else call a few more next time */
  return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %r15
cmpq $0x0, 0x98(%r15)
sete %al
je 0xa7ca
cmpl $0x0, 0xb0(%r15)
movl $0x0, %ebx
je 0xa7bb
movq %rdi, %r14
xorl %ebp, %ebp
xorl %ebx, %ebx
movq %r14, %rdi
movl $0x1, %esi
callq 0xa8a6
incl %ebx
cmpq $0x0, 0x98(%r15)
sete %al
je 0xa7ce
cmpl 0xb0(%r15), %ebx
jb 0xa796
testb %al, %al
jne 0xa7cc
movl 0xb0(%r15), %ebp
addl %ebp, %ebp
jmp 0xa7ce
xorl %ebx, %ebx
xorl %ebp, %ebp
movl %ebp, 0xb0(%r15)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_fullgc
void luaC_fullgc (lua_State *L, int isemergency) {
  global_State *g = G(L);
  lua_assert(g->gckind == KGC_NORMAL);
  if (isemergency) g->gckind = KGC_EMERGENCY;  /* set flag */
  if (keepinvariant(g)) {  /* black objects? */
    entersweep(L); /* sweep everything to turn them back to white */
  }
  /* finish any pending sweep phase to start a new cycle */
  luaC_runtilstate(L, bitmask(GCSpause));
  luaC_runtilstate(L, ~bitmask(GCSpause));  /* start new collection */
  luaC_runtilstate(L, bitmask(GCScallfin));  /* run up to finalizers */
  /* estimate must be correct after a full GC cycle */
  lua_assert(g->GCestimate == gettotalbytes(g));
  luaC_runtilstate(L, bitmask(GCSpause));  /* finish collection */
  g->gckind = KGC_NORMAL;
  setpause(g);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rbx
testl %esi, %esi
je 0xa7f5
movb $0x1, 0x56(%rbx)
cmpb $0x1, 0x55(%rbx)
ja 0xa814
movb $0x2, 0x55(%rbx)
leaq 0x58(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0xa0f8
movq %rax, 0x60(%rbx)
movq %r14, %rdi
movl $0x80, %esi
callq 0xa24e
movq %r14, %rdi
movl $0xffffff7f, %esi       # imm = 0xFFFFFF7F
callq 0xa24e
movq %r14, %rdi
movl $0x40, %esi
callq 0xa24e
movq %r14, %rdi
movl $0x80, %esi
callq 0xa24e
movb $0x0, 0x56(%rbx)
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
movq %rdx, %rcx
shrq $0x2, %rcx
movslq 0xb4(%rbx), %r8
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
movq %rdi, %rax
xorl %edx, %edx
divq %rcx
imulq %r8, %rcx
cmpq %r8, %rax
cmovleq %rdi, %rcx
addq 0x10(%rbx), %rsi
subq %rcx, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xeaa4
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: GCTM
static void GCTM (lua_State *L, int propagateerrors) {
  global_State *g = G(L);
  const TValue *tm;
  TValue v;
  setgcovalue(L, &v, udata2finalize(g));
  tm = luaT_gettmbyobj(L, &v, TM_GC);
  if (tm != NULL && ttisfunction(tm)) {  /* is there a finalizer? */
    int status;
    lu_byte oldah = L->allowhook;
    int running  = g->gcrunning;
    L->allowhook = 0;  /* stop debug hooks during GC metamethod */
    g->gcrunning = 0;  /* avoid GC steps */
    setobj2s(L, L->top, tm);  /* push finalizer... */
    setobj2s(L, L->top + 1, &v);  /* ... and its argument */
    L->top += 2;  /* and (next line) call the finalizer */
    status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top - 2), 0);
    L->allowhook = oldah;  /* restore hooks */
    g->gcrunning = running;  /* restore state */
    if (status != LUA_OK && propagateerrors) {  /* error while running __gc? */
      if (status == LUA_ERRRUN) {  /* is there an error object? */
        const char *msg = (ttisstring(L->top - 1))
                            ? svalue(L->top - 1)
                            : "no message";
        luaO_pushfstring(L, "error in __gc metamethod (%s)", msg);
        status = LUA_ERRGCMM;  /* error in __gc metamethod */
      }
      luaD_throw(L, status);  /* re-throw error */
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq 0x58(%r14), %rcx
movq 0x98(%r14), %rax
movq (%rax), %rdx
movq %rdx, 0x98(%r14)
movq %rcx, (%rax)
movq %rax, 0x58(%r14)
movb 0x9(%rax), %cl
movl %ecx, %edx
andb $-0x9, %dl
movb %dl, 0x9(%rax)
movb 0x55(%r14), %dl
addb $-0x2, %dl
cmpb $0x3, %dl
ja 0xa8fd
andb $-0x10, %cl
movb 0x54(%r14), %dl
andb $0x3, %dl
orb %cl, %dl
movb %dl, 0x9(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movzbl 0x8(%rax), %eax
orl $0x40, %eax
movl %eax, 0x8(%rsi)
movq %rbx, %rdi
movl $0x2, %edx
callq 0x10304
testq %rax, %rax
je 0xa98e
movl 0x8(%rax), %ecx
andl $0xf, %ecx
cmpl $0x6, %ecx
jne 0xa98e
movb 0xcc(%rbx), %r15b
movb 0x57(%r14), %r12b
xorl %ecx, %ecx
movb %cl, 0xcc(%rbx)
movb %cl, 0x57(%r14)
movq 0x10(%rbx), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rbx), %rax
movups (%rsp), %xmm0
movups %xmm0, 0x10(%rax)
movq 0x10(%rbx), %rcx
leaq 0x20(%rcx), %rax
movq %rax, 0x10(%rbx)
subq 0x38(%rbx), %rcx
leaq 0x72(%rip), %rsi        # 0xa9e0
movq %rbx, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x90f3
movb %r15b, 0xcc(%rbx)
movb %r12b, 0x57(%r14)
testl %ebp, %ebp
je 0xa98e
testl %eax, %eax
jne 0xa99b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %eax
jne 0xa9d6
movq 0x10(%rbx), %rax
movl -0x8(%rax), %ecx
andl $0xf, %ecx
cmpl $0x4, %ecx
jne 0xa9b9
movq -0x10(%rax), %rdx
addq $0x18, %rdx
jmp 0xa9c0
leaq 0x16b80(%rip), %rdx     # 0x21540
leaq 0x16b84(%rip), %rsi     # 0x2154b
movq %rbx, %rdi
xorl %eax, %eax
callq 0xbf04
movl $0x5, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x848c
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: sweepstep
static lu_mem sweepstep (lua_State *L, global_State *g,
                         int nextstate, GCObject **nextlist) {
  if (g->sweepgc) {
    l_mem olddebt = g->GCdebt;
    g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
    g->GCestimate += g->GCdebt - olddebt;  /* update estimate */
    if (g->sweepgc)  /* is there still something to sweep? */
      return (GCSWEEPMAX * GCSWEEPCOST);
  }
  /* else enter next state */
  g->gcstate = nextstate;
  g->sweepgc = nextlist;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq 0x60(%rsi), %rsi
testq %rsi, %rsi
je 0xafc8
movq 0x18(%r14), %r15
movl $0x55, %edx
callq 0xa0f8
movq %rax, %rcx
movq %rax, 0x60(%r14)
movq 0x18(%r14), %rax
subq %r15, %rax
addq %rax, 0x28(%r14)
movl $0x253, %eax            # imm = 0x253
testq %rcx, %rcx
jne 0xafd2
movb %bpl, 0x55(%r14)
movq %rbx, 0x60(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: iscleared
static int iscleared (global_State *g, const TValue *o) {
  if (!iscollectable(o)) return 0;
  else if (ttisstring(o)) {
    markobject(g, tsvalue(o));  /* strings are 'values', so are never weak */
    return 0;
  }
  else return iswhite(gcvalue(o));
}

// Assembly:
pushq %rbx
movl 0x8(%rsi), %eax
xorl %ebx, %ebx
testb $0x40, %al
je 0xb1c9
andl $0xf, %eax
movq (%rsi), %rsi
movzbl 0x9(%rsi), %ecx
andl $0x3, %ecx
cmpl $0x4, %eax
jne 0xb1c7
testb %cl, %cl
je 0xb1c9
callq 0x9dfc
jmp 0xb1c9
movl %ecx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: convergeephemerons
static void convergeephemerons (global_State *g) {
  int changed;
  do {
    GCObject *w;
    GCObject *next = g->ephemeron;  /* get ephemeron list */
    g->ephemeron = NULL;  /* tables may return to this list when traversed */
    changed = 0;
    while ((w = next) != NULL) {
      next = gco2t(w)->gclist;
      if (traverseephemeron(g, gco2t(w))) {  /* traverse marked some value? */
        propagateall(g);  /* propagate changes */
        changed = 1;  /* will have to revisit all ephemeron tables */
      }
    }
  } while (changed);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x88(%rbx), %r14
movq $0x0, 0x88(%rbx)
testq %r14, %r14
je 0xb21f
xorl %ebp, %ebp
movq %r14, %rsi
movq 0x30(%r14), %r14
movq %rbx, %rdi
callq 0xb047
testl %eax, %eax
je 0xb216
movl $0x1, %ebp
cmpq $0x0, 0x70(%rbx)
je 0xb216
movq %rbx, %rdi
callq 0xa9ef
jmp 0xb205
testq %r14, %r14
jne 0xb1ed
testl %ebp, %ebp
jne 0xb1d4
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: clearvalues
static void clearvalues (global_State *g, GCObject *l, GCObject *f) {
  for (; l != f; l = gco2t(l)->gclist) {
    Table *h = gco2t(l);
    Node *n, *limit = gnodelast(h);
    unsigned int i;
    for (i = 0; i < h->sizearray; i++) {
      TValue *o = &h->array[i];
      if (iscleared(g, o))  /* value was collected? */
        setnilvalue(o);  /* remove value */
    }
    for (n = gnode(h, 0); n < limit; n++) {
      if (!ttisnil(gval(n)) && iscleared(g, gval(n))) {
        setnilvalue(gval(n));  /* remove value ... */
        removeentry(n);  /* and remove entry from table */
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
cmpq %rdx, %rsi
je 0xb2ea
movq %rsi, %r14
movq %rdi, %r15
movb 0xb(%r14), %cl
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %r13
shlq $0x5, %r13
addq 0x18(%r14), %r13
cmpl $0x0, 0xc(%r14)
je 0xb291
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x10(%r14), %rbx
leaq (%rbx,%r12), %rsi
movq %r15, %rdi
callq 0xb1a0
testl %eax, %eax
je 0xb281
movl $0x0, 0x8(%rbx,%r12)
incq %rbp
movl 0xc(%r14), %eax
addq $0x10, %r12
cmpq %rax, %rbp
jb 0xb264
movq 0x18(%r14), %r12
cmpq %r13, %r12
jae 0xb2dc
cmpl $0x0, 0x8(%r12)
je 0xb2d6
movq %r15, %rdi
movq %r12, %rsi
callq 0xb1a0
testl %eax, %eax
je 0xb2d6
movl $0x0, 0x8(%r12)
testb $0x40, 0x18(%r12)
je 0xb2d6
movq 0x10(%r12), %rax
testb $0x3, 0x9(%rax)
je 0xb2d6
movl $0xa, 0x18(%r12)
addq $0x20, %r12
jmp 0xb295
movq 0x30(%r14), %r14
cmpq (%rsp), %r14
jne 0xb242
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: clearkeys
static void clearkeys (global_State *g, GCObject *l, GCObject *f) {
  for (; l != f; l = gco2t(l)->gclist) {
    Table *h = gco2t(l);
    Node *n, *limit = gnodelast(h);
    for (n = gnode(h, 0); n < limit; n++) {
      if (!ttisnil(gval(n)) && (iscleared(g, gkey(n)))) {
        setnilvalue(gval(n));  /* remove value ... */
        removeentry(n);  /* and remove entry from table */
      }
    }
  }
}

// Assembly:
testq %rsi, %rsi
je 0xb38b
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb 0xb(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
cmpb $0x1f, %cl
je 0xb377
movq 0x18(%rbx), %r15
movslq %eax, %r12
shlq $0x5, %r12
addq %r15, %r12
addq $0x10, %r15
cmpl $0x0, -0x8(%r15)
je 0xb367
movq %r14, %rdi
movq %r15, %rsi
callq 0xb1a0
testl %eax, %eax
je 0xb367
movl $0x0, -0x8(%r15)
testb $0x40, 0x8(%r15)
je 0xb367
movq (%r15), %rax
testb $0x3, 0x9(%rax)
je 0xb367
movl $0xa, 0x8(%r15)
leaq 0x20(%r15), %rax
addq $0x10, %r15
cmpq %r12, %r15
movq %rax, %r15
jb 0xb331
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0xb310
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq