LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x81eb
movl %eax, %ebp
testl %eax, %eax
je 0x8db5
addq 0x38(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x95bc
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x818e
movq (%rsp), %rax
movq %rax, 0x20(%rbx)
movb %r13b, 0xcc(%rbx)
movw %r12w, 0xc4(%rbx)
movq %rbx, %rdi
callq 0x83b9
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_O2/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 %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
incw 0xc4(%rdi)
movq %rsp, %r14
movq %rsi, (%r14)
movq %rdx, 0x58(%r14)
movq %rcx, 0x50(%r14)
andl $0x0, 0x2c(%r14)
andq $0x0, 0x30(%r14)
andl $0x0, 0x3c(%r14)
andq $0x0, 0x40(%r14)
andl $0x0, 0x4c(%r14)
andq $0x0, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movq 0x10(%rdi), %rcx
movq 0xb0(%rdi), %r8
subq 0x38(%rdi), %rcx
leaq 0x78(%rip), %rsi        # 0x8ea1
movq %r14, %rdx
callq 0x8d39
movl %eax, %ebp
movq 0x8(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xab76
movq %rax, 0x8(%r14)
andq $0x0, 0x18(%r14)
movq 0x20(%r14), %rsi
movslq 0x2c(%r14), %rdx
addq %rdx, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xab76
movq 0x30(%r14), %rsi
movslq 0x3c(%r14), %rax
imulq $0x18, %rax, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xab76
movq 0x40(%r14), %rsi
movslq 0x4c(%r14), %rax
imulq $0x18, %rax, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xab76
decw 0xc4(%rbx)
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8ebd
callq 0x1273c
movl %eax, %ebp
jmp 0x8ecc
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %ebp
movq 0x50(%r14), %rsi
cmpl $0x1b, %ebp
jne 0x8ef5
leaq 0x1659f(%rip), %rdx     # 0x1f47b
movq %rbx, %rdi
callq 0x8fc1
movq (%r14), %rsi
movq 0x58(%r14), %rdx
movq %rbx, %rdi
callq 0xf768
jmp 0x8f1e
leaq 0x16586(%rip), %rdx     # 0x1f482
movq %rbx, %rdi
callq 0x8fc1
leaq 0x8(%r14), %rdx
leaq 0x20(%r14), %rcx
movq (%r14), %rsi
movq 0x58(%r14), %r8
movq %rbx, %rdi
movl %ebp, %r9d
callq 0xb79c
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x94f5
// File: /workspace/github_c_makefile_star2_O2/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 0xe823
movq %rax, (%rbx)
movzbl 0x8(%rax), %eax
orl $0x40, %eax
movl %eax, 0x8(%rbx)
addq $0x10, 0x10(%r14)
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x80fc
// File: /workspace/github_c_makefile_star2_O2/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 0x8f7f
andb $-0x11, %al
movb %al, 0x42(%rbx)
movq 0x28(%rbx), %rax
movq %rax, 0xb0(%r14)
cmpw $-0x1, 0x40(%rbx)
jne 0x8f94
movq 0x10(%r14), %rax
cmpq %rax, 0x8(%rbx)
jae 0x8f94
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 0x8859
// File: /workspace/github_c_makefile_star2_O2/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 0x8fe4
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsbl (%rdx), %esi
movq %r14, %rdi
callq 0x5160
testq %rax, %rax
je 0x8fea
popq %rbx
popq %r14
popq %r15
retq
leaq 0x16496(%rip), %rsi     # 0x1f487
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0xb593
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x80fc
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rax
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movq %rdx, 0x8(%r14)
movq %rcx, 0x10(%r14)
movl %r8d, 0x18(%r14)
leaq 0x16489(%rip), %rsi     # 0x1f4c0
pushq $0x4
popq %rdx
callq *%rax
movl %eax, 0x1c(%r14)
pushq $0x53
popq %rdi
movq %r14, %rsi
callq 0x90fd
xorl %edi, %edi
movq %r14, %rsi
callq 0x90fd
cmpl $0x0, 0x1c(%r14)
jne 0x9078
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
leaq 0x16458(%rip), %rsi     # 0x1f4c5
pushq $0x6
popq %rdx
callq *0x10(%rsp)
movl %eax, 0x24(%rsp)
pushq $0x4
popq %rbp
leaq 0x8(%rsp), %r14
movl %ebp, %edi
movq %r14, %rsi
callq 0x90fd
pushq $0x8
popq %r15
movl %r15d, %edi
movq %r14, %rsi
callq 0x90fd
movl %ebp, %edi
movq %r14, %rsi
callq 0x90fd
movl %r15d, %edi
movq %r14, %rsi
callq 0x90fd
movl %r15d, %edi
movq %r14, %rsi
callq 0x90fd
movl $0x5678, %edi           # imm = 0x5678
movq %r14, %rsi
callq 0x93c7
movsd 0x163ea(%rip), %xmm0    # 0x1f4b8
movq %r14, %rdi
callq 0x93de
movl 0x10(%rbx), %edi
movq %r14, %rsi
callq 0x90fd
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x9116
movl 0x1c(%r14), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9414
movq %rdi, %r14
cmpb $0x4, 0x8(%rdi)
jne 0x9427
movzbl 0xb(%r14), %r15d
jmp 0x942b
xorl %edi, %edi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x90fd
movq 0x10(%r14), %r15
leaq 0x1(%r15), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %r14
cmpq $0xfe, %rdi
ja 0x944b
movq %rbx, %rsi
callq 0x90fd
jmp 0x9471
movl $0xff, %edi
movq %rbx, %rsi
callq 0x90fd
leaq 0x8(%rsp), %r15
pushq $0x8
popq %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x93a3
movq (%r15), %r15
decq %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x93a3
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x26
popq %rsi
callq 0x9874
movb %bl, 0xa(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %esi, %ebx
leal 0x20(,%rbx,8), %eax
movslq %eax, %rdx
pushq $0x6
popq %rsi
callq 0x9874
andq $0x0, 0x18(%rax)
movb %bl, 0xa(%rax)
movslq %ebx, %rcx
addq $0x3, %rcx
cmpq $0x3, %rcx
je 0x94f3
andq $0x0, (%rax,%rcx,8)
decq %rcx
jmp 0x94e3
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
pushq $0x20
popq %r15
movzbl 0xa(%rbx), %eax
cmpq %rax, %r12
jae 0x953f
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0xab76
movq $0x1, 0x8(%rax)
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
andl $0x0, 0x18(%rax)
movq %rax, 0x20(%rbx,%r12,8)
incq %r12
jmp 0x950a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 (%r15), %rax
testq %rax, %rax
je 0x9572
cmpq %r14, (%rax)
jb 0x9572
je 0x95b6
addq $0x10, %rax
movq %rax, %r15
jmp 0x955a
pushq $0x20
popq %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xab76
andq $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 0x95b6
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_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x20
popq %r15
movq 0x40(%r14), %rsi
testq %rsi, %rsi
je 0x9617
movq (%rsi), %rax
cmpq %rbx, %rax
jb 0x9617
movq 0x10(%rsi), %rcx
movq %rcx, 0x40(%r14)
cmpq $0x0, 0x8(%rsi)
je 0x9608
leaq 0x10(%rsi), %rcx
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq %rcx, (%rsi)
testb $0x40, 0x18(%rsi)
je 0x95cb
movq %r14, %rdi
callq 0x9838
jmp 0x95cb
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0xab76
jmp 0x95cb
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xab76
movq 0x40(%rbx), %rsi
movslq 0x20(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xab76
movq 0x30(%rbx), %rsi
movslq 0x14(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xab76
movq 0x48(%rbx), %rsi
movslq 0x1c(%rbx), %rdx
shlq $0x2, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xab76
movq 0x50(%rbx), %rsi
movslq 0x24(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xab76
movq 0x58(%rbx), %rsi
movslq 0x10(%rbx), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xab76
pushq $0x78
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xab76
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x24(%rdi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
shlq $0x4, %rcx
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x972b
movq 0x50(%rdi), %r9
cmpl %edx, 0x8(%r9,%r8)
jg 0x972b
cmpl %edx, 0xc(%r9,%r8)
jle 0x971d
decl %esi
je 0x9723
addq $0x10, %r8
jmp 0x9702
movq (%r9,%r8), %rax
addq $0x18, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x973b
movq %rdx, %rsi
jmp 0x974c
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_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb 0x9(%rsi), %al
leaq 0x15d6b(%rip), %r15     # 0x1f4cc
andb $-0x4, %al
movb %al, 0x9(%r14)
movzbl 0x8(%r14), %ecx
leal -0x4(%rcx), %edx
cmpl $0x10, %edx
ja 0x97c6
movslq (%r15,%rdx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x9798
testb $0x3, 0x9(%rsi)
je 0x9798
movq %rbx, %rdi
callq 0x974c
movb 0x9(%r14), %al
orb $0x4, %al
movb %al, 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 0x981d
movq 0x20(%r14), %r14
movb 0x9(%r14), %al
testb $0x3, %al
jne 0x9761
jmp 0x981d
cmpl $0x26, %ecx
jne 0x981d
movq 0x70(%rbx), %rax
movq %rax, 0x10(%r14)
jmp 0x9819
orb $0x4, %al
movb %al, 0x9(%r14)
movq 0x10(%r14), %rax
jmp 0x97f6
movq 0x70(%rbx), %rax
movq %rax, 0x70(%r14)
jmp 0x9819
orb $0x4, %al
movb %al, 0x9(%r14)
movzbl 0xb(%r14), %eax
movq 0x20(%rbx), %rcx
addq %rcx, %rax
addq $0x19, %rax
movq %rax, 0x20(%rbx)
jmp 0x981d
movq 0x70(%rbx), %rax
movq %rax, 0x30(%r14)
jmp 0x9819
movq 0x70(%rbx), %rax
movq %rax, 0x48(%r14)
movq %r14, 0x70(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9987
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb 0x9(%rsi), %al
andb $0x8, %al
jne 0x997c
testb $0x4, 0xa(%rdx)
jne 0x997c
movq %rdi, %r14
movq 0x18(%rdi), %r12
movq 0xf0(%r12), %rax
pushq $0x2
popq %rsi
movq %rdx, %rdi
movq %rax, %rdx
callq 0xf48b
testq %rax, %rax
je 0x997c
movb 0x55(%r12), %al
addb $-0x2, %al
cmpb $0x3, %al
ja 0x9955
movb 0x9(%rbx), %al
andb $-0x8, %al
movb 0x54(%r12), %cl
andb $0x3, %cl
orb %al, %cl
movb %cl, 0x9(%rbx)
movq 0x60(%r12), %rax
cmpq %rbx, %rax
jne 0x9955
pushq $0x1
popq %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x9a40
cmpq %rbx, %rax
je 0x993d
movq %rax, 0x60(%r12)
leaq 0x58(%r12), %rcx
movq %rcx, %rax
movq (%rcx), %rcx
cmpq %rbx, %rcx
jne 0x995a
movq (%rbx), %rcx
movq %rcx, (%rax)
movq 0x68(%r12), %rax
movq %rax, (%rbx)
movq %rbx, 0x68(%r12)
orb $0x8, 0x9(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x99fc
movq 0x18(%rbx), %r15
cmpq $0x0, 0x98(%r15)
je 0x99b9
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa0d7
jmp 0x99a3
movb $0x3, 0x54(%r14)
movb $0x0, 0x56(%r14)
leaq 0x68(%r14), %rsi
pushq $-0x1
popq %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x9a40
leaq 0x58(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x9a40
addq $0xa0, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x9a40
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: separatetobefnz
static void separatetobefnz (global_State *g, int all) {
  GCObject *curr;
  GCObject **p = &g->finobj;
  GCObject **lastnext = findlast(&g->tobefnz);
  while ((curr = *p) != NULL) {  /* traverse all finalizable objects */
    lua_assert(tofinalize(curr));
    if (!(iswhite(curr) || all))  /* not being collected? */
      p = &curr->next;  /* don't bother with it */
    else {
      *p = curr->next;  /* remove 'curr' from 'finobj' list */
      curr->next = *lastnext;  /* link at the end of 'tobefnz' list */
      *lastnext = curr;
      lastnext = &curr->next;
    }
  }
}

// Assembly:
leaq 0x98(%rdi), %rcx
movq %rcx, %rax
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x9a03
addq $0x68, %rdi
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x9a3f
testl %esi, %esi
jne 0x9a26
movb 0x9(%rcx), %dl
andb $0x3, %dl
je 0x9a3a
movq (%rcx), %rdx
movq %rdx, (%rdi)
movq (%rax), %rdx
movq %rdx, (%rcx)
movq %rcx, (%rax)
movq %rcx, %rax
jmp 0x9a12
movq %rcx, %rdi
jmp 0x9a12
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdi), %rax
movb 0x54(%rax), %bpl
movl %ebp, %r13d
xorb $0x3, %r13b
andb $0x3, %bpl
movq (%r14), %r12
testq %r12, %r12
je 0x9b8b
subq $0x1, %rbx
jb 0x9b8e
movb 0x9(%r12), %al
movl %eax, %ecx
xorb $0x3, %cl
testb %r13b, %cl
je 0x9a9b
andb $-0x8, %al
orb %bpl, %al
movb %al, 0x9(%r12)
movq %r12, %r14
jmp 0x9a67
movq (%r12), %rax
movq %rax, (%r14)
movzbl 0x8(%r12), %eax
leal -0x4(%rax), %ecx
cmpl $0x10, %ecx
ja 0x9ad6
leaq 0x15a59(%rip), %rdx     # 0x1f510
movslq (%rdx,%rcx,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %r15, %rdi
movq %r12, %rsi
callq 0xe7f0
movzbl 0xb(%r12), %edx
jmp 0x9b75
cmpl $0x26, %eax
jne 0x9a67
movzbl 0xa(%r12), %edx
shll $0x4, %edx
addq $0x20, %rdx
jmp 0x9b79
movq %r15, %rdi
movq %r12, %rsi
callq 0xe11f
jmp 0x9a67
movb %bpl, 0x7(%rsp)
xorl %ebp, %ebp
movzbl 0xa(%r12), %eax
cmpq %rax, %rbp
jae 0x9b26
movq 0x20(%r12,%rbp,8), %rsi
testq %rsi, %rsi
je 0x9b21
movq %r15, %rdi
callq 0x98ad
incq %rbp
jmp 0x9b04
leaq 0x20(,%rax,8), %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0xab76
movb 0x7(%rsp), %bpl
jmp 0x9a67
movq 0x18(%r12), %rdx
addq $0x28, %rdx
jmp 0x9b79
movq %r15, %rdi
movq %r12, %rsi
callq 0xed39
jmp 0x9a67
movq %r15, %rdi
movq %r12, %rsi
callq 0x964f
jmp 0x9a67
movq 0x10(%r12), %rdx
addq $0x19, %rdx
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0xab76
jmp 0x9a67
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq 0x18(%rdi), %r14
movq 0x18(%r14), %rax
testq %rax, %rax
jle 0x9f50
movslq 0xb8(%r14), %r15
movl $0xc8, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %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 0x9f53
xorl %r15d, %r15d
cmpb $0x0, 0x57(%r14)
je 0x9f78
movq %rbx, %rdi
callq 0x9bc8
subq %rax, %r15
movb 0x55(%r14), %al
cmpq $-0x95f, %r15           # imm = 0xF6A1
jl 0x9f8c
cmpb $0x7, %al
jne 0x9f5a
jmp 0x9f90
movq %r14, %rdi
movq $-0x5dc0, %rsi          # imm = 0xA240
popq %rbx
popq %r14
popq %r15
jmp 0xdea8
cmpb $0x7, %al
jne 0x9f9a
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9fc2
movslq 0xb8(%r14), %rcx
movq %r15, %rax
cqto
idivq %rcx
imulq $0xc8, %rax, %rsi
movq %r14, %rdi
callq 0xdea8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xa005
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: setpause
static void setpause (global_State *g) {
  l_mem threshold, debt;
  l_mem estimate = g->GCestimate / PAUSEADJ;  /* adjust 'estimate' */
  lua_assert(estimate > 0);
  threshold = (g->gcpause < MAX_LMEM / estimate)  /* overflow? */
            ? estimate * g->gcpause  /* no overflow */
            : MAX_LMEM;  /* overflow; truncate to maximum */
  debt = gettotalbytes(g) - threshold;
  luaE_setdebt(g, debt);
}

// Assembly:
movq 0x18(%rdi), %rsi
movq 0x28(%rdi), %rax
pushq $0x64
popq %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movslq 0xb4(%rdi), %r9
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
movq %r8, %rax
xorl %edx, %edx
divq %rcx
imulq %r9, %rcx
cmpq %r9, %rax
cmovleq %r8, %rcx
addq 0x10(%rdi), %rsi
subq %rcx, %rsi
jmp 0xdea8
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
xorl %r12d, %r12d
pushq $0x1
popq %rbp
xorl %ebx, %ebx
cmpq $0x0, 0x98(%r15)
je 0xa044
movl 0xb0(%r15), %eax
cmpl %eax, %ebx
jae 0xa03f
movq %r14, %rdi
movl %ebp, %esi
callq 0xa0d7
incl %ebx
jmp 0xa01c
addl %eax, %eax
movl %eax, %r12d
movl %r12d, 0xb0(%r15)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa069
movb $0x1, 0x56(%rbx)
cmpb $0x1, 0x55(%rbx)
ja 0xa077
movq %r14, %rdi
callq 0xa0bc
movq %r14, %rdi
movl $0x80, %esi
callq 0x9ba0
movq %r14, %rdi
movl $0xffffff7f, %esi       # imm = 0xFFFFFF7F
callq 0x9ba0
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x9ba0
movq %r14, %rdi
movl $0x80, %esi
callq 0x9ba0
movb $0x0, 0x56(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9fc2
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: entersweep
static void entersweep (lua_State *L) {
  global_State *g = G(L);
  g->gcstate = GCSswpallgc;
  lua_assert(g->sweepgc == NULL);
  g->sweepgc = sweeplist(L, &g->allgc, 1);
}

// Assembly:
pushq %rbx
movq 0x18(%rdi), %rbx
movb $0x2, 0x55(%rbx)
leaq 0x58(%rbx), %rsi
pushq $0x1
popq %rdx
callq 0x9a40
movq %rax, 0x60(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa12e
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)
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0xf4b4
testq %rax, %rax
je 0xa1bd
movl 0x8(%rax), %ecx
andl $0xf, %ecx
cmpl $0x6, %ecx
jne 0xa1bd
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 0x70(%rip), %rsi        # 0xa20d
movq %rbx, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x8d39
movb %r15b, 0xcc(%rbx)
movb %r12b, 0x57(%r14)
testl %ebp, %ebp
je 0xa1bd
testl %eax, %eax
jne 0xa1ca
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %eax
jne 0xa203
movq 0x10(%rbx), %rax
movl -0x8(%rax), %ecx
andl $0xf, %ecx
cmpl $0x4, %ecx
jne 0xa1e8
movq -0x10(%rax), %rdx
addq $0x18, %rdx
jmp 0xa1ef
leaq 0x15399(%rip), %rdx     # 0x1f588
leaq 0x1539d(%rip), %rsi     # 0x1f593
movq %rbx, %rdi
xorl %eax, %eax
callq 0xb593
pushq $0x5
popq %rax
movq %rbx, %rdi
movl %eax, %esi
callq 0x80fc
// File: /workspace/github_c_makefile_star2_O2/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 0xa7a9
movq 0x18(%r14), %r15
pushq $0x55
popq %rdx
callq 0x9a40
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 0xa7b3
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_O2/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: traverseephemeron
static int traverseephemeron (global_State *g, Table *h) {
  int marked = 0;  /* true if an object is marked in this traversal */
  int hasclears = 0;  /* true if table has white keys */
  int hasww = 0;  /* true if table has entry "white-key -> white-value" */
  Node *n, *limit = gnodelast(h);
  unsigned int i;
  /* traverse array part */
  for (i = 0; i < h->sizearray; i++) {
    if (valiswhite(&h->array[i])) {
      marked = 1;
      reallymarkobject(g, gcvalue(&h->array[i]));
    }
  }
  /* traverse hash part */
  for (n = gnode(h, 0); n < limit; n++) {
    checkdeadkey(n);
    if (ttisnil(gval(n)))  /* entry is empty? */
      removeentry(n);  /* remove it */
    else if (iscleared(g, gkey(n))) {  /* key is not marked (yet)? */
      hasclears = 1;  /* table must be cleared */
      if (valiswhite(gval(n)))  /* value not marked yet? */
        hasww = 1;  /* white-white entry */
    }
    else if (valiswhite(gval(n))) {  /* value not marked yet? */
      marked = 1;
      reallymarkobject(g, gcvalue(gval(n)));  /* mark it now */
    }
  }
  /* link table into proper list */
  if (g->gcstate == GCSpropagate)
    linkgclist(h, g->grayagain);  /* must retraverse it in atomic phase */
  else if (hasww)  /* table has white->white entries? */
    linkgclist(h, g->ephemeron);  /* have to propagate again */
  else if (hasclears)  /* table has white keys? */
    linkgclist(h, g->allweak);  /* may have to clean white keys */
  return marked;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r12
movb 0xb(%rsi), %cl
pushq $0x1
popq %rbp
movl %ebp, %eax
shll %cl, %eax
cltq
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
pushq $0x8
popq %r15
movl $0x0, 0xc(%rsp)
movl 0xc(%rbx), %eax
cmpq %rax, %r13
jae 0xa890
movq 0x10(%rbx), %rax
testb $0x40, (%rax,%r15)
je 0xa887
movq -0x8(%rax,%r15), %rsi
testb $0x3, 0x9(%rsi)
je 0xa887
movq %r14, %rdi
callq 0x974c
movl %ebp, 0xc(%rsp)
incq %r13
addq $0x10, %r15
jmp 0xa85d
movq 0x10(%rsp), %rax
shlq $0x5, %rax
addq %rax, %r12
movq 0x18(%rbx), %r15
xorl %ebp, %ebp
xorl %r13d, %r13d
cmpq %r12, %r15
jae 0xa90c
cmpl $0x0, 0x8(%r15)
je 0xa8cf
leaq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0xa962
movl 0x8(%r15), %ecx
testl %eax, %eax
je 0xa8d9
testb $0x40, %cl
jne 0xa8f8
pushq $0x1
popq %rbp
jmp 0xa906
movq %r15, %rdi
callq 0xa94a
jmp 0xa906
testb $0x40, %cl
je 0xa906
movq (%r15), %rsi
testb $0x3, 0x9(%rsi)
je 0xa906
movq %r14, %rdi
callq 0x974c
pushq $0x1
popq %rax
movl %eax, 0xc(%rsp)
jmp 0xa906
movq (%r15), %rax
testb $0x3, 0x9(%rax)
pushq $0x1
popq %rbp
cmovnel %ebp, %r13d
addq $0x20, %r15
jmp 0xa8a5
cmpb $0x0, 0x55(%r14)
je 0xa928
movl $0x88, %eax
testl %r13d, %r13d
jne 0xa92b
movl $0x90, %eax
testl %ebp, %ebp
jne 0xa92b
jmp 0xa937
pushq $0x78
popq %rax
movq (%r14,%rax), %rcx
movq %rcx, 0x30(%rbx)
movq %rbx, (%r14,%rax)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa98b
andl $0xf, %eax
movq (%rsi), %rsi
movzbl 0x9(%rsi), %ecx
andl $0x3, %ecx
cmpl $0x4, %eax
jne 0xa989
testb %cl, %cl
je 0xa98b
callq 0x974c
jmp 0xa98b
movl %ecx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x88(%rbx)
movb $0x1, %bpl
movq %r14, %rsi
testq %rsi, %rsi
je 0xa9cf
movq 0x30(%rsi), %r14
movq %rbx, %rdi
callq 0xa825
movq %r14, %rsi
testl %eax, %eax
je 0xa9ab
movq %rbx, %rdi
callq 0xa752
xorl %ebp, %ebp
jmp 0xa9a8
testb $0x1, %bpl
je 0xa996
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %r15
cmpq 0x8(%rsp), %r14
je 0xaa8b
movb 0xb(%r14), %cl
pushq $0x1
popq %rax
shll %cl, %eax
movq 0x18(%r14), %r13
cltq
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
xorl %ebx, %ebx
movl 0xc(%r14), %eax
cmpq %rax, %rbx
jae 0xaa42
movq 0x10(%r14), %r12
leaq (%r12,%rbp), %rsi
movq %r15, %rdi
callq 0xa962
testl %eax, %eax
je 0xaa39
andl $0x0, 0x8(%r12,%rbp)
incq %rbx
addq $0x10, %rbp
jmp 0xaa16
movq 0x10(%rsp), %rax
shlq $0x5, %rax
addq %rax, %r13
movq 0x18(%r14), %r12
cmpq %r13, %r12
jae 0xaa82
cmpl $0x0, 0x8(%r12)
je 0xaa7c
movq %r15, %rdi
movq %r12, %rsi
callq 0xa962
testl %eax, %eax
je 0xaa7c
andl $0x0, 0x8(%r12)
movq %r12, %rdi
callq 0xa94a
addq $0x20, %r12
jmp 0xaa52
movq 0x30(%r14), %r14
jmp 0xa9f3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rbp
testq %rbx, %rbx
je 0xab04
movq 0x18(%rbx), %r15
movb 0xb(%rbx), %cl
movl %ebp, %eax
shll %cl, %eax
movslq %eax, %r13
shlq $0x5, %r13
addq %r15, %r13
addq $0x10, %r15
leaq -0x10(%r15), %r12
cmpq %r13, %r12
jae 0xaafe
cmpl $0x0, -0x8(%r15)
je 0xaaf8
movq %r14, %rdi
movq %r15, %rsi
callq 0xa962
testl %eax, %eax
je 0xaaf8
andl $0x0, -0x8(%r15)
movq %r12, %rdi
callq 0xa94a
addq $0x20, %r15
jmp 0xaacc
movq 0x30(%rbx), %rbx
jmp 0xaaae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lmem.c
// Function: luaM_growaux_
void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
                     int limit, const char *what) {
  void *newblock;
  int newsize;
  if (*size >= limit/2) {  /* cannot double it? */
    if (*size >= limit)  /* cannot grow even a little? */
      luaG_runerror(L, "too many %s (limit is %d)", what, limit);
    newsize = limit;  /* still have at least one free place */
  }
  else {
    newsize = (*size)*2;
    if (newsize < MINSIZEARRAY)
      newsize = MINSIZEARRAY;  /* minimum size */
  }
  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
  *size = newsize;  /* update only when everything else is OK */
  return newblock;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movslq (%rdx), %r10
pushq $0x2
popq %r11
movl %r8d, %eax
cltd
idivl %r11d
cmpl %eax, %r10d
jge 0xab3f
leal (%r10,%r10), %eax
cmpl $0x5, %eax
pushq $0x4
popq %r8
cmovgel %eax, %r8d
jmp 0xab44
cmpl %r8d, %r10d
jge 0xab62
imulq %rcx, %r10
movslq %r8d, %r14
imulq %r14, %rcx
movq %r10, %rdx
callq 0xab76
movl %r14d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x14a48(%rip), %rsi     # 0x1f5b1
movq %r9, %rdx
movl %r8d, %ecx
xorl %eax, %eax
callq 0x7930
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lmem.c
// Function: luaM_realloc_
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
  void *newblock;
  global_State *g = G(L);
  size_t realosize = (block) ? osize : 0;
  lua_assert((realosize == 0) == (block == NULL));
#if defined(HARDMEMTESTS)
  if (nsize > realosize && g->gcrunning)
    luaC_fullgc(L, 1);  /* force a GC whenever possible */
#endif
  newblock = (*g->frealloc)(g->ud, block, osize, nsize);
  if (newblock == NULL && nsize > 0) {
    lua_assert(nsize > realosize);  /* cannot fail when shrinking a block */
    if (g->version) {  /* is state fully built? */
      luaC_fullgc(L, 1);  /* try to free some memory... */
      newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
    }
    if (newblock == NULL)
      luaD_throw(L, LUA_ERRMEM);
  }
  lua_assert((nsize == 0) == (newblock == NULL));
  g->GCdebt = (g->GCdebt + nsize) - realosize;
  return newblock;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rdi), %r13
movq 0x8(%r13), %rdi
callq *(%r13)
testq %rbx, %rbx
je 0xabcc
testq %rax, %rax
jne 0xabcc
cmpq $0x0, 0xd0(%r13)
je 0xabe4
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0xa056
movq 0x8(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *(%r13)
testq %rax, %rax
je 0xabe4
testq %r15, %r15
cmoveq %r15, %r14
subq %r14, %rbx
addq %rbx, 0x18(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x4
popq %rsi
movq %r12, %rdi
callq 0x80fc
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_int2fb
int luaO_int2fb (unsigned int x) {
  int e = 0;  /* exponent */
  if (x < 8) return x;
  while (x >= (8 << 4)) {  /* coarse steps */
    x = (x + 0xf) >> 4;  /* x = ceil(x / 16) */
    e += 4;
  }
  while (x >= (8 << 1)) {  /* fine steps */
    x = (x + 1) >> 1;  /* x = ceil(x / 2) */
    e++;
  }
  return ((e+1) << 3) | (cast_int(x) - 8);
}

// Assembly:
movl %edi, %eax
cmpl $0x8, %edi
jb 0xac2b
pushq $0x8
popq %rcx
cmpl $0x7f, %eax
jbe 0xac21
addl $0xf, %eax
shrl $0x4, %eax
addl $0x20, %ecx
jmp 0xac0a
incl %eax
shrl %eax
addl $0x8, %ecx
cmpl $0x10, %eax
jae 0xac1a
addl $-0x8, %eax
orl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: intarith
static lua_Integer intarith (lua_State *L, int op, lua_Integer v1,
                                                   lua_Integer v2) {
  switch (op) {
    case LUA_OPADD: return intop(+, v1, v2);
    case LUA_OPSUB:return intop(-, v1, v2);
    case LUA_OPMUL:return intop(*, v1, v2);
    case LUA_OPMOD: return luaV_mod(L, v1, v2);
    case LUA_OPIDIV: return luaV_div(L, v1, v2);
    case LUA_OPBAND: return intop(&, v1, v2);
    case LUA_OPBOR: return intop(|, v1, v2);
    case LUA_OPBXOR: return intop(^, v1, v2);
    case LUA_OPSHL: return luaV_shiftl(v1, v2);
    case LUA_OPSHR: return luaV_shiftl(v1, -v2);
    case LUA_OPUNM: return intop(-, 0, v1);
    case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1);
    default: lua_assert(0); return 0;
  }
}

// Assembly:
xorl %eax, %eax
cmpl $0xd, %esi
ja 0xae75
movl %esi, %esi
leaq 0x147b4(%rip), %r8      # 0x1f600
movslq (%r8,%rsi,4), %rsi
addq %r8, %rsi
jmpq *%rsi
addq %rdx, %rcx
jmp 0xae7e
negq %rdx
jmp 0xae72
imulq %rdx, %rcx
jmp 0xae7e
andq %rdx, %rcx
jmp 0xae7e
notq %rdx
jmp 0xae72
subq %rcx, %rdx
movq %rdx, %rax
retq
orq %rdx, %rcx
jmp 0xae7e
xorq %rdx, %rcx
movq %rcx, %rax
retq
movq %rdx, %rsi
movq %rcx, %rdx
jmp 0x10a4d
movq %rdx, %rsi
movq %rcx, %rdx
jmp 0x10a0e
negq %rcx
movq %rdx, %rdi
movq %rcx, %rsi
jmp 0x10a8f