LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: fornum
static void fornum (LexState *ls, TString *varname, int line) {
  /* fornum -> NAME = exp1,exp1[,exp1] forbody */
  FuncState *fs = ls->fs;
  int base = fs->freereg;
  new_localvarliteral(ls, "(for index)");
  new_localvarliteral(ls, "(for limit)");
  new_localvarliteral(ls, "(for step)");
  new_localvar(ls, varname);
  checknext(ls, '=');
  exp1(ls);  /* initial value */
  checknext(ls, ',');
  exp1(ls);  /* limit */
  if (testnext(ls, ','))
    exp1(ls);  /* optional step */
  else {  /* default step = 1 */
    luaK_codek(fs, fs->freereg, luaK_intK(fs, 1));
    luaK_reserveregs(fs, 1);
  }
  forbody(ls, base, line, 1, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x3c(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1fea2(%rip), %rsi     # 0x34f37
movl $0xb, %edx
callq 0x13f90
movq -0x8(%rbp), %rdi
leaq 0x1fe99(%rip), %rsi     # 0x34f43
movl $0xb, %edx
callq 0x13f90
movq -0x8(%rbp), %rdi
leaq 0x1fe90(%rip), %rsi     # 0x34f4f
movl $0xa, %edx
callq 0x13f90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x141d0
movq -0x8(%rbp), %rdi
movl $0x3d, %esi
callq 0x12f20
movq -0x8(%rbp), %rdi
callq 0x152b0
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x12f20
movq -0x8(%rbp), %rdi
callq 0x152b0
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x12890
cmpl $0x0, %eax
je 0x15122
movq -0x8(%rbp), %rdi
callq 0x152b0
jmp 0x1515f
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x3c(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x22600
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %esi
movl %eax, %edx
callq 0x22240
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x22350
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x14(%rbp), %edx
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x152f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: forlist
static void forlist (LexState *ls, TString *indexname) {
  /* forlist -> NAME {,NAME} IN explist forbody */
  FuncState *fs = ls->fs;
  expdesc e;
  int nvars = 4;  /* gen, state, control, plus at least one declared var */
  int line;
  int base = fs->freereg;
  /* create control variables */
  new_localvarliteral(ls, "(for generator)");
  new_localvarliteral(ls, "(for state)");
  new_localvarliteral(ls, "(for control)");
  /* create declared variables */
  new_localvar(ls, indexname);
  while (testnext(ls, ',')) {
    new_localvar(ls, str_checkname(ls));
    nvars++;
  }
  checknext(ls, TK_IN);
  line = ls->linenumber;
  adjust_assign(ls, 3, explist(ls, &e), &e);
  luaK_checkstack(fs, 3);  /* extra space to call generator */
  forbody(ls, base, line, nvars - 3, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x4, -0x34(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x3c(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1fda1(%rip), %rsi     # 0x34f5a
movl $0xf, %edx
callq 0x13f90
movq -0x8(%rbp), %rdi
leaq 0x1fd9c(%rip), %rsi     # 0x34f6a
movl $0xb, %edx
callq 0x13f90
movq -0x8(%rbp), %rdi
leaq 0x1fd93(%rip), %rsi     # 0x34f76
movl $0xd, %edx
callq 0x13f90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x141d0
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x12890
cmpl $0x0, %eax
je 0x15235
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12af0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x141d0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x151fa
movq -0x8(%rbp), %rdi
movl $0x10c, %esi            # imm = 0x10C
callq 0x12f20
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x14930
movq -0x50(%rbp), %rdi
movl %eax, %edx
movl $0x3, %esi
leaq -0x30(%rbp), %rcx
callq 0x15430
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x222e0
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
movl -0x38(%rbp), %edx
movl -0x34(%rbp), %ecx
subl $0x3, %ecx
xorl %r8d, %r8d
callq 0x152f0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12ef0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x22950
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x13fd0
movq -0x8(%rbp), %rdi
movl $0x103, %esi            # imm = 0x103
callq 0x12f20
cmpl $0x0, -0x18(%rbp)
je 0x15352
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x28, %esi
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x21f20
movl %eax, -0x44(%rbp)
jmp 0x1535e
movq -0x38(%rbp), %rdi
callq 0x21ec0
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x12000
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x13fd0
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x22350
movq -0x8(%rbp), %rdi
callq 0x125c0
movq -0x38(%rbp), %rdi
callq 0x12fa0
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x21fc0
cmpl $0x0, -0x18(%rbp)
je 0x153ca
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x27, %esi
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x21f20
movl %eax, -0x40(%rbp)
jmp 0x15409
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x14(%rbp), %r8d
movl $0x29, %esi
xorl %ecx, %ecx
callq 0x21d20
movq -0x38(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x23b30
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movl $0x2a, %esi
movl $0x1fffe, %ecx          # imm = 0x1FFFE
callq 0x21f20
movl %eax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x3c(%rbp), %edx
addl $0x1, %edx
callq 0x22000
movq -0x38(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x23b30
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xd, (%rax)
je 0x1546d
movq -0x18(%rbp), %rax
cmpl $0xe, (%rax)
jne 0x154aa
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x15483
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x22670
cmpl $0x1, -0x24(%rbp)
jle 0x154a8
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
subl $0x1, %esi
callq 0x22350
jmp 0x154ee
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x154c0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22950
cmpl $0x0, -0x24(%rbp)
jle 0x154ec
movq -0x20(%rbp), %rax
movzbl 0x3c(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x22350
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x21be0
jmp 0x154ee
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: funcname
static int funcname (LexState *ls, expdesc *v) {
  /* funcname -> NAME {fieldsel} [':' NAME] */
  int ismethod = 0;
  singlevar(ls, v);
  while (ls->t.token == '.')
    fieldsel(ls, v);
  if (ls->t.token == ':') {
    ismethod = 1;
    fieldsel(ls, v);
  }
  return ismethod;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x146b0
movq -0x8(%rbp), %rax
cmpl $0x2e, 0x10(%rax)
jne 0x1553d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x144d0
jmp 0x15524
movq -0x8(%rbp), %rax
cmpl $0x3a, 0x10(%rax)
jne 0x1555b
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x144d0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: checkrepeated
static void checkrepeated (FuncState *fs, Labellist *ll, TString *label) {
  int i;
  for (i = fs->bl->firstlabel; i < ll->n; i++) {
    if (eqstr(label, ll->arr[i].name)) {
      const char *msg = luaO_pushfstring(fs->ls->L,
                          "label '%s' already defined on line %d",
                          getstr(label), ll->arr[i].line);
      semerror(fs->ls, msg);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x15612
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jne 0x15605
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rdx
addq $0x18, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
leaq 0x1f99b(%rip), %rsi     # 0x34f84
movb $0x0, %al
callq 0x114b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x14e90
jmp 0x15607
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15592
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movl $0x8, %eax
cmpl 0x8(%rcx), %eax
ja 0x1564b
movq -0x10(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jbe 0x1565b
movq -0x8(%rbp), %rdi
leaq 0x1f954(%rip), %rsi     # 0x34faa
callq 0x24390
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x12890
cmpl $0x0, %eax
je 0x156e7
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
addq $0x8, %rsi
callq 0x13990
cmpl $0xa, -0x48(%rbp)
je 0x156a2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdx
addq $0x8, %rdx
callq 0x157b0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movzwl 0xc6(%rax), %eax
addl %eax, %esi
movl $0xc8, %edx
leaq 0x1f6e7(%rip), %rcx     # 0x34db1
callq 0x12080
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
addl $0x1, %edx
leaq -0x50(%rbp), %rsi
callq 0x15620
jmp 0x1576f
movq -0x8(%rbp), %rdi
movl $0x3d, %esi
callq 0x12f20
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x14930
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x15741
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x54(%rbp), %edx
leaq -0x30(%rbp), %rcx
callq 0x15430
movl -0x54(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x1573f
movl -0x54(%rbp), %edx
subl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movzbl 0x3c(%rax), %ecx
subl %edx, %ecx
movb %cl, 0x3c(%rax)
jmp 0x1576d
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x22760
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdx
callq 0x22e80
jmp 0x157a5
jmp 0x1576f
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movzbl 0x3c(%rax), %edx
subl $0x1, %edx
leaq -0x30(%rbp), %rdi
movl $0x7, %esi
callq 0x11b90
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdx
callq 0x22e80
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: check_conflict
static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
  FuncState *fs = ls->fs;
  int extra = fs->freereg;  /* eventual position to save local variable */
  int conflict = 0;
  for (; lh; lh = lh->prev) {  /* check all previous assignments */
    if (lh->v.k == VINDEXED) {  /* assigning to a table? */
      /* table is the upvalue/local being assigned now? */
      if (lh->v.u.ind.vt == v->k && lh->v.u.ind.t == v->u.info) {
        conflict = 1;
        lh->v.u.ind.vt = VLOCAL;
        lh->v.u.ind.t = extra;  /* previous assignment will use safe copy */
      }
      /* index is the local being assigned? (index cannot be upvalue) */
      if (v->k == VLOCAL && lh->v.u.ind.idx == v->u.info) {
        conflict = 1;
        lh->v.u.ind.idx = extra;  /* previous assignment will use safe copy */
      }
    }
  }
  if (conflict) {
    /* copy upvalue/local value to a temporary (in position 'extra') */
    OpCode op = (v->k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
    luaK_codeABC(fs, op, extra, v->u.info, 0);
    luaK_reserveregs(fs, 1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x3c(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x15876
movq -0x10(%rbp), %rax
cmpl $0xa, 0x8(%rax)
jne 0x15864
movq -0x10(%rbp), %rax
movzbl 0x13(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x15833
movq -0x10(%rbp), %rax
movzbl 0x12(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x15833
movl $0x1, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb $0x8, 0x13(%rax)
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x12(%rax)
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jne 0x15862
movq -0x10(%rbp), %rax
movswl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x15862
movl $0x1, -0x28(%rbp)
movl -0x24(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x10(%rax)
jmp 0x15864
jmp 0x15866
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x157e2
cmpl $0x0, -0x28(%rbp)
je 0x158b9
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl $0x5, %eax
xorl %ecx, %ecx
cmpl $0x8, %edx
cmovel %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x24(%rbp), %edx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
xorl %r8d, %r8d
callq 0x21d20
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x22350
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x18(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
subq %rdx, %rcx
cmpq %rcx, %rax
jge 0x1590f
movq -0x18(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
subq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
subq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x48, %ecx
movq %rdx, %rsi
callq 0x10130
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movw 0xa(%rax), %cx
addw $0x1, %cx
movw %cx, 0xa(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x15a12
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x48, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
movq -0x8(%rbp), %rax
movw 0xa(%rax), %cx
addw $-0x1, %cx
movw %cx, 0xa(%rax)
jmp 0x159d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx)
movb %al, -0x19(%rbp)
je 0x15a62
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x15a6b
jmp 0x15ab7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movl $0x48, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
movq -0x8(%rbp), %rax
movw 0xa(%rax), %cx
addw $-0x1, %cx
movw %cx, 0xa(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x15a38
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x18(%rax)
jle 0x15af0
movq -0x8(%rbp), %rdi
callq 0xe0b0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x8, %edx
movl $0xd8, %ecx
callq 0x10130
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x54(%rax), %eax
andl $0x3, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x18(%rbp), %rax
movb $0x8, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl $0x48, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15c10
movq -0x8(%rbp), %rax
movl 0xc8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc8(%rax)
movq -0x8(%rbp), %rax
movl 0xbc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xbc(%rax)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xa8(%rax)
movq -0x18(%rbp), %rax
movl 0xbc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc0(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xc8(%rcx), %rcx
movq -0x8(%rcx), %rcx
movq %rcx, -0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x15d00
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: preinit_thread
static void preinit_thread (lua_State *L, global_State *g) {
  G(L) = g;
  L->stack = NULL;
  L->ci = NULL;
  L->nci = 0;
  L->stacksize = 0;
  L->twups = L;  /* thread has no upvalues */
  L->errorJmp = NULL;
  L->nCcalls = 0;
  L->hook = NULL;
  L->hookmask = 0;
  L->basehookcount = 0;
  L->allowhook = 1;
  resethookcount(L);
  L->openupval = NULL;
  L->nny = 1;
  L->status = LUA_OK;
  L->errfunc = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0xa(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xb8(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0xc6(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xa8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xbc(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0xcc(%rax)
movq -0x8(%rbp), %rax
movl 0xbc(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movw $0x1, 0xc4(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xb0(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x280, %ecx            # imm = 0x280
movq %rdx, %rsi
callq 0x10130
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x28, 0xb8(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x28, -0x14(%rbp)
jge 0x15d70
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x15d45
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movslq 0xb8(%rax), %rax
shlq $0x4, %rax
addq %rax, %rcx
addq $-0x50, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x42(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, 0x10(%rcx)
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x140, %rcx            # imm = 0x140
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0xd1e0
movq -0x10(%rbp), %rdi
callq 0x15e90
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xd8, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x15ea9
jmp 0x15ee6
movq -0x8(%rbp), %rcx
addq $0x60, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x159a0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0xb8(%rax), %rdx
shlq $0x4, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: makeseed
static unsigned int makeseed (lua_State *L) {
  char buff[4 * sizeof(size_t)];
  unsigned int h = luai_makeseed();
  int p = 0;
  addbuff(buff, p, L);  /* heap variable */
  addbuff(buff, p, &h);  /* local variable */
  addbuff(buff, p, luaO_nilobject);  /* global variable */
  addbuff(buff, p, &lua_newstate);  /* public function */
  lua_assert(p == sizeof(buff));
  return luaS_hash(buff, p, h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x5320
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x30(%rbp,%rax)
movslq -0x38(%rbp), %rax
addq $0x8, %rax
movl %eax, -0x38(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x48(%rbp)
movslq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x30(%rbp,%rax)
movslq -0x38(%rbp), %rax
addq $0x8, %rax
movl %eax, -0x38(%rbp)
leaq 0x1e8e2(%rip), %rax     # 0x34ab8
movq %rax, -0x50(%rbp)
movslq -0x38(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, -0x30(%rbp,%rax)
movslq -0x38(%rbp), %rax
addq $0x8, %rax
movl %eax, -0x38(%rbp)
leaq -0x309(%rip), %rax      # 0x15ef0
movq %rax, -0x58(%rbp)
movslq -0x38(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x30(%rbp,%rax)
movslq -0x38(%rbp), %rax
addq $0x8, %rax
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movslq -0x38(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x164e0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x15d00
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x16380
movq -0x8(%rbp), %rdi
callq 0x167d0
movq -0x8(%rbp), %rdi
callq 0x18550
movq -0x8(%rbp), %rdi
callq 0x24270
movq -0x18(%rbp), %rax
movb $0x1, 0x57(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x5d00
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xd0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0xd1e0
movq -0x8(%rbp), %rdi
callq 0xdbe0
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x162f0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x30(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq 0x3c(%rax), %rdx
shlq $0x3, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x10130
movq -0x8(%rbp), %rdi
callq 0x15e90
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x8(%rbp), %rsi
addq $-0x8, %rsi
movl $0x610, %edx            # imm = 0x610
xorl %ecx, %ecx
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lstate.c
// Function: init_registry
static void init_registry (lua_State *L, global_State *g) {
  TValue temp;
  /* create registry */
  Table *registry = luaH_new(L);
  sethvalue(L, &g->l_registry, registry);
  luaH_resize(L, registry, LUA_RIDX_LAST, 0);
  /* registry[LUA_RIDX_MAINTHREAD] = L */
  setthvalue(L, &temp, L);  /* temp = L */
  luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &temp);
  /* registry[LUA_RIDX_GLOBALS] = table of globals */
  sethvalue(L, &temp, luaH_new(L));  /* temp = new table (global table) */
  luaH_setint(L, registry, LUA_RIDX_GLOBALS, &temp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17540
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl $0x45, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x170a0
leaq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movl $0x48, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
leaq -0x20(%rbp), %rcx
callq 0x173f0
leaq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17540
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rax
movl $0x45, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x2, %edx
leaq -0x20(%rbp), %rcx
callq 0x173f0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
je 0x164c6
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x1a(%rbp)
jne 0x164c0
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x18(%rbp), %rdx
callq 0x5230
cmpl $0x0, %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
xorl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
shrq $0x5, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x1654c
movl -0x18(%rbp), %eax
shll $0x5, %eax
movl -0x18(%rbp), %ecx
shrl $0x2, %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq $0x1, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
xorl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x1650b
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
jne 0x165a6
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x164e0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0xa(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x30, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x1664b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movslq 0xc(%rax), %rdx
shlq $0x3, %rdx
movslq -0xc(%rbp), %rcx
shlq $0x3, %rcx
callq 0x10130
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x16649
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x16623
jmp 0x1664b
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x166ef
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
cmpq $0x0, -0x20(%rbp)
je 0x166df
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x2c(%rbp), %ecx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x2c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x16688
jmp 0x166e1
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x16652
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x16729
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movslq 0xc(%rax), %rdx
shlq $0x3, %rdx
movslq -0xc(%rbp), %rcx
shlq $0x3, %rcx
callq 0x10130
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x35, -0xc(%rbp)
jge 0x167cd
movl $0x0, -0x10(%rbp)
cmpl $0x2, -0x10(%rbp)
jge 0x167c0
movq -0x8(%rbp), %rax
addq $0x1e8, %rax            # imm = 0x1E8
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x167b3
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rdx
movq -0x8(%rbp), %rax
addq $0x1e8, %rax            # imm = 0x1E8
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x167b5
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1675c
jmp 0x167c2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1674f
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x80, %esi
callq 0x165c0
movq -0x8(%rbp), %rdi
leaq 0x1e7e9(%rip), %rsi     # 0x34fea
movl $0x11, %edx
callq 0x16890
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rsi
callq 0xd8d0
movl $0x0, -0x14(%rbp)
cmpl $0x35, -0x14(%rbp)
jge 0x16887
movl $0x0, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
jge 0x1687a
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rdx
movq -0x10(%rbp), %rax
addq $0x1e8, %rax            # imm = 0x1E8
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x16841
jmp 0x1687c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x16834
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x28, -0x20(%rbp)
ja 0x168c2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x16a70
movq %rax, -0x8(%rbp)
jmp 0x1690d
movabsq $0x7fffffffffffffe7, %rax # imm = 0x7FFFFFFFFFFFFFE7
cmpq %rax, -0x20(%rbp)
jb 0x168db
movq -0x10(%rbp), %rdi
callq 0x10220
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x16920
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
shlq $0x0, %rdx
callq 0x5300
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
shlq $0x0, %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0xd930
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0xa(%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, 0x18(%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x30, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movq -0x18(%rbp), %rdx
movl 0xc(%rdx), %edx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x16a42
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x16a24
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)