LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: cond
static int cond (LexState *ls) {
  /* cond -> exp */
  expdesc v;
  expr(ls, &v);  /* read condition */
  if (v.k == VNIL) v.k = VFALSE;  /* 'falses' are all equal here */
  luaK_goiftrue(ls->fs, &v);
  return v.f;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0xd37c
cmpl $0x1, (%r14)
jne 0xe6d5
movl $0x3, (%rsp)
movq 0x30(%rbx), %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x16183
movl 0x14(%rbx), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: forbody
static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
  /* forbody -> DO block */
  BlockCnt bl;
  FuncState *fs = ls->fs;
  int prep, endfor;
  adjustlocalvars(ls, 3);  /* control variables */
  checknext(ls, TK_DO);
  prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
  enterblock(fs, &bl, 0);  /* scope for declared variables */
  adjustlocalvars(ls, nvars);
  luaK_reserveregs(fs, nvars);
  block(ls);
  leaveblock(fs);  /* end of scope for declared variables */
  luaK_patchtohere(fs, prep);
  if (isnum)  /* numeric for? */
    endfor = luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP);
  else {  /* generic for */
    luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars);
    luaK_fixline(fs, line);
    endfor = luaK_codeAsBx(fs, OP_TFORLOOP, base + 2, NO_JUMP);
  }
  luaK_patchlist(fs, endfor, prep + 1);
  luaK_fixline(fs, line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r13d
movl %ecx, %r12d
movl %edx, 0xc(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %r14
movl $0x3, %esi
callq 0xdf0d
movq %rbx, %rdi
movl $0x103, %esi            # imm = 0x103
callq 0xd1f5
movq %r14, %rdi
testl %r13d, %r13d
je 0xe771
movl $0x28, %esi
movl %ebp, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x157bc
jmp 0xe776
callq 0x1577c
movl %eax, %r15d
xorl %eax, %eax
leaq 0x10(%rsp), %rcx
movb %al, 0x12(%rcx)
movb 0x3a(%r14), %dl
movb %dl, 0x10(%rcx)
movq 0x10(%r14), %rdx
movq 0x58(%rdx), %rdx
movl 0x28(%rdx), %esi
movl %esi, 0x8(%rcx)
movl 0x18(%rdx), %edx
movl %edx, 0xc(%rcx)
movb %al, 0x11(%rcx)
movq 0x18(%r14), %rax
movq %rax, (%rcx)
movq %rcx, 0x18(%r14)
movq %rbx, %rdi
movl %r12d, %esi
callq 0xdf0d
movq %r14, %rdi
movl %r12d, %esi
callq 0x15a12
movq %rbx, %rdi
callq 0xcf39
movq %r14, %rdi
callq 0xd204
movq %r14, %rdi
movl %r15d, %esi
callq 0x157e8
movq %r14, %rdi
testl %r13d, %r13d
je 0xe7fc
movl $0x27, %esi
movl %ebp, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x157bc
movl 0xc(%rsp), %ebx
jmp 0xe832
movl $0x29, %esi
movl %ebp, %edx
xorl %ecx, %ecx
movl %r12d, %r8d
callq 0x156de
movq %r14, %rdi
movl 0xc(%rsp), %ebx
movl %ebx, %esi
callq 0x1697a
addl $0x2, %ebp
movq %r14, %rdi
movl $0x2a, %esi
movl %ebp, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x157bc
incl %r15d
movq %r14, %rdi
movl %eax, %esi
movl %r15d, %edx
callq 0x157f9
movq %r14, %rdi
movl %ebx, %esi
callq 0x1697a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: adjust_assign
static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
  FuncState *fs = ls->fs;
  int extra = nvars - nexps;
  if (hasmultret(e->k)) {
    extra++;  /* includes call itself */
    if (extra < 0) extra = 0;
    luaK_setreturns(fs, e, extra);  /* last exp. provides the difference */
    if (extra > 1) luaK_reserveregs(fs, extra-1);
  }
  else {
    if (e->k != VVOID) luaK_exp2nextreg(fs, e);  /* close last expression */
    if (extra > 0) {
      int reg = fs->freereg;
      luaK_reserveregs(fs, extra);
      luaK_nil(fs, reg, extra);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq 0x30(%rdi), %rbx
subl %edx, %ebp
movl (%rcx), %eax
leal -0xd(%rax), %edx
cmpl $0x2, %edx
jae 0xe89f
testl %ebp, %ebp
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmovnsl %ebp, %r14d
leal 0x1(%r14), %edx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x15bc7
testl %ebp, %ebp
jle 0xe8d2
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x15a12
testl %eax, %eax
je 0xe8ae
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x15d1e
testl %ebp, %ebp
jle 0xe8d2
movzbl 0x3c(%rbx), %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x15a12
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x15614
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: luaE_setdebt
void luaE_setdebt (global_State *g, l_mem debt) {
  l_mem tb = gettotalbytes(g);
  lua_assert(tb > 0);
  if (debt < tb - MAX_LMEM)
    debt = tb - MAX_LMEM;  /* will make 'totalbytes == MAX_LMEM' */
  g->totalbytes = tb - debt;
  g->GCdebt = debt;
}

// Assembly:
movq 0x18(%rdi), %rax
addq 0x10(%rdi), %rax
movabsq $-0x7fffffffffffffff, %rcx # imm = 0x8000000000000001
addq %rax, %rcx
cmpq %rsi, %rcx
cmovleq %rsi, %rcx
subq %rcx, %rax
movq %rax, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: luaE_extendCI
CallInfo *luaE_extendCI (lua_State *L) {
  CallInfo *ci = luaM_new(L, CallInfo);
  lua_assert(L->ci->next == NULL);
  L->ci->next = ci;
  ci->previous = L->ci;
  ci->next = NULL;
  L->nci++;
  return ci;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x48, %ecx
xorl %esi, %esi
xorl %edx, %edx
callq 0xb3eb
movq 0x20(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
incw 0xa(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: luaE_freeCI
void luaE_freeCI (lua_State *L) {
  CallInfo *ci = L->ci;
  CallInfo *next = ci->next;
  ci->next = NULL;
  while ((ci = next) != NULL) {
    next = ci->next;
    luaM_free(L, ci);
    L->nci--;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rax
movq 0x18(%rax), %rsi
movq $0x0, 0x18(%rax)
testq %rsi, %rsi
je 0xeb33
movq %rdi, %rbx
movq 0x18(%rsi), %r14
movl $0x48, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xb3eb
decw 0xa(%rbx)
movq %r14, %rsi
testq %r14, %r14
jne 0xeb14
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: luaE_shrinkCI
void luaE_shrinkCI (lua_State *L) {
  CallInfo *ci = L->ci;
  CallInfo *next2;  /* next's next */
  /* while there are two nexts */
  while (ci->next != NULL && (next2 = ci->next->next) != NULL) {
    luaM_free(L, ci->next);  /* free next */
    L->nci--;
    ci->next = next2;  /* remove 'next' from the list */
    next2->previous = ci;
    ci = next2;  /* keep next's next */
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r14
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0xeb8d
movq %rdi, %rbx
leaq 0x18(%r14), %r15
movq 0x18(%rsi), %r12
testq %r12, %r12
je 0xeb8d
movl $0x48, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xb3eb
decw 0xa(%rbx)
movq %r12, (%r15)
movq %r14, 0x10(%r12)
leaq 0x18(%r12), %r15
movq 0x18(%r12), %rsi
movq %r12, %r14
testq %rsi, %rsi
jne 0xeb57
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: lua_newthread
LUA_API lua_State *lua_newthread (lua_State *L) {
  global_State *g = G(L);
  lua_State *L1;
  lua_lock(L);
  luaC_checkGC(L);
  /* create new thread */
  L1 = &cast(LX *, luaM_newobject(L, LUA_TTHREAD, sizeof(LX)))->l;
  L1->marked = luaC_white(g);
  L1->tt = LUA_TTHREAD;
  /* link it on list 'allgc' */
  L1->next = g->allgc;
  g->allgc = obj2gco(L1);
  /* anchor it on L stack */
  setthvalue(L, L->top, L1);
  api_incr_top(L);
  preinit_thread(L1, g);
  L1->hookmask = L->hookmask;
  L1->basehookcount = L->basehookcount;
  L1->hook = L->hook;
  resethookcount(L1);
  /* initialize L1 extra space */
  memcpy(lua_getextraspace(L1), lua_getextraspace(g->mainthread),
         LUA_EXTRASPACE);
  luai_userstatethread(L, L1);
  stack_init(L1, L);  /* init stack */
  lua_unlock(L);
  return L1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r15
cmpq $0x0, 0x18(%r15)
jle 0xebb7
movq %rbx, %rdi
callq 0xa65d
xorl %r12d, %r12d
movl $0x8, %edx
movl $0xd8, %ecx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb3eb
leaq 0x8(%rax), %r14
movb 0x54(%r15), %cl
andb $0x3, %cl
movb %cl, 0x11(%rax)
movb $0x8, 0x10(%rax)
movq 0x58(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %r14, 0x58(%r15)
movq 0x10(%rbx), %rcx
movq %r14, (%rcx)
movl $0x48, 0x8(%rcx)
addq $0x10, 0x10(%rbx)
movq %r15, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rax)
movq %r12, 0x28(%rax)
movw $0x0, 0x12(%rax)
movl $0x0, 0xc0(%rax)
movq %r14, 0x58(%rax)
movq %r12, 0x60(%rax)
movq %r12, 0xb0(%rax)
movq %r12, 0xc4(%rax)
movb $0x1, 0xd4(%rax)
movq $0x1, 0xcc(%rax)
movb $0x0, 0x14(%rax)
movq %r12, 0xb8(%rax)
movl 0xc8(%rbx), %ecx
movl %ecx, 0xd0(%rax)
movl 0xbc(%rbx), %ecx
movl %ecx, 0xc4(%rax)
movq 0xa8(%rbx), %rdx
movq %rdx, 0xb0(%rax)
movl %ecx, 0xc8(%rax)
movq 0xc8(%r15), %rcx
movq -0x8(%rcx), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeca5
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: stack_init
static void stack_init (lua_State *L1, lua_State *L) {
  int i; CallInfo *ci;
  /* initialize stack array */
  L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, TValue);
  L1->stacksize = BASIC_STACK_SIZE;
  for (i = 0; i < BASIC_STACK_SIZE; i++)
    setnilvalue(L1->stack + i);  /* erase new stack */
  L1->top = L1->stack;
  L1->stack_last = L1->stack + L1->stacksize - EXTRA_STACK;
  /* initialize first ci */
  ci = &L1->base_ci;
  ci->next = ci->previous = NULL;
  ci->callstatus = 0;
  ci->func = L1->top;
  setnilvalue(L1->top++);  /* 'function' entry for this 'ci' */
  ci->top = L1->top + LUA_MINSTACK;
  L1->ci = ci;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x280, %ecx            # imm = 0x280
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb3eb
movq %rax, 0x38(%rbx)
movl $0x28, 0xb8(%rbx)
movl $0x8, %ecx
movl $0x0, (%rax,%rcx)
addq $0x10, %rcx
cmpq $0x288, %rcx            # imm = 0x288
jne 0xeccd
leaq 0x230(%rax), %rcx
movq %rcx, 0x30(%rbx)
leaq 0x60(%rbx), %rcx
movb $0x0, 0xa2(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
movq %rax, 0x60(%rbx)
leaq 0x10(%rax), %rdx
movq %rdx, 0x10(%rbx)
movl $0x0, 0x8(%rax)
addq $0x150, %rax            # imm = 0x150
movq %rax, 0x68(%rbx)
movq %rcx, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: luaE_freethread
void luaE_freethread (lua_State *L, lua_State *L1) {
  LX *l = fromstate(L1);
  luaF_close(L1, L1->stack);  /* close all upvalues for this thread */
  lua_assert(L1->openupval == NULL);
  luai_userstatefree(L, L1);
  freestack(L1);
  luaM_free(L, l);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x8(%rsi), %r15
movq 0x38(%rsi), %rsi
movq %rbx, %rdi
callq 0x9c59
movq %rbx, %rdi
callq 0xed5b
movl $0xd8, %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xb3eb
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: freestack
static void freestack (lua_State *L) {
  if (L->stack == NULL)
    return;  /* stack not completely built yet */
  L->ci = &L->base_ci;  /* free the entire 'ci' list */
  luaE_freeCI(L);
  lua_assert(L->nci == 0);
  luaM_freearray(L, L->stack, L->stacksize);  /* free stack array */
}

// Assembly:
cmpq $0x0, 0x38(%rdi)
je 0xed8d
pushq %rbx
movq %rdi, %rbx
leaq 0x60(%rdi), %rax
movq %rax, 0x20(%rdi)
callq 0xeaf8
movq 0x38(%rbx), %rsi
movslq 0xb8(%rbx), %rdx
shlq $0x4, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
popq %rbx
jmp 0xb3eb
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: f_luaopen
static void f_luaopen (lua_State *L, void *ud) {
  global_State *g = G(L);
  UNUSED(ud);
  stack_init(L, L);  /* init stack */
  init_registry(L, g);
  luaS_init(L);
  luaT_init(L);
  luaX_init(L);
  g->gcrunning = 1;  /* allow gc */
  g->version = lua_version(NULL);
  luai_userstateopen(L);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r12
movq %rdi, %rsi
callq 0xeca5
movq %rbx, %rdi
callq 0xfa85
movq %rax, %r14
movq %rax, 0x40(%r12)
movl $0x45, %ebp
movl %ebp, 0x48(%r12)
movq %rbx, %rdi
movq %rax, %rsi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0xf78b
movq %rsp, %r15
movq %rbx, (%r15)
movl $0x48, 0x8(%r15)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xf9cb
movq %rbx, %rdi
callq 0xfa85
movq %rax, (%r15)
movl %ebp, 0x8(%r15)
movl $0x2, %edx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xf9cb
movq %rbx, %rdi
callq 0xf282
movq %rbx, %rdi
callq 0x10288
movq %rbx, %rdi
callq 0x16cd0
movb $0x1, 0x57(%r12)
xorl %edi, %edi
callq 0x5d03
movq %rax, 0xd0(%r12)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: close_state
static void close_state (lua_State *L) {
  global_State *g = G(L);
  luaF_close(L, L->stack);  /* close all upvalues for this thread */
  luaC_freeallobjects(L);  /* collect all objects */
  if (g->version)  /* closing a fully built state? */
    luai_userstateclose(L);
  luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
  freestack(L);
  lua_assert(gettotalbytes(g) == sizeof(LG));
  (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0);  /* free main block */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq 0x38(%rdi), %rsi
callq 0x9c59
movq %rbx, %rdi
callq 0xa048
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rsi
movslq 0x3c(%rax), %rdx
shlq $0x3, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xb3eb
movq %rbx, %rdi
callq 0xed5b
movq (%r14), %rax
movq 0x8(%r14), %rdi
addq $-0x8, %rbx
movl $0x610, %edx            # imm = 0x610
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_eqlngstr
int luaS_eqlngstr (TString *a, TString *b) {
  size_t len = a->u.lnglen;
  lua_assert(a->tt == LUA_TLNGSTR && b->tt == LUA_TLNGSTR);
  return (a == b) ||  /* same instance or... */
    ((len == b->u.lnglen) &&  /* equal length and ... */
     (memcmp(getstr(a), getstr(b), len) == 0));  /* equal contents */
}

// Assembly:
cmpq %rsi, %rdi
je 0xf0d1
movq 0x10(%rdi), %rdx
xorl %eax, %eax
cmpq 0x10(%rsi), %rdx
jne 0xf0d0
pushq %rax
addq $0x18, %rdi
addq $0x18, %rsi
callq 0x5390
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addq $0x8, %rsp
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_hash
unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) {
  unsigned int h = seed ^ cast(unsigned int, l);
  size_t step = (l >> LUAI_HASHLIMIT) + 1;
  for (; l >= step; l -= step)
    h ^= ((h<<5) + (h>>2) + cast_byte(str[l - 1]));
  return h;
}

// Assembly:
movl %edx, %eax
xorl %esi, %eax
testq %rsi, %rsi
je 0xf112
movq %rsi, %rcx
shrq $0x5, %rcx
movq %rcx, %rdx
notq %rdx
movl %eax, %r8d
shll $0x5, %r8d
movl %eax, %r9d
shrl $0x2, %r9d
addl %r8d, %r9d
movzbl -0x1(%rdi,%rsi), %r8d
addl %r9d, %r8d
xorl %r8d, %eax
addq %rdx, %rsi
cmpq %rcx, %rsi
ja 0xf0ed
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_hashlongstr
unsigned int luaS_hashlongstr (TString *ts) {
  lua_assert(ts->tt == LUA_TLNGSTR);
  if (ts->extra == 0) {  /* no hash? */
    ts->hash = luaS_hash(getstr(ts), ts->u.lnglen, ts->hash);
    ts->extra = 1;  /* now it has its hash */
  }
  return ts->hash;
}

// Assembly:
cmpb $0x0, 0xa(%rdi)
jne 0xf160
movq 0x10(%rdi), %rcx
movl 0xc(%rdi), %eax
xorl %ecx, %eax
testq %rcx, %rcx
je 0xf159
movq %rcx, %rdx
shrq $0x5, %rdx
movq %rdx, %rsi
notq %rsi
movl %eax, %r8d
shll $0x5, %r8d
movl %eax, %r9d
shrl $0x2, %r9d
addl %r8d, %r9d
movzbl 0x17(%rdi,%rcx), %r8d
addl %r9d, %r8d
xorl %r8d, %eax
addq %rsi, %rcx
cmpq %rdx, %rcx
ja 0xf134
movl %eax, 0xc(%rdi)
movb $0x1, 0xa(%rdi)
movl 0xc(%rdi), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_resize
void luaS_resize (lua_State *L, int newsize) {
  int i;
  stringtable *tb = &G(L)->strt;
  if (newsize > tb->size) {  /* grow table if needed */
    luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
    for (i = tb->size; i < newsize; i++)
      tb->hash[i] = NULL;
  }
  for (i = 0; i < tb->size; i++) {  /* rehash */
    TString *p = tb->hash[i];
    tb->hash[i] = NULL;
    while (p) {  /* for each node in the list */
      TString *hnext = p->u.hnext;  /* save next */
      unsigned int h = lmod(p->hash, newsize);  /* new position */
      p->u.hnext = tb->hash[h];  /* chain it */
      tb->hash[h] = p;
      p = hnext;
    }
  }
  if (newsize < tb->size) {  /* shrink table if needed */
    /* vanishing slice should be empty */
    lua_assert(tb->hash[newsize] == NULL && tb->hash[tb->size - 1] == NULL);
    luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
  }
  tb->size = newsize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %r12
movslq 0x3c(%r12), %rdx
movslq %esi, %r15
cmpl %esi, %edx
jge 0xf1be
movq 0x30(%r12), %rsi
shlq $0x3, %rdx
leaq (,%r15,8), %rcx
movq %r14, %rdi
callq 0xb3eb
movq %rax, 0x30(%r12)
movslq 0x3c(%r12), %rax
cmpl %r15d, %eax
jge 0xf1be
movq 0x30(%r12), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0xf1a9
movl 0x3c(%r12), %edx
testl %edx, %edx
jle 0xf216
leal -0x1(%rbx), %eax
xorl %ecx, %ecx
movq 0x30(%r12), %rsi
movq (%rsi,%rcx,8), %rdx
movq $0x0, (%rsi,%rcx,8)
testq %rdx, %rdx
je 0xf209
movq 0x10(%rdx), %rsi
movl 0xc(%rdx), %edi
andl %eax, %edi
movq 0x30(%r12), %r8
movq (%r8,%rdi,8), %r8
movq %r8, 0x10(%rdx)
movq 0x30(%r12), %r8
movq %rdx, (%r8,%rdi,8)
movq %rsi, %rdx
testq %rsi, %rsi
jne 0xf1e2
incq %rcx
movslq 0x3c(%r12), %rdx
cmpq %rdx, %rcx
jl 0xf1cc
cmpl %ebx, %edx
jle 0xf23a
movq 0x30(%r12), %rsi
movslq %edx, %rdx
shlq $0x3, %rdx
shlq $0x3, %r15
movq %r14, %rdi
movq %r15, %rcx
callq 0xb3eb
movq %rax, 0x30(%r12)
movl %ebx, 0x3c(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_clearcache
void luaS_clearcache (global_State *g) {
  int i, j;
  for (i = 0; i < STRCACHE_N; i++)
    for (j = 0; j < STRCACHE_M; j++) {
    if (iswhite(g->strcache[i][j]))  /* will entry be collected? */
      g->strcache[i][j] = g->memerrmsg;  /* replace it with something fixed */
    }
}

// Assembly:
leaq 0x1e8(%rdi), %rax
xorl %ecx, %ecx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
testb $0x3, 0x9(%rsi)
je 0xf26b
movq 0xd8(%rdi), %rsi
movq %rsi, (%rax,%rdx,8)
incq %rdx
cmpq $0x1, %rdx
je 0xf256
incq %rcx
addq $0x10, %rax
cmpq $0x35, %rcx
jne 0xf254
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_init
void luaS_init (lua_State *L) {
  global_State *g = G(L);
  int i, j;
  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
  /* pre-create memory-error message */
  g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
  luaC_fix(L, obj2gco(g->memerrmsg));  /* it should never be collected */
  for (i = 0; i < STRCACHE_N; i++)  /* fill cache with valid strings */
    for (j = 0; j < STRCACHE_M; j++)
      g->strcache[i][j] = g->memerrmsg;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movl $0x80, %esi
callq 0xf164
leaq 0x1296d(%rip), %rsi     # 0x21c0b
movl $0x11, %edx
movq %rbx, %rdi
callq 0xf2f1
movq %rax, 0xd8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9f16
movq 0xd8(%r14), %rax
addq $0x1e8, %r14            # imm = 0x1E8
xorl %ecx, %ecx
xorl %edx, %edx
movq %rax, (%r14,%rdx,8)
incq %rdx
cmpq $0x1, %rdx
je 0xf2cf
incq %rcx
addq $0x10, %r14
cmpq $0x35, %rcx
jne 0xf2cd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_newlstr
TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
  if (l <= LUAI_MAXSHORTLEN)  /* short string? */
    return internshrstr(L, str, l);
  else {
    TString *ts;
    if (l >= (MAX_SIZE - sizeof(TString))/sizeof(char))
      luaM_toobig(L);
    ts = luaS_createlngstrobj(L, l);
    memcpy(getstr(ts), str, l * sizeof(char));
    return ts;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
cmpq $0x28, %rdx
ja 0xf39e
movq %rdi, (%rsp)
movq 0x18(%rdi), %r8
movl 0x50(%r8), %ebp
xorl %ebx, %ebp
testq %rbx, %rbx
je 0xf350
movq %rbx, %rax
shrq $0x5, %rax
movq %rax, %rcx
notq %rcx
movq %rbx, %rdx
movl %ebp, %esi
shll $0x5, %esi
movl %ebp, %edi
shrl $0x2, %edi
addl %esi, %edi
movzbl -0x1(%r14,%rdx), %esi
addl %edi, %esi
xorl %esi, %ebp
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0xf332
movq 0x30(%r8), %rcx
movq %r8, 0x8(%rsp)
movl 0x3c(%r8), %r13d
leal -0x1(%r13), %eax
andl %ebp, %eax
movslq %eax, %r15
movq %rcx, 0x10(%rsp)
movq (%rcx,%r15,8), %r12
testq %r12, %r12
je 0xf3f2
movzbl 0xb(%r12), %eax
cmpq %rbx, %rax
jne 0xf397
leaq 0x18(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5390
testl %eax, %eax
je 0xf440
movq 0x10(%r12), %r12
jmp 0xf36f
movabsq $0x7fffffffffffffe7, %rax # imm = 0x7FFFFFFFFFFFFFE7
cmpq %rax, %rbx
jae 0xf4bf
movq 0x18(%rdi), %rax
movl 0x50(%rax), %ebp
leaq 0x19(%rbx), %rdx
movl $0x14, %esi
callq 0x9f37
movq %rax, %r12
movl %ebp, 0xc(%rax)
xorl %eax, %eax
movb %al, 0xa(%r12)
leaq 0x18(%r12), %rdi
movb %al, 0x18(%r12,%rbx)
movq %rbx, 0x10(%r12)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5320
jmp 0xf4ad
movq 0x10(%rsp), %rax
leaq (%rax,%r15,8), %r15
cmpl $0x3fffffff, %r13d      # imm = 0x3FFFFFFF
jg 0xf45d
movq 0x8(%rsp), %r12
cmpl %r13d, 0x38(%r12)
movq (%rsp), %rdi
jl 0xf466
addl %r13d, %r13d
movq (%rsp), %rdi
movl %r13d, %esi
callq 0xf164
movq (%rsp), %rdi
movslq 0x3c(%r12), %rax
decq %rax
movslq %ebp, %r15
andq %rax, %r15
shlq $0x3, %r15
addq 0x30(%r12), %r15
jmp 0xf466
movb 0x9(%r12), %al
xorb $0x3, %al
movq 0x8(%rsp), %rcx
movb 0x54(%rcx), %cl
xorb $0x3, %cl
testb %al, %cl
jne 0xf4ad
movb %al, 0x9(%r12)
jmp 0xf4ad
movq 0x8(%rsp), %r12
movq (%rsp), %rdi
leaq 0x19(%rbx), %rdx
movl $0x4, %esi
callq 0x9f37
movq %r12, %r13
movq %rax, %r12
movl %ebp, 0xc(%rax)
xorl %eax, %eax
movb %al, 0xa(%r12)
leaq 0x18(%r12), %rdi
movb %al, 0x18(%r12,%rbx)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5320
movb %bl, 0xb(%r12)
movq (%r15), %rax
movq %rax, 0x10(%r12)
movq %r12, (%r15)
incl 0x38(%r13)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb46c
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_remove
void luaS_remove (lua_State *L, TString *ts) {
  stringtable *tb = &G(L)->strt;
  TString **p = &tb->hash[lmod(ts->hash, tb->size)];
  while (*p != ts)  /* find previous element */
    p = &(*p)->u.hnext;
  *p = (*p)->u.hnext;  /* remove element from its list */
  tb->nuse--;
}

// Assembly:
movq 0x18(%rdi), %rax
movslq 0xc(%rsi), %rdx
movslq 0x3c(%rax), %rcx
decq %rcx
andq %rdx, %rcx
shlq $0x3, %rcx
addq 0x30(%rax), %rcx
movq %rcx, %rdx
movq (%rcx), %rdi
leaq 0x10(%rdi), %rcx
cmpq %rsi, %rdi
jne 0xf510
movq 0x10(%rdi), %rcx
movq %rcx, (%rdx)
decl 0x38(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_new
TString *luaS_new (lua_State *L, const char *str) {
  unsigned int i = point2uint(str) % STRCACHE_N;  /* hash */
  int j;
  TString **p = G(L)->strcache[i];
  for (j = 0; j < STRCACHE_M; j++) {
    if (strcmp(str, getstr(p[j])) == 0)  /* hit? */
      return p[j];  /* that is it */
  }
  /* normal route */
  for (j = STRCACHE_M - 1; j > 0; j--)
    p[j] = p[j - 1];  /* move out last element */
  /* new element is first in the list */
  p[0] = luaS_newlstr(L, str, strlen(str));
  return p[0];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %ebx, %eax
imulq $0x3521cfb3, %rax, %rax # imm = 0x3521CFB3
shrq $0x20, %rax
movl %ebx, %ecx
subl %eax, %ecx
shrl %ecx
addl %eax, %ecx
shrl $0x5, %ecx
imull $0x35, %ecx, %eax
movl %ebx, %ecx
subl %eax, %ecx
movq 0x18(%rdi), %rax
shll $0x4, %ecx
leaq (%rax,%rcx), %r12
addq $0x1e8, %r12            # imm = 0x1E8
xorl %r13d, %r13d
movq (%r12,%r13,8), %r15
leaq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x5290
testl %eax, %eax
je 0xf5b0
incq %r13
cmpq $0x1, %r13
je 0xf56d
movq (%r12), %rax
movq %rax, 0x8(%r12)
movq %rbx, %rdi
callq 0x5150
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xf2f1
movq %rax, %r15
movq %rax, (%r12)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: luaS_newudata
Udata *luaS_newudata (lua_State *L, size_t s) {
  Udata *u;
  GCObject *o;
  if (s > MAX_SIZE - sizeof(Udata))
    luaM_toobig(L);
  o = luaC_newobj(L, LUA_TUSERDATA, sizeludata(s));
  u = gco2u(o);
  u->len = s;
  u->metatable = NULL;
  setuservalue(L, u, luaO_nilobject);
  return u;
}

// Assembly:
pushq %rbx
movabsq $0x7fffffffffffffd8, %rax # imm = 0x7FFFFFFFFFFFFFD8
cmpq %rax, %rsi
jae 0xf600
movq %rsi, %rbx
leaq 0x28(%rsi), %rdx
movl $0x7, %esi
callq 0x9f37
movq %rbx, 0x18(%rax)
movq $0x0, 0x10(%rax)
movq 0x1202f(%rip), %rcx     # 0x21620
movq %rcx, 0x20(%rax)
movb 0x1202d(%rip), %cl      # 0x21628
movb %cl, 0xa(%rax)
popq %rbx
retq
callq 0xb46c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_next
int luaH_next (lua_State *L, Table *t, StkId key) {
  unsigned int i = findindex(L, t, key);  /* find original element */
  for (; i < t->sizearray; i++) {  /* try first array part */
    if (!ttisnil(&t->array[i])) {  /* a non-nil value? */
      setivalue(key, i + 1);
      setobj2s(L, key+1, &t->array[i]);
      return 1;
    }
  }
  for (i -= t->sizearray; cast_int(i) < sizenode(t); i++) {  /* hash part */
    if (!ttisnil(gval(gnode(t, i)))) {  /* a non-nil value? */
      setobj2s(L, key, gkey(gnode(t, i)));
      setobj2s(L, key+1, gval(gnode(t, i)));
      return 1;
    }
  }
  return 0;  /* no more elements */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl 0x8(%rdx), %edx
testl %edx, %edx
je 0xf6d7
movq %rdi, %r15
cmpl $0x13, %edx
jne 0xf642
movq (%rbx), %rdx
movabsq $-0x80000001, %rax      # imm = 0xFFFFFFFF7FFFFFFF
leaq (%rdx,%rax), %rcx
cmpq %rax, %rcx
ja 0xf644
xorl %edx, %edx
testl %edx, %edx
je 0xf652
cmpl 0xc(%r14), %edx
jbe 0xf6d7
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfe78
movq %rax, %r12
movq %rax, %r13
addq $0x10, %r13
xorl %edi, %edi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x11583
testl %eax, %eax
je 0xf67d
movq %r12, %rbp
jmp 0xf6c6
cmpl $0xa, 0x18(%r12)
jne 0xf694
testb $0x40, 0x8(%rbx)
je 0xf694
movq (%r13), %rax
cmpq (%rbx), %rax
je 0xf678
movslq 0x1c(%r12), %rax
testq %rax, %rax
je 0xf77a
shlq $0x5, %rax
leaq (%r12,%rax), %rbp
leaq (%r12,%rax), %r13
addq $0x10, %r13
xorl %edi, %edi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x11583
movq %rbp, %r12
testl %eax, %eax
je 0xf67d
subq 0x18(%r14), %rbp
shrq $0x5, %rbp
movl 0xc(%r14), %eax
leal (%rax,%rbp), %edx
incl %edx
movl 0xc(%r14), %eax
cmpl %eax, %edx
jae 0xf70b
movq 0x10(%r14), %rsi
movl %eax, %edi
negl %edi
movl %edx, %ecx
incl %edx
shlq $0x4, %rcx
cmpl $0x0, 0x8(%rsi,%rcx)
jne 0xf73a
leal (%rdi,%rdx), %r8d
incl %r8d
incl %edx
addq $0x10, %rcx
cmpl $0x1, %r8d
jne 0xf6ef
movl %eax, %edx
movb 0xb(%r14), %cl
movl $0x1, %esi
shll %cl, %esi
subl %eax, %edx
xorl %eax, %eax
cmpl %esi, %edx
jge 0xf76b
movq 0x18(%r14), %rcx
movl %edx, %edx
movq %rdx, %rdi
shlq $0x5, %rdi
cmpl $0x0, 0x8(%rcx,%rdi)
jne 0xf750
incl %edx
cmpl %edx, %esi
jne 0xf722
jmp 0xf76b
movl %edx, %eax
movq %rax, (%rbx)
movl $0x13, 0x8(%rbx)
movq 0x10(%r14), %rax
movups (%rax,%rcx), %xmm0
jmp 0xf762
addq %rdi, %rcx
movups 0x10(%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x18(%r14), %rax
movups (%rax,%rdi), %xmm0
movups %xmm0, 0x10(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1250d(%rip), %rsi     # 0x21c8e
movq %r15, %rdi
xorl %eax, %eax
callq 0x7cd8
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: setnodevector
static void setnodevector (lua_State *L, Table *t, unsigned int size) {
  int lsize;
  if (size == 0) {  /* no elements to hash part? */
    t->node = cast(Node *, dummynode);  /* use common 'dummynode' */
    lsize = 0;
  }
  else {
    int i;
    lsize = luaO_ceillog2(size);
    if (lsize > MAXHBITS)
      luaG_runerror(L, "table overflow");
    size = twoto(lsize);
    t->node = luaM_newvector(L, size, Node);
    for (i = 0; i < (int)size; i++) {
      Node *n = gnode(t, i);
      gnext(n) = 0;
      setnilvalue(wgkey(n));
      setnilvalue(gval(n));
    }
  }
  t->lsizenode = cast_byte(lsize);
  t->lastfree = gnode(t, size);  /* all positions are free */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testl %edx, %edx
je 0xf98d
movq %rdi, %r15
movl %edx, %edi
callq 0xb4e5
cmpl $0x1f, %eax
jge 0xf9ba
movl %eax, %r14d
movl $0x1, %r12d
movl %r14d, %ecx
shll %cl, %r12d
movq %r12, %rcx
shlq $0x5, %rcx
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb3eb
movq %rax, 0x18(%rbx)
movl $0x1c, %eax
movq %r12, %rcx
movq 0x18(%rbx), %rdx
movq $0x0, -0x4(%rdx,%rax)
movl $0x0, -0x14(%rdx,%rax)
addq $0x20, %rax
decq %rcx
jne 0xf96d
jmp 0xf99e
leaq 0x122b4(%rip), %rax     # 0x21c48
movq %rax, 0x18(%rbx)
xorl %r14d, %r14d
xorl %r12d, %r12d
movb %r14b, 0xb(%rbx)
shlq $0x5, %r12
addq 0x18(%rbx), %r12
movq %r12, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x122e3(%rip), %rsi     # 0x21ca4
movq %r15, %rdi
xorl %eax, %eax
callq 0x7cd8
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_setint
void luaH_setint (lua_State *L, Table *t, lua_Integer key, TValue *value) {
  const TValue *p = luaH_getint(t, key);
  TValue *cell;
  if (p != luaO_nilobject)
    cell = cast(TValue *, p);
  else {
    TValue k;
    setivalue(&k, key);
    cell = luaH_newkey(L, t, &k);
  }
  setobj2t(L, cell, value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xff77
leaq 0x11c2c(%rip), %rcx     # 0x21620
cmpq %rcx, %rax
jne 0xfa13
leaq 0x8(%rsp), %rdx
movq %r12, (%rdx)
movl $0x13, 0x8(%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq 0xfb20
movups (%rbx), %xmm0
movups %xmm0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_set
TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
  const TValue *p = luaH_get(t, key);
  if (p != luaO_nilobject)
    return cast(TValue *, p);
  else return luaH_newkey(L, t, key);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x10094
leaq 0x11bdb(%rip), %rcx     # 0x21620
cmpq %rcx, %rax
je 0xfa50
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xfb20
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_new
Table *luaH_new (lua_State *L) {
  GCObject *o = luaC_newobj(L, LUA_TTABLE, sizeof(Table));
  Table *t = gco2t(o);
  t->metatable = NULL;
  t->flags = cast_byte(~0);
  t->array = NULL;
  t->sizearray = 0;
  setnodevector(L, t, 0);
  return t;
}

// Assembly:
pushq %rax
movl $0x38, %edx
movl $0x5, %esi
callq 0x9f37
xorl %ecx, %ecx
movq %rcx, 0x28(%rax)
movw $0xff, 0xa(%rax)
movq %rcx, 0x10(%rax)
movl $0x0, 0xc(%rax)
leaq 0x12195(%rip), %rcx     # 0x21c48
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_free
void luaH_free (lua_State *L, Table *t) {
  if (!isdummy(t->node))
    luaM_freearray(L, t->node, cast(size_t, sizenode(t)));
  luaM_freearray(L, t->array, t->sizearray);
  luaM_free(L, t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
leaq 0x12176(%rip), %rax     # 0x21c48
cmpq %rax, %rsi
je 0xfaf2
movb 0xb(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rdx
shlq $0x5, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb3eb
movq 0x10(%rbx), %rsi
movl 0xc(%rbx), %edx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb3eb
movl $0x38, %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb3eb
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: mainposition
static Node *mainposition (const Table *t, const TValue *key) {
  switch (ttype(key)) {
    case LUA_TNUMINT:
      return hashint(t, ivalue(key));
    case LUA_TNUMFLT:
      return hashmod(t, l_hashfloat(fltvalue(key)));
    case LUA_TSHRSTR:
      return hashstr(t, tsvalue(key));
    case LUA_TLNGSTR:
      return hashpow2(t, luaS_hashlongstr(tsvalue(key)));
    case LUA_TBOOLEAN:
      return hashboolean(t, bvalue(key));
    case LUA_TLIGHTUSERDATA:
      return hashpointer(t, pvalue(key));
    case LUA_TLCF:
      return hashpointer(t, fvalue(key));
    default:
      lua_assert(!ttisdeadkey(key));
      return hashpointer(t, gcvalue(key));
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x8(%rsi), %eax
andl $0x3f, %eax
movq 0x18(%rdi), %rbx
cmpl $0x12, %eax
jg 0xff01
decl %eax
cmpl $0x3, %eax
ja 0xff21
leaq 0x11d98(%rip), %rcx     # 0x21c38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd (%rsi), %xmm0
leaq 0x4(%rsp), %rdi
callq 0x5270
mulsd 0x11d61(%rip), %xmm0    # 0x21c20
xorl %eax, %eax
ucomisd 0x11d5f(%rip), %xmm0    # 0x21c28
jb 0xfee9
movsd 0x11d5d(%rip), %xmm1    # 0x21c30
ucomisd %xmm0, %xmm1
jbe 0xfee9
cvttsd2si %xmm0, %rcx
addl 0x4(%rsp), %ecx
movl %ecx, %eax
sarl $0x1f, %eax
xorl %ecx, %eax
movb 0xb(%r14), %cl
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
shll %cl, %esi
notl %esi
orl $0x1, %esi
cltd
idivl %esi
movslq %edx, %rdx
jmp 0xff65
cmpl $0x16, %eax
je 0xff21
cmpl $0x14, %eax
je 0xff4e
cmpl $0x13, %eax
jne 0xff21
movb 0xb(%r14), %cl
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
notl %edx
andl (%rsi), %edx
jmp 0xff65
movb 0xb(%r14), %cl
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
shll %cl, %edi
movl (%rsi), %eax
notl %edi
orl $0x1, %edi
xorl %edx, %edx
divl %edi
jmp 0xff65
movb 0xb(%r14), %cl
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
movq (%rsi), %rax
notl %edx
andl 0xc(%rax), %edx
jmp 0xff65
movq (%rsi), %rdi
callq 0xf113
movb 0xb(%r14), %cl
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
notl %edx
andl %eax, %edx
shlq $0x5, %rdx
addq %rdx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_getint
const TValue *luaH_getint (Table *t, lua_Integer key) {
  /* (1 <= key && key <= t->sizearray) */
  if (l_castS2U(key) - 1 < t->sizearray)
    return &t->array[key - 1];
  else {
    Node *n = hashint(t, key);
    for (;;) {  /* check whether 'key' is somewhere in the chain */
      if (ttisinteger(gkey(n)) && ivalue(gkey(n)) == key)
        return gval(n);  /* that's it */
      else {
        int nx = gnext(n);
        if (nx == 0) break;
        n += nx;
      }
    }
    return luaO_nilobject;
  }
}

// Assembly:
leaq -0x1(%rsi), %rax
movl 0xc(%rdi), %ecx
cmpq %rcx, %rax
jae 0xff8c
shlq $0x4, %rax
addq 0x10(%rdi), %rax
retq
movb 0xb(%rdi), %cl
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
notl %edx
movl %esi, %eax
andl %edx, %eax
shlq $0x5, %rax
addq 0x18(%rdi), %rax
leaq 0x11675(%rip), %rcx     # 0x21620
cmpl $0x13, 0x18(%rax)
jne 0xffb7
cmpq %rsi, 0x10(%rax)
je 0xff8b
movslq 0x1c(%rax), %rdx
movq %rdx, %rdi
shlq $0x5, %rdi
addq %rdi, %rax
testq %rdx, %rdx
jne 0xffab
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_getshortstr
const TValue *luaH_getshortstr (Table *t, TString *key) {
  Node *n = hashstr(t, key);
  lua_assert(key->tt == LUA_TSHRSTR);
  for (;;) {  /* check whether 'key' is somewhere in the chain */
    const TValue *k = gkey(n);
    if (ttisshrstring(k) && eqshrstr(tsvalue(k), key))
      return gval(n);  /* that's it */
    else {
      int nx = gnext(n);
      if (nx == 0)
        return luaO_nilobject;  /* not found */
      n += nx;
    }
  }
}

// Assembly:
movb 0xb(%rdi), %cl
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
notl %edx
andl 0xc(%rsi), %edx
shlq $0x5, %rdx
addq 0x18(%rdi), %rdx
leaq 0x11634(%rip), %rcx     # 0x21620
cmpl $0x44, 0x18(%rdx)
jne 0xfff8
cmpq %rsi, 0x10(%rdx)
je 0x10018
movslq 0x1c(%rdx), %rdi
movq %rdi, %r8
shlq $0x5, %r8
addq %r8, %rdx
testq %rdi, %rdi
setne %dil
cmoveq %rcx, %rax
testb %dil, %dil
jne 0xffec
jmp 0x1001f
xorl %edi, %edi
movq %rdx, %rax
jmp 0x10011
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: getgeneric
static const TValue *getgeneric (Table *t, const TValue *key) {
  Node *n = mainposition(t, key);
  for (;;) {  /* check whether 'key' is somewhere in the chain */
    if (luaV_rawequalobj(gkey(n), key))
      return gval(n);  /* that's it */
    else {
      int nx = gnext(n);
      if (nx == 0)
        return luaO_nilobject;  /* not found */
      n += nx;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0xfe78
movq %rax, %r14
leaq 0x115bd(%rip), %r15     # 0x21620
leaq 0x10(%r14), %rsi
xorl %edi, %edi
movq %rbx, %rdx
callq 0x11583
testl %eax, %eax
jne 0x1008b
movslq 0x1c(%r14), %rax
movq %rax, %rcx
shlq $0x5, %rcx
addq %rcx, %r14
testq %rax, %rax
jne 0x10063
movq %r15, %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_get
const TValue *luaH_get (Table *t, const TValue *key) {
  switch (ttype(key)) {
    case LUA_TSHRSTR: return luaH_getshortstr(t, tsvalue(key));
    case LUA_TNUMINT: return luaH_getint(t, ivalue(key));
    case LUA_TNIL: return luaO_nilobject;
    case LUA_TNUMFLT: {
      lua_Integer k;
      if (luaV_tointeger(key, &k, 0)) /* index is int? */
        return luaH_getint(t, k);  /* use specialized version */
      /* else... */
    }  /* FALLTHROUGH */
    default:
      return getgeneric(t, key);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
andl $0x3f, %eax
cmpl $0x3, %eax
jg 0x100da
testl %eax, %eax
je 0x100f7
cmpl $0x3, %eax
jne 0x10117
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x10e26
movl %eax, %ebp
testl %eax, %eax
je 0x10113
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xff77
jmp 0x10113
cmpl $0x13, %eax
je 0x10100
cmpl $0x4, %eax
jne 0x10117
movq (%r14), %rsi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xffce
leaq 0x11522(%rip), %rax     # 0x21620
jmp 0x10122
movq (%r14), %rsi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xff77
testl %ebp, %ebp
jne 0x10122
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1004c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_getn
int luaH_getn (Table *t) {
  unsigned int j = t->sizearray;
  if (j > 0 && ttisnil(&t->array[j - 1])) {
    /* there is a boundary in the array part: (binary) search for it */
    unsigned int i = 0;
    while (j - i > 1) {
      unsigned int m = (i+j)/2;
      if (ttisnil(&t->array[m - 1])) j = m;
      else i = m;
    }
    return i;
  }
  /* else must find a boundary in hash part */
  else if (isdummy(t->node))  /* hash part is empty? */
    return j;  /* that is easy... */
  else return unbound_search(t, j);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %r12d
testl %r12d, %r12d
je 0x10153
movq 0x10(%rbx), %rax
leal -0x1(%r12), %ecx
shlq $0x4, %rcx
cmpl $0x0, 0x8(%rax,%rcx)
je 0x101a4
leaq 0x11aee(%rip), %rax     # 0x21c48
cmpq %rax, 0x18(%rbx)
je 0x1021b
leal 0x1(%r12), %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xff77
cmpl $0x0, 0x8(%rax)
je 0x101df
cmpl $0x40000000, %r14d      # imm = 0x40000000
jae 0x10220
leal (%r14,%r14), %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xff77
cmpl $0x0, 0x8(%rax)
movl %r14d, %r12d
movl %r15d, %r14d
jne 0x1017a
jmp 0x101e2
xorl %r14d, %r14d
cmpl $0x1, %r12d
je 0x1023b
xorl %ecx, %ecx
leal (%rcx,%r12), %r14d
shrl %r14d
leal -0x1(%r14), %edx
shlq $0x4, %rdx
cmpl $0x0, 0x8(%rax,%rdx)
jne 0x101cf
movl %r14d, %r12d
movl %ecx, %r14d
movl %r12d, %edx
subl %r14d, %edx
movl %r14d, %ecx
cmpl $0x1, %edx
ja 0x101b3
jmp 0x1023b
movl %r14d, %r15d
movl %r15d, %eax
subl %r12d, %eax
cmpl $0x2, %eax
jb 0x1021b
leal (%r15,%r12), %r14d
shrl %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xff77
cmpl $0x0, 0x8(%rax)
jne 0x1020b
movl %r14d, %r15d
movl %r12d, %r14d
movl %r15d, %eax
subl %r14d, %eax
movl %r14d, %r12d
cmpl $0x1, %eax
ja 0x101ed
jmp 0x1023b
movl %r12d, %r14d
jmp 0x1023b
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
leal 0x2(%r14), %esi
movq %rbx, %rdi
callq 0xff77
incl %r14d
cmpl $0x0, 0x8(%rax)
jne 0x10226
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: countint
static int countint (const TValue *key, unsigned int *nums) {
  unsigned int k = arrayindex(key);
  if (k != 0) {  /* is 'key' an appropriate array index? */
    nums[luaO_ceillog2(k)]++;  /* count as such */
    return 1;
  }
  else
    return 0;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpl $0x13, 0x8(%rdi)
jne 0x1026a
movq (%rdi), %rdi
movabsq $-0x80000001, %rax      # imm = 0xFFFFFFFF7FFFFFFF
leaq (%rdi,%rax), %rcx
cmpq %rax, %rcx
ja 0x1026c
xorl %edi, %edi
testl %edi, %edi
je 0x10281
callq 0xb4e5
cltq
incl (%rbx,%rax,4)
movl $0x1, %eax
jmp 0x10283
xorl %eax, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltm.c
// Function: luaT_init
void luaT_init (lua_State *L) {
  static const char *const luaT_eventname[] = {  /* ORDER TM */
    "__index", "__newindex",
    "__gc", "__mode", "__len", "__eq",
    "__add", "__sub", "__mul", "__mod", "__pow",
    "__div", "__idiv",
    "__band", "__bor", "__bxor", "__shl", "__shr",
    "__unm", "__bnot", "__lt", "__le",
    "__concat", "__call"
  };
  int i;
  for (i=0; i<TM_N; i++) {
    G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
    luaC_fix(L, obj2gco(G(L)->tmname[i]));  /* never collect these names */
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x11b1a(%rip), %r15     # 0x21db4
movslq (%r14,%r15), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0xf52a
movq 0x18(%rbx), %rcx
movq %rax, 0xe0(%rcx,%r14,2)
movq 0x18(%rbx), %rax
movq 0xe0(%rax,%r14,2), %rsi
movq %rbx, %rdi
callq 0x9f16
addq $0x4, %r14
cmpq $0x60, %r14
jne 0x1029a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltm.c
// Function: luaT_gettm
const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
  const TValue *tm = luaH_getshortstr(events, ename);
  lua_assert(event <= TM_EQ);
  if (ttisnil(tm)) {  /* no tag method? */
    events->flags |= cast_byte(1u<<event);  /* cache this fact */
    return NULL;
  }
  else return tm;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rsi
callq 0xffce
cmpl $0x0, 0x8(%rax)
jne 0x102fd
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
orb %al, 0xa(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltm.c
// Function: luaT_gettmbyobj
const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
  Table *mt;
  switch (ttnov(o)) {
    case LUA_TTABLE:
      mt = hvalue(o)->metatable;
      break;
    case LUA_TUSERDATA:
      mt = uvalue(o)->metatable;
      break;
    default:
      mt = G(L)->mt[ttnov(o)];
  }
  return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : luaO_nilobject);
}

// Assembly:
movl 0x8(%rsi), %eax
andl $0xf, %eax
cmpq $0x7, %rax
je 0x1031e
cmpl $0x5, %eax
jne 0x10327
movq (%rsi), %rax
addq $0x28, %rax
jmp 0x10335
movq (%rsi), %rax
addq $0x10, %rax
jmp 0x10335
movq 0x18(%rdi), %rcx
leaq (%rcx,%rax,8), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movq (%rax), %rax
testq %rax, %rax
je 0x10353
movq 0x18(%rdi), %rcx
movl %edx, %edx
movq 0xe0(%rcx,%rdx,8), %rsi
movq %rax, %rdi
jmp 0xffce
leaq 0x112c6(%rip), %rax     # 0x21620
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltm.c
// Function: luaT_objtypename
const char *luaT_objtypename (lua_State *L, const TValue *o) {
  Table *mt;
  if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) ||
      (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) {
    const TValue *name = luaH_getshortstr(mt, luaS_new(L, "__name"));
    if (ttisstring(name))  /* is '__name' a string? */
      return getstr(tsvalue(name));  /* use it as type name */
  }
  return ttypename(ttnov(o));  /* else use standard type name */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rsi), %eax
cmpl $0x47, %eax
je 0x10380
cmpl $0x45, %eax
jne 0x103bd
movq (%rbx), %rcx
movq 0x28(%rcx), %r14
testq %r14, %r14
jne 0x1038c
cmpl $0x47, %eax
jne 0x103bd
movq (%rbx), %rax
movq 0x10(%rax), %r14
testq %r14, %r14
je 0x103bd
leaq 0x119da(%rip), %rsi     # 0x21d6d
callq 0xf52a
movq %r14, %rdi
movq %rax, %rsi
callq 0xffce
movq %rax, %rcx
movl 0x8(%rax), %edx
andl $0xf, %edx
cmpl $0x4, %edx
jne 0x103b8
movq (%rcx), %rax
addq $0x18, %rax
cmpl $0x4, %edx
je 0x103cf
movl 0x8(%rbx), %eax
andl $0xf, %eax
leaq 0x1dd16(%rip), %rcx     # 0x2e0e0
movq 0x8(%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/ltm.c
// Function: luaT_callTM
void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
                  const TValue *p2, TValue *p3, int hasres) {
  ptrdiff_t result = savestack(L, p3);
  StkId func = L->top;
  setobj2s(L, func, f);  /* push function (assume EXTRA_STACK) */
  setobj2s(L, func + 1, p1);  /* 1st argument */
  setobj2s(L, func + 2, p2);  /* 2nd argument */
  L->top += 3;
  if (!hasres)  /* no result? 'p3' is third argument */
    setobj2s(L, L->top++, p3);  /* 3rd argument */
  /* metamethod may yield only when called from Lua code */
  if (isLua(L->ci))
    luaD_call(L, func, hasres);
  else
    luaD_callnoyield(L, func, hasres);
  if (hasres) {  /* if has result, move it to its place */
    p3 = restorestack(L, result);
    setobjs2s(L, p3, --L->top);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r9d, %ebp
movq %rdi, %rbx
movq %r8, %r14
subq 0x38(%rdi), %r14
movq %rsi, %rax
movq 0x10(%rdi), %rsi
movups (%rax), %xmm0
movups %xmm0, (%rsi)
movups (%rdx), %xmm0
movups %xmm0, 0x10(%rsi)
movups (%rcx), %xmm0
movups %xmm0, 0x20(%rsi)
movq 0x10(%rdi), %rcx
leaq 0x30(%rcx), %rax
movq %rax, 0x10(%rdi)
testl %r9d, %r9d
jne 0x10423
addq $0x40, %rcx
movq %rcx, 0x10(%rbx)
movups (%r8), %xmm0
movups %xmm0, (%rax)
movq 0x20(%rbx), %rax
testb $0x2, 0x42(%rax)
jne 0x10439
movq %rbx, %rdi
movl %ebp, %edx
callq 0x8dac
jmp 0x10443
movq %rbx, %rdi
movl %ebp, %edx
callq 0x8d4a
testl %ebp, %ebp
je 0x10460
movq 0x10(%rbx), %rax
movq 0x38(%rbx), %rcx
leaq -0x10(%rax), %rdx
movq %rdx, 0x10(%rbx)
movups -0x10(%rax), %xmm0
movups %xmm0, (%rcx,%r14)
popq %rbx
popq %r14
popq %rbp
retq