LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: closegoto
static void closegoto (LexState *ls, int g, Labeldesc *label) {
  int i;
  FuncState *fs = ls->fs;
  Labellist *gl = &ls->dyd->gt;
  Labeldesc *gt = &gl->arr[g];
  lua_assert(eqstr(gt->name, label->name));
  if (gt->nactvar < label->nactvar) {
    TString *vname = getlocvar(fs, gt->nactvar)->varname;
    const char *msg = luaO_pushfstring(ls->L,
      "<goto %s> at line %d jumps into the scope of local '%s'",
      getstr(gt->name), gt->line, getstr(vname));
    semerror(ls, msg);
  }
  luaK_patchlist(fs, gt->pc, label->pc);
  /* remove goto from pending list */
  for (i = g; i < gl->n - 1; i++)
    gl->arr[i] = gl->arr[i + 1];
  gl->n--;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq 0x58(%rbx), %r14
movq 0x10(%r14), %r13
movslq %esi, %r15
imulq $0x18, %r15, %r12
movzbl 0x10(%r13,%r12), %esi
addq %r12, %r13
cmpb 0x10(%rdx), %sil
jb 0xd9f4
movl 0x8(%r13), %esi
movl 0x8(%rdx), %edx
callq 0x14344
movslq 0x18(%r14), %rax
decq %rax
cmpq %rax, %r15
jge 0xd9e6
movq 0x10(%r14), %rax
incq %r15
movq 0x28(%rax,%r12), %rcx
movq %rcx, 0x10(%rax,%r12)
movups 0x18(%rax,%r12), %xmm0
movups %xmm0, (%rax,%r12)
addq $0x18, %r12
jmp 0xd9b8
movl %eax, 0x18(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xd525
movq (%rax), %r8
movq 0x38(%rbx), %rdi
movq (%r13), %rdx
addq $0x18, %rdx
movl 0xc(%r13), %ecx
addq $0x18, %r8
leaq 0x1213f(%rip), %rsi     # 0x1fb56
xorl %eax, %eax
callq 0xb593
movq %rbx, %rdi
movq %rax, %rsi
callq 0xda29
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: findlabel
static int findlabel (LexState *ls, int g) {
  int i;
  BlockCnt *bl = ls->fs->bl;
  Dyndata *dyd = ls->dyd;
  Labeldesc *gt = &dyd->gt.arr[g];
  /* check labels in current block for a match */
  for (i = bl->firstlabel; i < dyd->label.n; i++) {
    Labeldesc *lb = &dyd->label.arr[i];
    if (eqstr(lb->name, gt->name)) {  /* correct label? */
      if (gt->nactvar > lb->nactvar &&
          (bl->upval || dyd->label.n > bl->firstlabel))
        luaK_patchclose(ls->fs, gt->pc, lb->nactvar);
      closegoto(ls, g, lb);  /* close it */
      return 1;
    }
  }
  return 0;  /* label not found; cannot close goto */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq 0x58(%r14), %rdx
movq 0x18(%rdi), %rcx
movslq %esi, %rax
imulq $0x18, %rax, %rax
addq 0x10(%rdx), %rax
movslq 0x8(%rcx), %rsi
movslq 0x28(%rdx), %r8
imulq $0x18, %rsi, %r9
addq $-0x18, %r9
movq %rsi, %r10
decq %r10
incq %r10
cmpq %r8, %r10
jge 0xdab8
movq 0x20(%rdx), %r11
movq 0x18(%r11,%r9), %r15
addq $0x18, %r9
cmpq (%rax), %r15
jne 0xda6a
leaq (%r11,%r9), %r15
movzbl 0x10(%r11,%r9), %edx
cmpb %dl, 0x10(%rax)
jbe 0xdaa6
cmpb $0x0, 0x11(%rcx)
jne 0xda9e
cmpl %esi, %r8d
jle 0xdaa6
movl 0x8(%rax), %esi
callq 0x143b9
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0xd97e
pushq $0x1
popq %rax
jmp 0xdaba
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0xc7cf
cmpl $0x1, (%r14)
jne 0xdae2
movl $0x3, (%rsp)
movq 0x30(%rbx), %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x14c0a
movl 0x14(%rbx), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: exp1
static int exp1 (LexState *ls) {
  expdesc e;
  int reg;
  expr(ls, &e);
  luaK_exp2nextreg(ls->fs, &e);
  lua_assert(e.k == VNONRELOC);
  reg = e.u.info;
  return reg;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rsi
callq 0xc7cf
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x14836
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x3
popq %rsi
callq 0xd3b3
movq %rbx, %rdi
movl $0x103, %esi            # imm = 0x103
callq 0xc7d6
testl %r13d, %r13d
je 0xdba3
pushq $0x28
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x1430b
jmp 0xdbab
movq %r14, %rdi
callq 0x142ce
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 0xd3b3
movq %r14, %rdi
movl %r12d, %esi
callq 0x14536
movq %rbx, %rdi
callq 0xc66c
movq %r14, %rdi
callq 0xc807
movq %r14, %rdi
movl %r15d, %esi
callq 0x14333
testl %r13d, %r13d
je 0xdc2f
pushq $0x27
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x1430b
movl 0xc(%rsp), %ebx
jmp 0xdc64
pushq $0x29
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
xorl %ecx, %ecx
movl %r12d, %r8d
callq 0x14213
movq %r14, %rdi
movl 0xc(%rsp), %ebx
movl %ebx, %esi
callq 0x152f5
addl $0x2, %ebp
pushq $0x2a
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x1430b
incl %r15d
movq %r14, %rdi
movl %eax, %esi
movl %r15d, %edx
callq 0x14344
movq %r14, %rdi
movl %ebx, %esi
callq 0x152f5
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/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 0xdccf
testl %ebp, %ebp
pushq $-0x1
popq %r14
cmovnsl %ebp, %r14d
leal 0x1(%r14), %edx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x146d3
testl %ebp, %ebp
jle 0xdd02
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x14536
testl %eax, %eax
je 0xdcde
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x14836
testl %ebp, %ebp
jle 0xdd02
movzbl 0x3c(%rbx), %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14536
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x1415c
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: assignment
static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
  expdesc e;
  check_condition(ls, vkisvar(lh->v.k), "syntax error");
  if (testnext(ls, ',')) {  /* assignment -> ',' suffixedexp assignment */
    struct LHS_assign nv;
    nv.prev = lh;
    suffixedexp(ls, &nv.v);
    if (nv.v.k != VINDEXED)
      check_conflict(ls, lh, &nv.v);
    checklimit(ls->fs, nvars + ls->L->nCcalls, LUAI_MAXCCALLS,
                    "C levels");
    assignment(ls, &nv, nvars+1);
  }
  else {  /* assignment -> '=' explist */
    int nexps;
    checknext(ls, '=');
    nexps = explist(ls, &e);
    if (nexps != nvars) {
      adjust_assign(ls, nvars, nexps, &e);
      if (nexps > nvars)
        ls->fs->freereg -= nexps - nvars;  /* remove extra values */
    }
    else {
      luaK_setoneret(ls->fs, &e);  /* close last expression */
      luaK_storevar(ls->fs, &lh->v, &e);
      return;  /* avoid default */
    }
  }
  init_exp(&e, VNONRELOC, ls->fs->freereg-1);  /* default assignment */
  luaK_storevar(ls->fs, &lh->v, &e);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movl 0x8(%rsi), %eax
addl $-0x8, %eax
cmpl $0x3, %eax
jae 0xde98
movl %edx, %ebp
movq %rsi, %r15
leaq 0x8(%rsi), %rbx
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0xc731
testl %eax, %eax
je 0xddba
leaq 0x8(%rsp), %r12
movq %r15, -0x8(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0xd118
movl (%r12), %eax
cmpl $0xa, %eax
je 0xde13
movq 0x30(%r14), %r12
movb 0x3c(%r12), %cl
movzbl %cl, %edx
xorl %edi, %edi
pushq $0x1
popq %rsi
testq %r15, %r15
je 0xddea
cmpl $0xa, 0x8(%r15)
jne 0xddb5
movzbl 0x13(%r15), %r8d
cmpl %r8d, %eax
jne 0xdd9d
movzbl 0x12(%r15), %r8d
cmpl %r8d, 0x10(%rsp)
jne 0xdd9d
movb $0x8, 0x13(%r15)
movb %cl, 0x12(%r15)
movl %esi, %edi
cmpl $0x8, %eax
jne 0xddb5
movswl 0x10(%r15), %r8d
cmpl %r8d, 0x10(%rsp)
jne 0xddb5
movw %dx, 0x10(%r15)
movl %esi, %edi
movq (%r15), %r15
jmp 0xdd70
pushq $0x3d
popq %rsi
movq %r14, %rdi
callq 0xc7d6
movq %rsp, %rsi
movq %r14, %rdi
callq 0xd801
cmpl %eax, %ebp
jne 0xde77
movq 0x30(%r14), %rdi
movq %rsp, %rsi
callq 0x14739
movq 0x30(%r14), %rdi
jmp 0xde5f
testl %edi, %edi
je 0xde13
xorl %ecx, %ecx
cmpl $0x8, %eax
setne %cl
leal (%rcx,%rcx,4), %esi
movl 0x10(%rsp), %ecx
movq %r12, %rdi
xorl %r8d, %r8d
callq 0x14213
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x14536
movq 0x30(%r14), %rdi
movq 0x38(%r14), %rax
movzwl 0xc6(%rax), %esi
addl %ebp, %esi
leaq 0x11c71(%rip), %rcx     # 0x1fa9c
movl $0xc8, %edx
callq 0xbbfc
incl %ebp
movq %rsp, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0xdd07
movq 0x30(%r14), %rdi
movzbl 0x3c(%rdi), %eax
orq $-0x1, 0x10(%rsp)
decl %eax
movl $0x7, (%rsp)
movl %eax, 0x8(%rsp)
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x14aeb
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r15d
movq %rsp, %rcx
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0xdc8d
subl %r15d, %ebp
jge 0xde44
movq 0x30(%r14), %rax
addb %bpl, 0x3c(%rax)
jmp 0xde44
leaq 0x11df6(%rip), %rsi     # 0x1fc95
movq %r14, %rdi
callq 0x15676
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x48
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0xab76
movq 0x20(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq %rcx, 0x10(%rax)
andq $0x0, 0x18(%rax)
incw 0xa(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x18(%rax), %rsi
andq $0x0, 0x18(%rax)
pushq $0x48
popq %r14
testq %rsi, %rsi
je 0xdf2f
movq 0x18(%rsi), %r15
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xab76
decw 0xa(%rbx)
movq %r15, %rsi
jmp 0xdf10
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %rbx
movq 0x20(%rdi), %r15
pushq $0x48
popq %r14
movq 0x18(%r15), %rsi
testq %rsi, %rsi
je 0xdf79
movq 0x18(%rsi), %r12
testq %r12, %r12
je 0xdf79
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xab76
decw 0xa(%rbx)
movq %r12, 0x18(%r15)
movq %r15, 0x10(%r12)
movq %r12, %r15
jmp 0xdf48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r14
cmpq $0x0, 0x18(%r14)
jle 0xdfa3
movq %rbx, %rdi
callq 0x9f05
pushq $0x8
popq %rdx
movl $0xd8, %ecx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xab76
movq %rax, %r12
leaq 0x8(%rax), %r15
movb 0x54(%r14), %al
andb $0x3, %al
movb %al, 0x11(%r12)
movb $0x8, 0x10(%r12)
movq 0x58(%r14), %rax
movq %rax, 0x8(%r12)
movq %r15, 0x58(%r14)
movq 0x10(%rbx), %rax
movq %r15, (%rax)
movl $0x48, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0xe054
movl 0xc8(%rbx), %eax
movl %eax, 0xd0(%r12)
movl 0xbc(%rbx), %eax
movl %eax, 0xc4(%r12)
movq 0xa8(%rbx), %rcx
movq %rcx, 0xb0(%r12)
movl %eax, 0xc8(%r12)
movq 0xc8(%r14), %rax
movq -0x8(%rax), %rax
movq %rax, (%r12)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe0a9
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xab76
movq %rax, 0x38(%rbx)
movl $0x28, 0xb8(%rbx)
pushq $0x8
popq %rcx
cmpq $0x288, %rcx            # imm = 0x288
je 0xe0e2
andl $0x0, (%rax,%rcx)
addq $0x10, %rcx
jmp 0xe0cf
leaq 0x230(%rax), %rcx
movq %rcx, 0x30(%rbx)
movb $0x0, 0xa2(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
movq %rax, 0x60(%rbx)
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
andl $0x0, 0x8(%rax)
leaq 0x60(%rbx), %rcx
addq $0x150, %rax            # imm = 0x150
movq %rax, 0x68(%rbx)
movq %rcx, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x95bc
movq %rbx, %rdi
callq 0xe159
movl $0xd8, %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0xab76
// File: /workspace/github_c_makefile_star2_O2/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 0xe18b
pushq %rbx
movq %rdi, %rbx
leaq 0x60(%rdi), %rax
movq %rax, 0x20(%rdi)
callq 0xdef7
movq 0x38(%rbx), %rsi
movslq 0xb8(%rbx), %rdx
shlq $0x4, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
popq %rbx
jmp 0xab76
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: lua_newstate
LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
  int i;
  lua_State *L;
  global_State *g;
  LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));
  if (l == NULL) return NULL;
  L = &l->l.l;
  g = &l->g;
  L->next = NULL;
  L->tt = LUA_TTHREAD;
  g->currentwhite = bitmask(WHITE0BIT);
  L->marked = luaC_white(g);
  preinit_thread(L, g);
  g->frealloc = f;
  g->ud = ud;
  g->mainthread = L;
  g->seed = makeseed(L);
  g->gcrunning = 0;  /* no GC while building state */
  g->GCestimate = 0;
  g->strt.size = g->strt.nuse = 0;
  g->strt.hash = NULL;
  setnilvalue(&g->l_registry);
  g->panic = NULL;
  g->version = NULL;
  g->gcstate = GCSpause;
  g->gckind = KGC_NORMAL;
  g->allgc = g->finobj = g->tobefnz = g->fixedgc = NULL;
  g->sweepgc = NULL;
  g->gray = g->grayagain = NULL;
  g->weak = g->ephemeron = g->allweak = NULL;
  g->twups = NULL;
  g->totalbytes = sizeof(LG);
  g->GCdebt = 0;
  g->gcfinnum = 0;
  g->gcpause = LUAI_GCPAUSE;
  g->gcstepmul = LUAI_GCMUL;
  for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
  if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
    /* memory allocation error: free partial state */
    close_state(L);
    L = NULL;
  }
  return L;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
pushq $0x8
popq %rdx
movl $0x610, %ecx            # imm = 0x610
movq %rsi, %rdi
xorl %esi, %esi
callq *%r12
testq %rax, %rax
je 0xe30b
movq %rax, %r14
leaq 0x8(%rax), %rbx
andq $0x0, 0x8(%rax)
movq %rax, %rsi
addq $0xd8, %rsi
movw $0x108, 0x10(%rax)      # imm = 0x108
movb $0x1, 0x12c(%rax)
movq %rbx, %rdi
callq 0xe054
movq %r12, 0xd8(%r14)
movq %r15, 0xe0(%r14)
movq %rbx, 0x1a0(%r14)
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x5320
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x10(%rsp), %rdi
movq %rbx, (%rdi)
movq %rcx, 0x8(%rdi)
leaq 0x11454(%rip), %rcx     # 0x1f670
movq %rcx, 0x10(%rdi)
leaq -0x9b(%rip), %rcx       # 0xe18c
movq %rcx, 0x18(%rdi)
pushq $0x20
popq %rsi
movl %eax, %edx
callq 0xe471
movl %eax, 0x128(%r14)
movb $0x0, 0x12f(%r14)
andl $0x0, 0x120(%r14)
andq $0x0, 0x198(%r14)
andq $0x0, 0x1a8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x100(%r14)
andq $0x0, 0x110(%r14)
movw $0x7, 0x12d(%r14)
movups %xmm0, 0x130(%r14)
movups %xmm0, 0x140(%r14)
movups %xmm0, 0x150(%r14)
movups %xmm0, 0x160(%r14)
movups %xmm0, 0x170(%r14)
andq $0x0, 0x180(%r14)
movq $0x610, 0xe8(%r14) # imm = 0x610
andq $0x0, 0xf0(%r14)
movabsq $0xc800000000, %rax     # imm = 0xC800000000
movq %rax, 0x188(%r14)
movl $0xc8, 0x190(%r14)
cmpq $0x9, %r15
je 0xe2ec
andq $0x0, 0x278(%r14,%r15,8)
incq %r15
jmp 0xe2d8
leaq 0x27(%rip), %rsi        # 0xe31a
movq %rbx, %rdi
xorl %edx, %edx
callq 0x81eb
testl %eax, %eax
je 0xe30b
movq %rbx, %rdi
callq 0xe3d6
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe0a9
movq %rbx, %rdi
callq 0xed08
movq %rax, %r14
movq %rax, 0x40(%r12)
pushq $0x45
popq %rbp
movl %ebp, 0x48(%r12)
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0xea32
movq %rsp, %r15
movq %rbx, (%r15)
movl $0x48, 0x8(%r15)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xec50
movq %rbx, %rdi
callq 0xed08
movq %rax, (%r15)
movl %ebp, 0x8(%r15)
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xec50
movq %rbx, %rdi
callq 0xe5e7
movq %rbx, %rdi
callq 0xf438
movq %rbx, %rdi
callq 0x155c0
movb $0x1, 0x57(%r12)
xorl %edi, %edi
callq 0x5ae3
movq %rax, 0xd0(%r12)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x95bc
movq %rbx, %rdi
callq 0x9988
movq 0x18(%rbx), %rax
movq 0x30(%rax), %rsi
movslq 0x3c(%rax), %rdx
shlq $0x3, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xab76
movq %rbx, %rdi
callq 0xe159
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_O2/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 0xe46d
movq 0x10(%rdi), %rdx
xorl %eax, %eax
cmpq 0x10(%rsi), %rdx
jne 0xe46c
pushq %rax
addq $0x18, %rdi
addq $0x18, %rsi
callq 0x5370
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addq $0x8, %rsp
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rcx
shrq $0x5, %rcx
movq %rcx, %rdx
notq %rdx
cmpq %rcx, %rsi
jbe 0xe4a9
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
jmp 0xe482
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0xa(%rdi)
je 0xe4b9
movl 0xc(%rbx), %eax
jmp 0xe4d0
leaq 0x18(%rbx), %rdi
movq 0x10(%rbx), %rsi
movl 0xc(%rbx), %edx
callq 0xe471
movl %eax, 0xc(%rbx)
movb $0x1, 0xa(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x3c(%r12), %eax
movslq %esi, %r15
cmpl %esi, %eax
jge 0xe52c
movslq %eax, %rdx
movq 0x30(%r12), %rsi
shlq $0x3, %rdx
leaq (,%r15,8), %rcx
movq %r14, %rdi
callq 0xab76
movq %rax, 0x30(%r12)
movl 0x3c(%r12), %eax
movslq %eax, %rcx
cmpq %r15, %rcx
jge 0xe52c
movq 0x30(%r12), %rdx
andq $0x0, (%rdx,%rcx,8)
incq %rcx
jmp 0xe518
leal -0x1(%rbx), %ecx
xorl %esi, %esi
movslq %eax, %rdx
cmpq %rdx, %rsi
jge 0xe57a
movq 0x30(%r12), %rdx
movq (%rdx,%rsi,8), %rax
andq $0x0, (%rdx,%rsi,8)
testq %rax, %rax
je 0xe570
movq 0x10(%rax), %rdx
movl 0xc(%rax), %edi
andl %ecx, %edi
movq 0x30(%r12), %r8
movq (%r8,%rdi,8), %r8
movq %r8, 0x10(%rax)
movq 0x30(%r12), %r8
movq %rax, (%r8,%rdi,8)
movq %rdx, %rax
jmp 0xe547
incq %rsi
movl 0x3c(%r12), %eax
jmp 0xe531
cmpl %ebx, %eax
jle 0xe59b
movq 0x30(%r12), %rsi
shlq $0x3, %rdx
shlq $0x3, %r15
movq %r14, %rdi
movq %r15, %rcx
callq 0xab76
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_O2/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
cmpq $0x35, %rcx
je 0xe5e6
xorl %edx, %edx
cmpq $0x2, %rdx
je 0xe5dd
movq (%rax,%rdx,8), %rsi
testb $0x3, 0x9(%rsi)
je 0xe5d8
movq 0xd8(%rdi), %rsi
movq %rsi, (%rax,%rdx,8)
incq %rdx
jmp 0xe5bd
incq %rcx
addq $0x10, %rax
jmp 0xe5b5
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe4d2
leaq 0x1169f(%rip), %rsi     # 0x1fca2
pushq $0x11
popq %rdx
movq %rbx, %rdi
callq 0xe658
movq %rax, 0xd8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9853
movq 0xd8(%r14), %rax
addq $0x1e8, %r14            # imm = 0x1E8
xorl %ecx, %ecx
cmpq $0x35, %rcx
je 0xe650
xorl %edx, %edx
cmpq $0x2, %rdx
je 0xe647
movq %rax, (%r14,%rdx,8)
incq %rdx
jmp 0xe638
incq %rcx
addq $0x10, %r14
jmp 0xe630
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe6d3
movq %rdi, 0x10(%rsp)
movq 0x18(%rdi), %rbp
movl 0x50(%rbp), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe471
movl 0x3c(%rbp), %r13d
leal -0x1(%r13), %ecx
movl %eax, 0xc(%rsp)
andl %eax, %ecx
movslq %ecx, %r15
shlq $0x3, %r15
addq 0x30(%rbp), %r15
movq %r15, %r12
movq (%r12), %r12
testq %r12, %r12
je 0xe705
movzbl 0xb(%r12), %eax
cmpq %rbx, %rax
jne 0xe6cd
leaq 0x18(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5370
testl %eax, %eax
je 0xe740
addq $0x10, %r12
jmp 0xe6a5
movabsq $0x7fffffffffffffe7, %rax # imm = 0x7FFFFFFFFFFFFFE7
cmpq %rax, %rbx
jae 0xe7a6
movq %rbx, %rsi
callq 0xe7ab
movq %rax, %r12
leaq 0x18(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5300
jmp 0xe794
cmpl $0x3fffffff, %r13d      # imm = 0x3FFFFFFF
jg 0xe758
cmpl %r13d, 0x38(%rbp)
movq 0x10(%rsp), %r12
jl 0xe75d
addl %r13d, %r13d
movq %r12, %rdi
movl %r13d, %esi
callq 0xe4d2
movslq 0x3c(%rbp), %rax
decq %rax
movslq 0xc(%rsp), %r15
andq %rax, %r15
shlq $0x3, %r15
addq 0x30(%rbp), %r15
jmp 0xe75d
movb 0x9(%r12), %al
xorb $0x3, %al
movb 0x54(%rbp), %cl
xorb $0x3, %cl
testb %al, %cl
jne 0xe794
movb %al, 0x9(%r12)
jmp 0xe794
movq 0x10(%rsp), %r12
pushq $0x4
popq %rdx
movq %r12, %rdi
movq %rbx, %rsi
movl 0xc(%rsp), %ecx
callq 0xe7c4
movq %rax, %r12
leaq 0x18(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5300
movb %bl, 0xb(%r12)
movq (%r15), %rax
movq %rax, 0x10(%r12)
movq %r12, (%r15)
incl 0x38(%rbp)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xabef
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lstring.c
// Function: createstrobj
static TString *createstrobj (lua_State *L, size_t l, int tag, unsigned int h) {
  TString *ts;
  GCObject *o;
  size_t totalsize;  /* total size of TString object */
  totalsize = sizelstring(l);
  o = luaC_newobj(L, tag, totalsize);
  ts = gco2ts(o);
  ts->hash = h;
  ts->extra = 0;
  getstr(ts)[l] = '\0';  /* ending 0 */
  return ts;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rsi, %r14
leaq 0x19(%rsi), %rax
movl %edx, %esi
movq %rax, %rdx
callq 0x9874
movl %ebx, 0xc(%rax)
xorl %ecx, %ecx
movb %cl, 0xa(%rax)
movb %cl, 0x18(%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe80a
movq (%rcx), %rcx
movq %rcx, (%rdx)
decl 0x38(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r13d, %r13d
pushq $0x35
popq %rcx
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movq 0x18(%rdi), %rax
shll $0x4, %edx
leaq (%rax,%rdx), %r12
addq $0x1e8, %r12            # imm = 0x1E8
cmpq $0x2, %r13
je 0xe86f
movq (%r12,%r13,8), %r15
leaq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x5270
incq %r13
testl %eax, %eax
jne 0xe850
jmp 0xe895
movq (%r12), %rax
movq %rax, 0x8(%r12)
movq %rbx, %rdi
callq 0x5140
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xe658
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_O2/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 0xe8e0
movq %rsi, %rbx
leaq 0x28(%rsi), %rdx
pushq $0x7
popq %rsi
callq 0x9874
movq %rbx, 0x18(%rax)
andq $0x0, 0x10(%rax)
movq 0x10d9f(%rip), %rcx     # 0x1f670
movq %rcx, 0x20(%rax)
movb 0x10d9d(%rip), %cl      # 0x1f678
movb %cl, 0xa(%rax)
popq %rbx
retq
callq 0xabef
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rdx), %eax
cmpl $0x13, %eax
je 0xe911
testl %eax, %eax
jne 0xe932
movl 0xc(%r14), %ecx
xorl %eax, %eax
jmp 0xe996
movq (%rbx), %rax
movabsq $-0x80000001, %rcx      # imm = 0xFFFFFFFF7FFFFFFF
addq %rax, %rcx
cmpq $-0x80000000, %rcx      # imm = 0x80000000
jb 0xe932
movl 0xc(%r14), %ecx
cmpl %eax, %ecx
jae 0xe996
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf0a2
movq %rax, %r12
leaq 0x10(%r12), %r13
xorl %edi, %edi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x104c8
testl %eax, %eax
jne 0xe984
cmpl $0xa, 0x18(%r12)
jne 0xe96d
testb $0x40, 0x8(%rbx)
je 0xe96d
movq (%r13), %rax
cmpq (%rbx), %rax
je 0xe984
movslq 0x1c(%r12), %rax
testq %rax, %rax
je 0xea21
shlq $0x5, %rax
addq %rax, %r12
jmp 0xe940
subq 0x18(%r14), %r12
shrq $0x5, %r12
movl 0xc(%r14), %ecx
leal (%rcx,%r12), %eax
incl %eax
movl %eax, %edx
movl %ecx, %eax
movq %rdx, %rcx
shlq $0x4, %rcx
cmpq %rax, %rdx
jae 0xe9d9
movq 0x10(%r14), %rdi
incq %rdx
leaq 0x10(%rcx), %rsi
cmpl $0x0, 0x8(%rdi,%rcx)
movq %rsi, %rcx
je 0xe9a1
movl %edx, %eax
movq %rax, (%rbx)
movl $0x13, 0x8(%rbx)
movq 0x10(%r14), %rax
movups -0x10(%rax,%rsi), %xmm0
movups %xmm0, 0x10(%rbx)
pushq $0x1
popq %rax
jmp 0xea17
subl %eax, %edx
movb 0xb(%r14), %cl
pushq $0x1
popq %rax
movl %eax, %esi
shll %cl, %esi
cmpl %esi, %edx
jge 0xea15
movq 0x18(%r14), %rdi
movl %edx, %ecx
shlq $0x5, %rcx
incl %edx
cmpl $0x0, 0x8(%rdi,%rcx)
je 0xe9e6
addq %rcx, %rdi
movups 0x10(%rdi), %xmm0
movups %xmm0, (%rbx)
movq 0x18(%r14), %rdx
movups (%rdx,%rcx), %xmm0
movups %xmm0, 0x10(%rbx)
jmp 0xea17
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x112fe(%rip), %rsi     # 0x1fd26
movq %r15, %rdi
xorl %eax, %eax
callq 0x7930
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/ltable.c
// Function: luaH_resize
void luaH_resize (lua_State *L, Table *t, unsigned int nasize,
                                          unsigned int nhsize) {
  unsigned int i;
  int j;
  unsigned int oldasize = t->sizearray;
  int oldhsize = t->lsizenode;
  Node *nold = t->node;  /* save old hash ... */
  if (nasize > oldasize)  /* array part must grow? */
    setarrayvector(L, t, nasize);
  /* create new hash part with appropriate size */
  setnodevector(L, t, nhsize);
  if (nasize < oldasize) {  /* array part must shrink? */
    t->sizearray = nasize;
    /* re-insert elements from vanishing slice */
    for (i=nasize; i<oldasize; i++) {
      if (!ttisnil(&t->array[i]))
        luaH_setint(L, t, i + 1, &t->array[i]);
    }
    /* shrink array */
    luaM_reallocvector(L, t->array, oldasize, nasize, TValue);
  }
  /* re-insert elements from hash part */
  for (j = twoto(oldhsize) - 1; j >= 0; j--) {
    Node *old = nold + j;
    if (!ttisnil(gval(old))) {
      /* doesn't need barrier/invalidate cache, as entry was
         already present in the table */
      setobjt2t(L, luaH_set(L, t, gkey(old)), gval(old));
    }
  }
  if (!isdummy(nold))
    luaM_freearray(L, nold, cast(size_t, twoto(oldhsize))); /* free old hash */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl 0xc(%rsi), %r13d
movzbl 0xb(%rsi), %eax
movq %rax, 0x10(%rsp)
movq 0x18(%rsi), %rax
movq %rax, 0x8(%rsp)
movl %edx, %ebp
cmpl %edx, %r13d
jae 0xeaae
movq 0x10(%r15), %rsi
movq %r13, %rdx
shlq $0x4, %rdx
movq %rbp, %rcx
shlq $0x4, %rcx
movq %rbx, %rdi
callq 0xab76
movq %rax, 0x10(%r15)
movl 0xc(%r15), %ecx
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
addq $0x8, %rax
cmpq %rbp, %rcx
jae 0xeaaa
andl $0x0, (%rax)
incq %rcx
addq $0x10, %rax
jmp 0xea99
movl %r12d, 0xc(%r15)
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0xeba6
cmpl %r12d, %r13d
jbe 0xeb17
movl %r12d, 0xc(%r15)
movq %rbp, %r12
shlq $0x4, %r12
movq %rbp, %r14
movq 0x10(%r15), %rcx
cmpq %r13, %r14
jae 0xeafa
incq %r14
cmpl $0x0, 0x8(%rcx,%r12)
je 0xeaf4
addq %r12, %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xec50
addq $0x10, %r12
jmp 0xeacf
shlq $0x4, %r13
shlq $0x4, %rbp
movq %rbx, %rdi
movq %rcx, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0xab76
movq %rax, 0x10(%r15)
pushq $0x1
popq %r12
movq 0x10(%rsp), %rcx
shlq %cl, %r12
movq %r12, %rax
shlq $0x5, %rax
movq 0x8(%rsp), %rcx
leaq (%rax,%rcx), %r14
addq $-0x10, %r14
movl %r12d, %ebp
testl %ebp, %ebp
jle 0xeb67
cmpl $0x0, -0x8(%r14)
je 0xeb5f
leaq -0x10(%r14), %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xecaa
movups (%r13), %xmm0
movups %xmm0, (%rax)
decl %ebp
addq $-0x20, %r14
jmp 0xeb3a
leaq 0x11172(%rip), %rax     # 0x1fce0
movq 0x8(%rsp), %rsi
cmpq %rax, %rsi
je 0xeb97
movslq %r12d, %rdx
shlq $0x5, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xab76
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testl %edx, %edx
je 0xec10
movq %rdi, %r15
movl %edx, %edi
callq 0xac47
cmpl $0x1f, %eax
jge 0xec3f
movl %eax, %r14d
pushq $0x1
popq %r13
movl %r14d, %ecx
shll %cl, %r13d
movq %r13, %r12
shlq $0x5, %r12
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0xab76
movq %rax, 0x18(%rbx)
cmpq %rbp, %r12
je 0xec0a
movq 0x18(%rbx), %rax
andq $0x0, 0x18(%rax,%rbp)
andl $0x0, 0x8(%rax,%rbp)
addq $0x20, %rbp
jmp 0xebf0
movq 0x18(%rbx), %rax
jmp 0xec21
leaq 0x110c9(%rip), %rax     # 0x1fce0
movq %rax, 0x18(%rbx)
xorl %r14d, %r14d
xorl %r13d, %r13d
movb %r14b, 0xb(%rbx)
shlq $0x5, %r13
addq %rax, %r13
movq %r13, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x110f6(%rip), %rsi     # 0x1fd3c
movq %r15, %rdi
xorl %eax, %eax
callq 0x7930
// File: /workspace/github_c_makefile_star2_O2/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 0xf194
leaq 0x109f7(%rip), %rcx     # 0x1f670
cmpq %rcx, %rax
jne 0xec98
leaq 0x8(%rsp), %rdx
movq %r12, (%rdx)
movl $0x13, 0x8(%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq 0xed98
movups (%rbx), %xmm0
movups %xmm0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf29c
leaq 0x109a6(%rip), %rcx     # 0x1f670
cmpq %rcx, %rax
je 0xecd5
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xed98
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x5
popq %rsi
pushq $0x38
popq %rdx
callq 0x9874
andq $0x0, 0x28(%rax)
movw $0xff, 0xa(%rax)
andq $0x0, 0x10(%rax)
andl $0x0, 0xc(%rax)
leaq 0x10fb1(%rip), %rcx     # 0x1fce0
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10f92(%rip), %rax     # 0x1fce0
cmpq %rax, %rsi
je 0xed6c
movb 0xb(%rbx), %cl
pushq $0x1
popq %rax
shll %cl, %eax
movslq %eax, %rdx
shlq $0x5, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xab76
movq 0x10(%rbx), %rsi
movl 0xc(%rbx), %edx
shlq $0x4, %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xab76
pushq $0x38
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xab76
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/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
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
jbe 0xf0cc
cmpl $0x16, %eax
je 0xf0ee
cmpl $0x14, %eax
je 0xf104
cmpl $0x13, %eax
je 0xf0dc
jmp 0xf0ee
leaq 0x10bfd(%rip), %rax     # 0x1fcd0
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb 0xb(%r14), %cl
pushq $-0x1
popq %rdx
shll %cl, %edx
notl %edx
andl (%rsi), %edx
jmp 0xf182
movb 0xb(%r14), %cl
pushq $-0x1
popq %rdi
shll %cl, %edi
movl (%rsi), %eax
notl %edi
orl $0x1, %edi
xorl %edx, %edx
divl %edi
jmp 0xf182
movq (%rsi), %rdi
callq 0xe4aa
movb 0xb(%r14), %cl
pushq $-0x1
popq %rdx
shll %cl, %edx
notl %edx
andl %eax, %edx
jmp 0xf182
movsd (%rsi), %xmm0
leaq 0x4(%rsp), %rdi
callq 0x5250
mulsd 0x10b87(%rip), %xmm0    # 0x1fcb8
xorl %eax, %eax
ucomisd 0x10b85(%rip), %xmm0    # 0x1fcc0
jb 0xf15b
movsd 0x10b83(%rip), %xmm1    # 0x1fcc8
ucomisd %xmm0, %xmm1
jbe 0xf15b
cvttsd2si %xmm0, %rcx
addl 0x4(%rsp), %ecx
movl %ecx, %eax
sarl $0x1f, %eax
xorl %ecx, %eax
movb 0xb(%r14), %cl
pushq $-0x1
popq %rsi
shll %cl, %esi
notl %esi
orl $0x1, %esi
cltd
idivl %esi
movslq %edx, %rdx
jmp 0xf182
movb 0xb(%r14), %cl
pushq $-0x1
popq %rdx
shll %cl, %edx
movq (%rsi), %rax
notl %edx
andl 0xc(%rax), %edx
shlq $0x5, %rdx
addq %rdx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf1a9
shlq $0x4, %rax
addq 0x10(%rdi), %rax
retq
movb 0xb(%rdi), %cl
pushq $-0x1
popq %rdx
shll %cl, %edx
notl %edx
movl %esi, %eax
andl %edx, %eax
shlq $0x5, %rax
addq 0x18(%rdi), %rax
leaq 0x104aa(%rip), %rcx     # 0x1f670
cmpl $0x13, 0x18(%rax)
jne 0xf1d2
cmpq %rsi, 0x10(%rax)
je 0xf1a8
movslq 0x1c(%rax), %rdx
movq %rdx, %rdi
shlq $0x5, %rdi
addq %rdi, %rax
testq %rdx, %rdx
jne 0xf1c6
movq %rcx, %rax
retq