LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
cmpq $0x0, %rax
jbe 0xc4b0
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0xc4bf
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x1f490
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movsbl 0x2816c(%rip), %ecx     # 0x3463b
cmpl %ecx, %eax
jne 0xc509
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rsi
leaq 0x2815a(%rip), %rdx     # 0x34640
callq 0xc720
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rdx
callq 0x18b90
movq %rax, -0x18(%rbp)
jmp 0xc551
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rsi
leaq 0x2812b(%rip), %rdx     # 0x34647
callq 0xc720
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
addq $0x8, %rdx
movq -0x20(%rbp), %rcx
addq $0x20, %rcx
movq -0x20(%rbp), %rax
movq 0x58(%rax), %r8
movl -0x24(%rbp), %r9d
callq 0x11890
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd030
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16c30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movzbl 0x8(%rax), %ecx
orl $0x40, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xaa40
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldo.c
// Function: findpcall
static CallInfo *findpcall (lua_State *L) {
  CallInfo *ci;
  for (ci = L->ci; ci != NULL; ci = ci->previous) {  /* search for a pcall */
    if (ci->callstatus & CIST_YPCALL)
      return ci;
  }
  return NULL;  /* no pending pcall */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc635
movq -0x18(%rbp), %rax
movzbl 0x42(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xc625
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc63d
jmp 0xc627
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc604
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x42(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xc69c
movq -0x18(%rbp), %rax
movzbl 0x42(%rax), %ecx
andl $-0x11, %ecx
movb %cl, 0x42(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb0(%rax)
movq -0x18(%rbp), %rax
movswl 0x40(%rax), %eax
cmpl $-0x1, %eax
jne 0xc6d3
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xc6d3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rdx
callq *%rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movslq -0x1c(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
shlq $0x4, %rax
addq %rax, %rdx
movl -0x1c(%rbp), %ecx
callq 0xb680
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc779
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
callq 0x5170
cmpq $0x0, %rax
jne 0xc779
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x27ee8(%rip), %rsi     # 0x3464c
movb $0x0, %al
callq 0x114b0
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0xaa40
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc800
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
leaq -0x48(%rbp), %rsi
callq 0xc8d0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x48(%rbp), %rdx
callq 0xc900
movl -0x2c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldump.c
// Function: DumpHeader
static void DumpHeader (DumpState *D) {
  DumpLiteral(LUA_SIGNATURE, D);
  DumpByte(LUAC_VERSION, D);
  DumpByte(LUAC_FORMAT, D);
  DumpLiteral(LUAC_DATA, D);
  DumpByte(sizeof(int), D);
  DumpByte(sizeof(size_t), D);
  DumpByte(sizeof(Instruction), D);
  DumpByte(sizeof(lua_Integer), D);
  DumpByte(sizeof(lua_Number), D);
  DumpInteger(LUAC_INT, D);
  DumpNumber(LUAC_NUM, D);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x27e24(%rip), %rdi     # 0x3463b
movl $0x4, %esi
callq 0xc9f0
movsbl 0x27eac(%rip), %edi     # 0x346d4
subl $0x30, %edi
shll $0x4, %edi
movsbl 0x29931(%rip), %eax     # 0x36166
subl $0x30, %eax
addl %eax, %edi
movq -0x8(%rbp), %rsi
callq 0xc8d0
movq -0x8(%rbp), %rsi
xorl %edi, %edi
callq 0xc8d0
movq -0x8(%rbp), %rdx
leaq 0x27e7d(%rip), %rdi     # 0x346d6
movl $0x6, %esi
callq 0xc9f0
movq -0x8(%rbp), %rsi
movl $0x4, %edi
callq 0xc8d0
movq -0x8(%rbp), %rsi
movl $0x8, %edi
callq 0xc8d0
movq -0x8(%rbp), %rsi
movl $0x4, %edi
callq 0xc8d0
movq -0x8(%rbp), %rsi
movl $0x8, %edi
callq 0xc8d0
movq -0x8(%rbp), %rsi
movl $0x8, %edi
callq 0xc8d0
movq -0x8(%rbp), %rsi
movl $0x5678, %edi           # imm = 0x5678
callq 0xca50
movq -0x8(%rbp), %rdi
movsd 0x27db5(%rip), %xmm0    # 0x34678
callq 0xca80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldump.c
// Function: DumpFunction
static void DumpFunction (const Proto *f, TString *psource, DumpState *D) {
  if (D->strip || f->source == psource)
    DumpString(NULL, D);  /* no debug info or same source as its parent */
  else
    DumpString(f->source, D);
  DumpInt(f->linedefined, D);
  DumpInt(f->lastlinedefined, D);
  DumpByte(f->numparams, D);
  DumpByte(f->is_vararg, D);
  DumpByte(f->maxstacksize, D);
  DumpCode(f, D);
  DumpConstants(f, D);
  DumpUpvalues(f, D);
  DumpProtos(f, D);
  DumpDebug(f, D);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xc92c
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xc93b
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xcab0
jmp 0xc94c
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xcab0
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edi
movq -0x18(%rbp), %rsi
callq 0xcb70
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %edi
movq -0x18(%rbp), %rsi
callq 0xcb70
movq -0x8(%rbp), %rax
movzbl 0xa(%rax), %edi
movq -0x18(%rbp), %rsi
callq 0xc8d0
movq -0x8(%rbp), %rax
movzbl 0xb(%rax), %edi
movq -0x18(%rbp), %rsi
callq 0xc8d0
movq -0x8(%rbp), %rax
movzbl 0xc(%rax), %edi
movq -0x18(%rbp), %rsi
callq 0xc8d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xcba0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xcbf0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xcce0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xcd70
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xcde0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xcad7
movq -0x10(%rbp), %rsi
xorl %edi, %edi
callq 0xc8d0
jmp 0xcb6a
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x4, %eax
jne 0xcaf2
movq -0x8(%rbp), %rax
movzbl 0xb(%rax), %eax
movq %rax, -0x28(%rbp)
jmp 0xcafe
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
cmpq $0xff, -0x18(%rbp)
jae 0xcb31
movq -0x18(%rbp), %rax
movl %eax, %edi
movq -0x10(%rbp), %rsi
callq 0xc8d0
jmp 0xcb51
movq -0x10(%rbp), %rsi
movl $0xff, %edi
callq 0xc8d0
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0xc9f0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
shlq $0x0, %rsi
movq -0x10(%rbp), %rdx
callq 0xc9f0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldump.c
// Function: DumpConstants
static void DumpConstants (const Proto *f, DumpState *D) {
  int i;
  int n = f->sizek;
  DumpInt(n, D);
  for (i = 0; i < n; i++) {
    const TValue *o = &f->k[i];
    DumpByte(ttype(o), D);
    switch (ttype(o)) {
    case LUA_TNIL:
      break;
    case LUA_TBOOLEAN:
      DumpByte(bvalue(o), D);
      break;
    case LUA_TNUMFLT:
      DumpNumber(fltvalue(o), D);
      break;
    case LUA_TNUMINT:
      DumpInteger(ivalue(o), D);
      break;
    case LUA_TSHRSTR:
    case LUA_TLNGSTR:
      DumpString(tsvalue(o), D);
      break;
    default:
      lua_assert(0);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xcb70
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xccd8
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
andl $0x3f, %edi
movq -0x10(%rbp), %rsi
callq 0xc8d0
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x3f, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x14, %eax
ja 0xccc6
movq -0x28(%rbp), %rax
leaq 0x27a0d(%rip), %rcx     # 0x34680
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xccc8
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
callq 0xc8d0
jmp 0xccc8
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rdi
callq 0xca80
jmp 0xccc8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xca50
jmp 0xccc8
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xcab0
jmp 0xccc8
jmp 0xccc8
jmp 0xccca
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcc1d
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldump.c
// Function: DumpUpvalues
static void DumpUpvalues (const Proto *f, DumpState *D) {
  int i, n = f->sizeupvalues;
  DumpInt(n, D);
  for (i = 0; i < n; i++) {
    DumpByte(f->upvalues[i].instack, D);
    DumpByte(f->upvalues[i].idx, D);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xcb70
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xcd60
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x8(%rax), %edi
movq -0x10(%rbp), %rsi
callq 0xc8d0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl 0x9(%rax), %edi
movq -0x10(%rbp), %rsi
callq 0xc8d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcd0d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldump.c
// Function: DumpProtos
static void DumpProtos (const Proto *f, DumpState *D) {
  int i;
  int n = f->sizep;
  DumpInt(n, D);
  for (i = 0; i < n; i++)
    DumpFunction(f->p[i], f->source, D);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xcb70
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xcdd1
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0xc900
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcd9d
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldump.c
// Function: DumpDebug
static void DumpDebug (const Proto *f, DumpState *D) {
  int i, n;
  n = (D->strip) ? 0 : f->sizelineinfo;
  DumpInt(n, D);
  DumpVector(f->lineinfo, n, D);
  n = (D->strip) ? 0 : f->sizelocvars;
  DumpInt(n, D);
  for (i = 0; i < n; i++) {
    DumpString(f->locvars[i].varname, D);
    DumpInt(f->locvars[i].startpc, D);
    DumpInt(f->locvars[i].endpc, D);
  }
  n = (D->strip) ? 0 : f->sizeupvalues;
  DumpInt(n, D);
  for (i = 0; i < n; i++)
    DumpString(f->upvalues[i].name, D);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0xce01
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xce0b
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xcb70
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movslq -0x18(%rbp), %rsi
shlq $0x2, %rsi
movq -0x10(%rbp), %rdx
callq 0xc9f0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0xce47
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0xce51
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xcb70
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xceda
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xcab0
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rsi
callq 0xcb70
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %edi
movq -0x10(%rbp), %rsi
callq 0xcb70
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xce6a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0xceeb
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0xcef5
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xcb70
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xcf40
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xcab0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcf0e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltq
shlq $0x4, %rax
addl $0x30, %eax
movslq %eax, %rdx
movl $0x26, %esi
callq 0xd930
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0xa(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltq
shlq $0x3, %rax
addl $0x28, %eax
movslq %eax, %rdx
movl $0x6, %esi
callq 0xd930
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0xa(%rax)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0xd026
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, 0x20(%rax,%rcx,8)
jmp 0xd003
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0xa(%rcx), %ecx
cmpl %ecx, %eax
jge 0xd0b4
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x20, %ecx
movq %rdx, %rsi
callq 0x10130
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x1, 0x8(%rax)
movq -0x20(%rbp), %rcx
addq $0x10, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl $0x0, 0x8(%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, 0x20(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd047
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x31(%rbp)
je 0xd103
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
setae %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xd10c
jmp 0xd134
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xd126
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd1c9
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0xd0dc
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x20, %ecx
movq %rdx, %rsi
callq 0x10130
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xd1c1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0xa8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0xa8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x40(%rcx)
movb %al, -0x21(%rbp)
je 0xd219
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
setae %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xd225
jmp 0xd2ca
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd258
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x20, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
jmp 0xd2c5
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0xd2c1
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0xd2c1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd870
jmp 0xd2c3
jmp 0xd2c3
jmp 0xd2c5
jmp 0xd1f0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lfunc.c
// Function: luaF_newproto
Proto *luaF_newproto (lua_State *L) {
  GCObject *o = luaC_newobj(L, LUA_TPROTO, sizeof(Proto));
  Proto *f = gco2p(o);
  f->k = NULL;
  f->sizek = 0;
  f->p = NULL;
  f->sizep = 0;
  f->code = NULL;
  f->cache = NULL;
  f->sizecode = 0;
  f->lineinfo = NULL;
  f->sizelineinfo = 0;
  f->upvalues = NULL;
  f->sizeupvalues = 0;
  f->numparams = 0;
  f->is_vararg = 0;
  f->maxstacksize = 0;
  f->locvars = NULL;
  f->sizelocvars = 0;
  f->linedefined = 0;
  f->lastlinedefined = 0;
  f->source = NULL;
  return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x9, %esi
movl $0x78, %edx
callq 0xd930
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0xa(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0xb(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0xc(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rdx
shlq $0x2, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x20(%rax), %rdx
shlq $0x3, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x14(%rax), %rdx
shlq $0x4, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x1c(%rax), %rdx
shlq $0x2, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x24(%rax), %rdx
shlq $0x4, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rdx
shlq $0x4, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x78, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x24(%rdx), %ecx
movb %al, -0x1d(%rbp)
jge 0xd525
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x18(%rbp), %eax
setle %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xd52e
jmp 0xd58a
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0xc(%rcx), %eax
jge 0xd57a
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xd578
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
jmp 0xd592
jmp 0xd57a
jmp 0xd57c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd4f5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x55(%rax), %eax
cmpl $0x1, %eax
jg 0xd5dc
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd610
jmp 0xd600
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $-0x8, %eax
movq -0x20(%rbp), %rcx
movzbl 0x54(%rcx), %ecx
andl $0x3, %ecx
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x9(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_barrierback_
void luaC_barrierback_ (lua_State *L, Table *t) {
  global_State *g = G(L);
  lua_assert(isblack(t) && !isdead(g, t));
  black2gray(t);  /* make table gray (again) */
  linkgclist(t, g->grayagain);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %ecx
andl $0xfb, %ecx
movb %cl, 0x9(%rax)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x78(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_upvalbarrier_
void luaC_upvalbarrier_ (lua_State *L, UpVal *uv) {
  global_State *g = G(L);
  GCObject *o = gcvalue(uv->v);
  lua_assert(!upisopen(uv));  /* ensured by macro luaC_upvalbarrier */
  if (keepinvariant(g))
    markobject(g, o);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x55(%rax), %eax
cmpl $0x1, %eax
jg 0xd8c6
movq -0x20(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xd8c4
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd610
jmp 0xd8c6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %ecx
andl $0xfc, %ecx
movb %cl, 0x9(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xa0(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x10130
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x54(%rax), %eax
andl $0x3, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x9(%rax)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: luaC_upvdeccount
void luaC_upvdeccount (lua_State *L, UpVal *uv) {
  lua_assert(uv->refcount > 0);
  uv->refcount--;
  if (uv->refcount == 0 && !upisopen(uv))
    luaM_free(L, uv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xda15
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0xda15
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x20, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0xdaa6
cmpq $0x0, -0x18(%rbp)
jne 0xda5f
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0xda9c
movq -0x18(%rbp), %rax
movzbl 0xa(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xda77
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xda94
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0xf0(%rax), %rdx
movl $0x2, %esi
callq 0x185d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, %rax
jne 0xdaab
jmp 0xdb7b
movq -0x20(%rbp), %rax
movzbl 0x55(%rax), %ecx
movl $0x2, %eax
cmpl %ecx, %eax
jg 0xdb1c
movq -0x20(%rbp), %rax
movzbl 0x55(%rax), %eax
cmpl $0x5, %eax
jg 0xdb1c
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $-0x8, %eax
movq -0x20(%rbp), %rcx
movzbl 0x54(%rcx), %ecx
andl $0x3, %ecx
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jne 0xdb1a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rsi
callq 0xdb90
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x60(%rax)
jmp 0xdb1c
movq -0x20(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
je 0xdb44
jmp 0xdb37
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xdb28
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %ecx
orl $0x8, %ecx
movb %cl, 0x9(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: sweeptolive
static GCObject **sweeptolive (lua_State *L, GCObject **p) {
  GCObject **old = p;
  do {
    p = sweeplist(L, p, 1);
  } while (p == old);
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0xdd50
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xdba8
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xdc70
movq -0x8(%rbp), %rdi
callq 0xdd10
movq -0x10(%rbp), %rax
movb $0x3, 0x54(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x56(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x68, %rsi
movq $-0x1, %rdx
callq 0xdd50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x58, %rsi
movq $-0x1, %rdx
callq 0xdd50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xa0, %rsi
movq $-0x1, %rdx
callq 0xdd50
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x98, %rdi
callq 0xe480
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xdd01
movq -0x18(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0xdcd0
cmpl $0x0, -0xc(%rbp)
jne 0xdcd0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xdcff
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xdc9f
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x54(%rax), %eax
xorl $0x3, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x54(%rax), %eax
andl $0x3, %eax
movzbl %al, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x35(%rbp)
je 0xddb7
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
seta %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0xddc0
jmp 0xde20
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzbl 0x9(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
xorl $0x3, %eax
andl -0x24(%rbp), %eax
cmpl $0x0, %eax
jne 0xde01
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xe750
jmp 0xde1b
movl -0x34(%rbp), %eax
andl $-0x8, %eax
orl -0x28(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xdd8f
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xde32
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0xde3a
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe190
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x57(%rax)
jne 0xe0f4
movq -0x10(%rbp), %rdi
movq $-0x5dc0, %rsi          # imm = 0xA240
callq 0x158c0
jmp 0xe186
jmp 0xe0f6
movq -0x8(%rbp), %rdi
callq 0xdea0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $-0x960, -0x18(%rbp)    # imm = 0xF6A0
movb %al, -0x21(%rbp)
jle 0xe132
movq -0x10(%rbp), %rax
movzbl 0x55(%rax), %eax
cmpl $0x7, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xe0f6
movq -0x10(%rbp), %rax
movzbl 0x55(%rax), %eax
cmpl $0x7, %eax
jne 0xe151
movq -0x10(%rbp), %rdi
callq 0xe240
jmp 0xe186
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0xb8(%rcx), %rcx
cqto
idivq %rcx
imulq $0xc8, %rax, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x158c0
movq -0x8(%rbp), %rdi
callq 0xe2f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lgc.c
// Function: getdebt
static l_mem getdebt (global_State *g) {
  l_mem debt = g->GCdebt;
  int stepmul = g->gcstepmul;
  if (debt <= 0) return 0;  /* minimal debt */
  else {
    debt = (debt / STEPMULADJ) + 1;
    debt = (debt < MAX_LMEM / stepmul) ? debt * stepmul : MAX_LMEM;
    return debt;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xb8(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jg 0xe1c2
movq $0x0, -0x8(%rbp)
jmp 0xe231
movq -0x18(%rbp), %rax
movl $0xc8, %ecx
cqto
idivq %rcx
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0x1c(%rbp), %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cqto
idivq %rcx
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jge 0xe211
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0xe221
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x30(%rbp)
jmp 0xe221
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)