LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_requiref
LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
                               lua_CFunction openf, int glb) {
  luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
  lua_getfield(L, -1, modname);  /* _LOADED[modname] */
  if (!lua_toboolean(L, -1)) {  /* package not already loaded? */
    lua_pop(L, 1);  /* remove field */
    lua_pushcfunction(L, openf);
    lua_pushstring(L, modname);  /* argument to open function */
    lua_call(L, 1, 1);  /* call 'openf' to open module */
    lua_pushvalue(L, -1);  /* make copy of module (call result) */
    lua_setfield(L, -3, modname);  /* _LOADED[modname] = module */
  }
  lua_remove(L, -2);  /* remove _LOADED table */
  if (glb) {
    lua_pushvalue(L, -1);  /* copy of module */
    lua_setglobal(L, modname);  /* _G[modname] = module */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xd6b7(%rip), %rdx      # 0x233a9
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x15c69
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdx
callq 0x6895
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6333
testl %eax, %eax
jne 0x15d76
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x66a8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x656b
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6f67
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x606b
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movq %rbx, %rdx
callq 0x6c66
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5eb2
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
testl %ebp, %ebp
je 0x15dbb
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x606b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6aec
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_gsub
LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p,
                                                               const char *r) {
  const char *wild;
  size_t l = strlen(p);
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  while ((wild = strstr(s, p)) != NULL) {
    luaL_addlstring(&b, s, wild - s);  /* push prefix */
    luaL_addstring(&b, r);  /* push replacement in place of pattern */
    s = wild + l;  /* continue after 'p' */
  }
  luaL_addstring(&b, s);  /* push last suffix */
  luaL_pushresult(&b);
  return lua_tostring(L, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2038, %rsp           # imm = 0x2038
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x5140
movq %rax, %r13
leaq 0x38(%rsp), %rax
movq %rbx, 0x8(%rsp)
movq %rbx, -0x8(%rax)
movq %rax, -0x20(%rax)
movq $0x0, -0x10(%rax)
movq $0x2000, -0x18(%rax)    # imm = 0x2000
movq %r12, %rdi
movq %r15, %rsi
callq 0x54f0
testq %rax, %rax
je 0x15e76
movq %rax, %r14
leaq 0x18(%rsp), %rbp
movq %r14, %rbx
subq %r12, %rbx
je 0x15e50
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x151bd
movq %rax, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x5310
addq %rbx, 0x28(%rsp)
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x15382
movq %r14, %r12
addq %r13, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x54f0
movq %rax, %r14
testq %rax, %rax
jne 0x15e2a
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x15382
movq %rbx, %rdi
callq 0x153c0
movq 0x8(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x6359
addq $0x2038, %rsp           # imm = 0x2038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: l_alloc
static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
  (void)ud; (void)osize;  /* not used */
  if (nsize == 0) {
    free(ptr);
    return NULL;
  }
  else
    return realloc(ptr, nsize);
}

// Assembly:
movq %rsi, %rdi
testq %rcx, %rcx
je 0x15eec
movq %rcx, %rsi
jmp 0x53e0
pushq %rax
callq 0x5050
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: luaL_checkversion_
LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
  const lua_Number *v = lua_version(L);
  if (sz != LUAL_NUMSIZES)  /* check numeric types */
    luaL_error(L, "core and library have incompatible numeric types");
  if (v != lua_version(NULL))
    luaL_error(L, "multiple Lua VMs detected");
  else if (*v != ver)
    luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
                  ver, *v);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x5cff
movq %rax, %r14
cmpq $0x88, %r15
je 0x15f2d
leaq 0xd48e(%rip), %rsi      # 0x233b1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x14a62
xorl %edi, %edi
callq 0x5cff
cmpq %rax, %r14
je 0x15f53
leaq 0xd4a2(%rip), %rsi      # 0x233e2
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x14a62
movsd (%r14), %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm0, %xmm1
jne 0x15f66
jnp 0x15f80
leaq 0xd48f(%rip), %rsi      # 0x233fc
movq %rbx, %rdi
movb $0x2, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x14a62
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lauxlib.c
// Function: findfield
static int findfield (lua_State *L, int objidx, int level) {
  if (level == 0 || !lua_istable(L, -1))
    return 0;  /* not found */
  lua_pushnil(L);  /* start 'next' loop */
  while (lua_next(L, -2)) {  /* for each pair in table */
    if (lua_type(L, -2) == LUA_TSTRING) {  /* ignore non-string keys */
      if (lua_rawequal(L, objidx, -1)) {  /* found object? */
        lua_pop(L, 1);  /* remove value (but keep name) */
        return 1;
      }
      else if (findfield(L, objidx, level - 1)) {  /* try recursively */
        lua_remove(L, -2);  /* remove table (but keep name) */
        lua_pushliteral(L, ".");
        lua_insert(L, -2);  /* place '.' between the two names */
        lua_concat(L, 3);
        return 1;
      }
    }
    lua_pop(L, 1);  /* remove value */
  }
  return 0;  /* not found */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testl %edx, %edx
je 0x16095
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x608f
cmpl $0x5, %eax
jne 0x16095
movq %rbx, %rdi
callq 0x64cd
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x72df
testl %eax, %eax
je 0x16095
decl %r14d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x608f
cmpl $0x4, %eax
jne 0x1600f
movq %rbx, %rdi
movl %r15d, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6146
testl %eax, %eax
jne 0x1602f
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x15f8a
testl %eax, %eax
jne 0x16043
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x72df
testl %eax, %eax
jne 0x15fd7
jmp 0x16095
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movl $0x1, %ebp
jmp 0x16095
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5eb2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
leaq 0xd204(%rip), %rsi      # 0x2326d
movq %rbx, %rdi
callq 0x656b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5eb2
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7316
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/linit.c
// Function: luaL_openlibs
LUALIB_API void luaL_openlibs (lua_State *L) {
  const luaL_Reg *lib;
  /* "require" functions from 'loadedlibs' and set results to global table */
  for (lib = loadedlibs; lib->func; lib++) {
    luaL_requiref(L, lib->name, lib->func, 1);
    lua_pop(L, 1);  /* remove lib */
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1907d(%rip), %r14     # 0x2f140
leaq 0x28ee(%rip), %rdx      # 0x189b8
movq (%r14), %rsi
movq 0x18(%r14), %r15
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x15cd9
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
addq $0x10, %r14
movq %r15, %rdx
testq %r15, %r15
jne 0x160ca
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_nil
void luaK_nil (FuncState *fs, int from, int n) {
  Instruction *previous;
  int l = from + n - 1;  /* last register to set nil */
  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */
    previous = &fs->f->code[fs->pc-1];
    if (GET_OPCODE(*previous) == OP_LOADNIL) {  /* previous is LOADNIL? */
      int pfrom = GETARG_A(*previous);  /* get previous range */
      int pl = pfrom + GETARG_B(*previous);
      if ((pfrom <= from && from <= pl + 1) ||
          (from <= pfrom && pfrom <= l + 1)) {  /* can connect both? */
        if (pfrom < from) from = pfrom;  /* from = min(from, pfrom) */
        if (pl > l) l = pl;  /* l = max(l, pl) */
        SETARG_A(*previous, from);
        SETARG_B(*previous, l - from);
        return;
      }
    }  /* else go through */
  }
  luaK_codeABC(fs, OP_LOADNIL, from, n - 1, 0);  /* else no optimization */
}

// Assembly:
pushq %rbp
pushq %rbx
movslq 0x20(%rdi), %rax
cmpl 0x24(%rdi), %eax
jle 0x16167
movq (%rdi), %rcx
movq 0x38(%rcx), %rcx
movl -0x4(%rcx,%rax,4), %r8d
movl %r8d, %r9d
andl $0x3f, %r9d
cmpl $0x4, %r9d
jne 0x16167
leal (%rdx,%rsi), %r10d
movl %r8d, %r9d
shrl $0x6, %r9d
movzbl %r9b, %r11d
movl %r8d, %r9d
shrl $0x17, %r9d
cmpl %esi, %r11d
setg %bl
leal (%r11,%r9), %ebp
incl %ebp
cmpl %esi, %ebp
setl %bpl
orb %bl, %bpl
cmpb $0x1, %bpl
jne 0x16181
cmpl %esi, %r11d
setl %bl
cmpl %r10d, %r11d
setg %bpl
orb %bl, %bpl
je 0x16181
shll $0x6, %esi
shll $0x17, %edx
addl $0xff800000, %edx       # imm = 0xFF800000
orl %esi, %edx
orl $0x4, %edx
movl %edx, %esi
popq %rbx
popq %rbp
jmp 0x163c0
addl %esi, %edx
addl $0x1ff, %edx            # imm = 0x1FF
addl %r11d, %r9d
cmpl %esi, %r11d
cmovll %r11d, %esi
cmpl %r10d, %r9d
cmovll %edx, %r9d
andl $0x7fc004, %r8d         # imm = 0x7FC004
movzbl %sil, %edx
shll $0x6, %edx
orl %r8d, %edx
subl %esi, %r9d
shll $0x17, %r9d
orl %edx, %r9d
movl %r9d, -0x4(%rcx,%rax,4)
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_concat
void luaK_concat (FuncState *fs, int *l1, int l2) {
  if (l2 == NO_JUMP) return;  /* nothing to concatenate? */
  else if (*l1 == NO_JUMP)  /* no original list? */
    *l1 = l2;  /* 'l1' points to 'l2' */
  else {
    int list = *l1;
    int next;
    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */
      list = next;
    fixjump(fs, list, l2);  /* last element links to 'l2' */
  }
}

// Assembly:
cmpl $-0x1, %edx
je 0x16210
movl (%rsi), %ecx
cmpl $-0x1, %ecx
je 0x1620e
movq (%rdi), %rax
movq 0x38(%rax), %rax
movl %ecx, %esi
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
shrl $0xe, %ecx
leal -0x1ffff(%rcx), %r8d
cmpl $-0x1, %r8d
je 0x1620c
addl %esi, %ecx
addl $0xfffe0002, %ecx       # imm = 0xFFFE0002
cmpl $-0x1, %ecx
jne 0x161e7
jmp 0x16211
movl %edx, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_jump
int luaK_jump (FuncState *fs) {
  int jpc = fs->jpc;  /* save list of jumps to here */
  int j;
  fs->jpc = NO_JUMP;  /* no more jumps to here */
  j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);
  luaK_concat(fs, &j, jpc);  /* keep them on hold */
  return j;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x28(%rdi), %ebp
movl $0xffffffff, 0x28(%rdi) # imm = 0xFFFFFFFF
movl $0x7fff801e, %esi       # imm = 0x7FFF801E
callq 0x163c0
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x161d4
movl (%r14), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_patchlist
void luaK_patchlist (FuncState *fs, int list, int target) {
  if (target == fs->pc)  /* 'target' is current position? */
    luaK_patchtohere(fs, list);  /* add list to pending jumps */
  else {
    lua_assert(target < fs->pc);
    patchlistaux(fs, list, target, NO_REG, target);
  }
}

// Assembly:
movl %edx, %r8d
movl %esi, %edx
cmpl %r8d, 0x20(%rdi)
jne 0x162ec
movl %r8d, 0x24(%rdi)
leaq 0x28(%rdi), %rsi
jmp 0x161d4
movl %edx, %esi
movl %r8d, %edx
movl $0xff, %ecx
jmp 0x162f8
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: patchlistaux
static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,
                          int dtarget) {
  while (list != NO_JUMP) {
    int next = getjump(fs, list);
    if (patchtestreg(fs, list, reg))
      fixjump(fs, list, vtarget);
    else
      fixjump(fs, list, dtarget);  /* jump to default target */
    list = next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, 0x4(%rsp)
movl %ecx, (%rsp)
cmpl $-0x1, %esi
je 0x16366
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movq (%r12), %rax
movq 0x38(%rax), %rdi
movslq %r15d, %r13
movl (%rdi,%r13,4), %ebx
shrl $0xe, %ebx
leal -0x1ffff(%rbx), %ebp
movl %r13d, %esi
movl (%rsp), %edx
callq 0x1758d
testl %eax, %eax
movl %r14d, %edx
cmovel 0x4(%rsp), %edx
movq %r12, %rdi
movl %r13d, %esi
callq 0x16211
cmpl $-0x1, %ebp
je 0x16366
addl %ebx, %r15d
addl $0xfffe0002, %r15d      # imm = 0xFFFE0002
cmpl $-0x1, %r15d
jne 0x16319
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_patchclose
void luaK_patchclose (FuncState *fs, int list, int level) {
  level++;  /* argument is +1 to reserve 0 as non-op */
  for (; list != NO_JUMP; list = getjump(fs, list)) {
    lua_assert(GET_OPCODE(fs->f->code[list]) == OP_JMP &&
                (GETARG_A(fs->f->code[list]) == 0 ||
                 GETARG_A(fs->f->code[list]) >= level));
    SETARG_A(fs->f->code[list], level);
  }
}

// Assembly:
cmpl $-0x1, %esi
je 0x163bf
movq (%rdi), %rax
movq 0x38(%rax), %rax
shll $0x6, %edx
addl $0x40, %edx
andl $0x3fc0, %edx           # imm = 0x3FC0
movslq %esi, %rdi
movl (%rax,%rdi,4), %ecx
movl %ecx, %r8d
andl $0xffffc03f, %r8d       # imm = 0xFFFFC03F
orl %edx, %r8d
movl %r8d, (%rax,%rdi,4)
shrl $0xe, %ecx
leal -0x1ffff(%rcx), %edi
cmpl $-0x1, %edi
je 0x163bf
addl %ecx, %esi
addl $0xfffe0002, %esi       # imm = 0xFFFE0002
cmpl $-0x1, %esi
jne 0x1638d
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_code
static int luaK_code (FuncState *fs, Instruction i) {
  Proto *f = fs->f;
  dischargejpc(fs);  /* 'pc' will change */
  /* put new instruction in code array */
  luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction,
                  MAX_INT, "opcodes");
  f->code[fs->pc] = i;
  /* save corresponding line information */
  luaM_growvector(fs->ls->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
                  MAX_INT, "opcodes");
  f->lineinfo[fs->pc] = fs->ls->lastline;
  return fs->pc++;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %r14
movl 0x28(%rdi), %esi
movl 0x20(%rdi), %edx
movl $0xff, %ecx
movl %edx, %r8d
callq 0x162f8
movl $0xffffffff, 0x28(%rbx) # imm = 0xFFFFFFFF
movl 0x20(%rbx), %ecx
cmpl 0x18(%r14), %ecx
jge 0x163f5
movq 0x38(%r14), %rax
jmp 0x16423
leaq 0x18(%r14), %rdx
movq 0x10(%rbx), %rax
movq 0x38(%rax), %rdi
movq 0x38(%r14), %rsi
leaq 0xd267(%rip), %r9       # 0x23673
movl $0x4, %ecx
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
callq 0xb838
movq %rax, 0x38(%r14)
movl 0x20(%rbx), %ecx
movslq %ecx, %rcx
movl %ebp, (%rax,%rcx,4)
movl 0x20(%rbx), %ecx
cmpl 0x1c(%r14), %ecx
jge 0x16438
movq 0x48(%r14), %rax
jmp 0x16466
leaq 0x1c(%r14), %rdx
movq 0x10(%rbx), %rax
movq 0x38(%rax), %rdi
movq 0x48(%r14), %rsi
leaq 0xd224(%rip), %r9       # 0x23673
movl $0x4, %ecx
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
callq 0xb838
movq %rax, 0x48(%r14)
movl 0x20(%rbx), %ecx
movq 0x10(%rbx), %rdx
movl 0x8(%rdx), %edx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x20(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_codek
int luaK_codek (FuncState *fs, int reg, int k) {
  if (k <= MAXARG_Bx)
    return luaK_codeABx(fs, OP_LOADK, reg, k);
  else {
    int p = luaK_codeABx(fs, OP_LOADKX, reg, 0);
    codeextraarg(fs, k);
    return p;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
shll $0x6, %esi
cmpl $0x3ffff, %edx          # imm = 0x3FFFF
jg 0x164a9
shll $0xe, %ebp
orl %ebp, %esi
orl $0x1, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x163c0
orl $0x2, %esi
movq %rbx, %rdi
callq 0x163c0
movl %eax, %r14d
shll $0x6, %ebp
orl $0x2e, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x163c0
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_checkstack
void luaK_checkstack (FuncState *fs, int n) {
  int newstack = fs->freereg + n;
  if (newstack > fs->f->maxstacksize) {
    if (newstack >= MAXREGS)
      luaX_syntaxerror(fs->ls,
        "function or expression needs too many registers");
    fs->f->maxstacksize = cast_byte(newstack);
  }
}

// Assembly:
movzbl 0x3c(%rdi), %eax
addl %esi, %eax
movq (%rdi), %rcx
movzbl 0xc(%rcx), %edx
cmpl %edx, %eax
jle 0x164ea
cmpl $0xff, %eax
jae 0x164eb
movb %al, 0xc(%rcx)
retq
pushq %rax
movq 0x10(%rdi), %rdi
leaq 0xd131(%rip), %rsi      # 0x23628
callq 0x1790e
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_intK
int luaK_intK (FuncState *fs, lua_Integer n) {
  TValue k, o;
  setpvalue(&k, cast(void*, cast(size_t, n)));
  setivalue(&o, n);
  return addk(fs, &k, &o);
}

// Assembly:
subq $0x28, %rsp
leaq 0x18(%rsp), %rax
movq %rsi, (%rax)
movl $0x2, 0x8(%rax)
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movl $0x13, 0x8(%rdx)
movq %rax, %rsi
callq 0x16539
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_setreturns
void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
  if (e->k == VCALL) {  /* expression is an open function call? */
    SETARG_C(getinstruction(fs, e), nresults + 1);
  }
  else if (e->k == VVARARG) {
    Instruction *pc = &getinstruction(fs, e);
    SETARG_B(*pc, nresults + 1);
    SETARG_A(*pc, fs->freereg);
    luaK_reserveregs(fs, 1);
  }
  else lua_assert(nresults == LUA_MULTRET);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0xe, %eax
je 0x167c2
cmpl $0xd, %eax
jne 0x167fc
movq (%rbx), %rax
movq 0x38(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0xff803fff, %esi       # imm = 0xFF803FFF
andl (%rax,%rcx,4), %esi
shll $0xe, %edx
addl $0x4000, %edx           # imm = 0x4000
andl $0x7fc000, %edx         # imm = 0x7FC000
orl %esi, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x167fc
movq (%rbx), %rax
movq 0x38(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0x7fc03f, %esi         # imm = 0x7FC03F
andl (%rax,%rcx,4), %esi
shll $0x17, %edx
orl %esi, %edx
movzbl 0x3c(%rbx), %esi
shll $0x6, %esi
addl %esi, %edx
addl $0x800000, %edx         # imm = 0x800000
movl %edx, (%rax,%rcx,4)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x164cf
incb 0x3c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_setoneret
void luaK_setoneret (FuncState *fs, expdesc *e) {
  if (e->k == VCALL) {  /* expression is an open function call? */
    /* already returns 1 value */
    lua_assert(GETARG_C(getinstruction(fs, e)) == 2);
    e->k = VNONRELOC;  /* result has fixed position */
    e->u.info = GETARG_A(getinstruction(fs, e));
  }
  else if (e->k == VVARARG) {
    SETARG_B(getinstruction(fs, e), 2);
    e->k = VRELOCABLE;  /* can relocate its simple result */
  }
}

// Assembly:
movl (%rsi), %eax
cmpl $0xe, %eax
je 0x16828
cmpl $0xd, %eax
jne 0x1684a
movl $0x7, (%rsi)
movq (%rdi), %rax
movq 0x38(%rax), %rax
movslq 0x8(%rsi), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x6, %eax
movzbl %al, %eax
movl %eax, 0x8(%rsi)
retq
movq (%rdi), %rax
movq 0x38(%rax), %rax
movslq 0x8(%rsi), %rcx
movl $0x7fffff, %edx         # imm = 0x7FFFFF
andl (%rax,%rcx,4), %edx
orl $0x1000000, %edx        # imm = 0x1000000
movl %edx, (%rax,%rcx,4)
movl $0xc, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_dischargevars
void luaK_dischargevars (FuncState *fs, expdesc *e) {
  switch (e->k) {
    case VLOCAL: {  /* already in a register */
      e->k = VNONRELOC;  /* becomes a non-relocatable value */
      break;
    }
    case VUPVAL: {  /* move value to some (pending) register */
      e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0);
      e->k = VRELOCABLE;
      break;
    }
    case VINDEXED: {
      OpCode op;
      freereg(fs, e->u.ind.idx);
      if (e->u.ind.vt == VLOCAL) {  /* is 't' in a register? */
        freereg(fs, e->u.ind.t);
        op = OP_GETTABLE;
      }
      else {
        lua_assert(e->u.ind.vt == VUPVAL);
        op = OP_GETTABUP;  /* 't' is in an upvalue */
      }
      e->u.info = luaK_codeABC(fs, op, 0, e->u.ind.t, e->u.ind.idx);
      e->k = VRELOCABLE;
      break;
    }
    case VVARARG: case VCALL: {
      luaK_setoneret(fs, e);
      break;
    }
    default: break;  /* there is one value available (somewhere) */
  }
}

// Assembly:
pushq %rbx
movl (%rsi), %eax
addl $-0x8, %eax
cmpl $0x6, %eax
ja 0x168d5
movq %rsi, %rbx
leaq 0xcce0(%rip), %rcx      # 0x23540
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rsi
popq %rbx
jmp 0x167fe
movswl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0x16887
movzbl 0x3a(%rdi), %ecx
cmpl %eax, %ecx
jg 0x16887
decb 0x3c(%rdi)
movl $0x6, %eax
cmpb $0x8, 0xb(%rbx)
jne 0x168a2
movb 0x3a(%rdi), %cl
movl $0x7, %eax
cmpb 0xa(%rbx), %cl
ja 0x168a2
decb 0x3c(%rdi)
movzbl 0xa(%rbx), %ecx
movswl 0x8(%rbx), %esi
shll $0x17, %ecx
orl %eax, %ecx
shll $0xe, %esi
orl %ecx, %esi
jmp 0x168c7
movl $0x7, (%rbx)
jmp 0x168d5
movl 0x8(%rbx), %esi
shll $0x17, %esi
orl $0x5, %esi
callq 0x163c0
movl %eax, 0x8(%rbx)
movl $0xc, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_exp2nextreg
void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
  luaK_dischargevars(fs, e);
  freeexp(fs, e);
  luaK_reserveregs(fs, 1);
  exp2reg(fs, e, fs->freereg - 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1684b
cmpl $0x7, (%rbx)
jne 0x16901
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0x16901
movzbl 0x3a(%r14), %ecx
cmpl %ecx, %eax
jl 0x16901
decb 0x3c(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x164cf
movb 0x3c(%r14), %al
incb %al
movb %al, 0x3c(%r14)
movzbl %al, %edx
decl %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1692c
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: exp2reg
static void exp2reg (FuncState *fs, expdesc *e, int reg) {
  discharge2reg(fs, e, reg);
  if (e->k == VJMP)  /* expression itself is a test? */
    luaK_concat(fs, &e->t, e->u.info);  /* put this jump in 't' list */
  if (hasjumps(e)) {
    int final;  /* position after whole expression */
    int p_f = NO_JUMP;  /* position of an eventual LOAD false */
    int p_t = NO_JUMP;  /* position of an eventual LOAD true */
    if (need_value(fs, e->t) || need_value(fs, e->f)) {
      int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
      p_f = code_loadbool(fs, reg, 0, 1);
      p_t = code_loadbool(fs, reg, 1, 0);
      luaK_patchtohere(fs, fj);
    }
    final = luaK_getlabel(fs);
    patchlistaux(fs, e->f, final, reg, p_f);
    patchlistaux(fs, e->t, final, reg, p_t);
  }
  e->f = e->t = NO_JUMP;
  e->u.info = reg;
  e->k = VNONRELOC;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x175fc
cmpl $0xb, (%rbx)
jne 0x16958
leaq 0x10(%rbx), %rsi
movl 0x8(%rbx), %edx
movq %r14, %rdi
callq 0x161d4
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %r15d
cmpl %r15d, %esi
je 0x16a29
movq %r14, %rdi
callq 0x17706
testl %eax, %eax
jne 0x16987
movq %r14, %rdi
movl %r15d, %esi
callq 0x17706
testl %eax, %eax
je 0x16a49
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $0xb, (%rbx)
je 0x1699d
movq %r14, %rdi
callq 0x16257
movl %eax, %r15d
movl 0x20(%r14), %eax
movl %eax, 0x24(%r14)
movl %ebp, %r12d
shll $0x6, %r12d
movl %r12d, %esi
orl $0x4003, %esi           # imm = 0x4003
movq %r14, %rdi
callq 0x163c0
movl %eax, %r13d
movl 0x20(%r14), %eax
movl %eax, 0x24(%r14)
orl $0x800003, %r12d        # imm = 0x800003
movq %r14, %rdi
movl %r12d, %esi
callq 0x163c0
movl %eax, 0x4(%rsp)
movl 0x20(%r14), %eax
movl %eax, 0x24(%r14)
leaq 0x28(%r14), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x161d4
movl 0x14(%rbx), %r15d
movl 0x20(%r14), %r12d
movl %r12d, 0x24(%r14)
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
movl %ebp, %ecx
movl %r13d, %r8d
callq 0x162f8
movl 0x10(%rbx), %esi
movq %r14, %rdi
movl %r12d, %edx
movl %ebp, %ecx
movl 0x4(%rsp), %r8d
callq 0x162f8
movq $-0x1, 0x10(%rbx)
movl %ebp, 0x8(%rbx)
movl $0x7, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x169f9
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_exp2anyreg
int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
  luaK_dischargevars(fs, e);
  if (e->k == VNONRELOC) {  /* expression already has a register? */
    if (!hasjumps(e))  /* no jumps? */
      return e->u.info;  /* result is already in a register */
    if (e->u.info >= fs->nactvar) {  /* reg. is not a local? */
      exp2reg(fs, e, e->u.info);  /* put final result in it */
      return e->u.info;
    }
  }
  luaK_exp2nextreg(fs, e);  /* otherwise, use next available register */
  return e->u.info;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1684b
cmpl $0x7, (%rbx)
jne 0x16a86
movl 0x10(%rbx), %eax
leaq 0x8(%rbx), %r15
cmpl 0x14(%rbx), %eax
je 0x16a98
movl (%r15), %edx
movzbl 0x3a(%r14), %eax
cmpl %eax, %edx
jge 0x16aa1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x168d7
addq $0x8, %rbx
movq %rbx, %r15
movl (%r15), %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1692c
jmp 0x16a98
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_exp2RK
int luaK_exp2RK (FuncState *fs, expdesc *e) {
  luaK_exp2val(fs, e);
  switch (e->k) {  /* move constants to 'k' */
    case VTRUE: e->u.info = boolK(fs, 1); goto vk;
    case VFALSE: e->u.info = boolK(fs, 0); goto vk;
    case VNIL: e->u.info = nilK(fs); goto vk;
    case VKINT: e->u.info = luaK_intK(fs, e->u.ival); goto vk;
    case VKFLT: e->u.info = luaK_numberK(fs, e->u.nval); goto vk;
    case VK:
     vk:
      e->k = VK;
      if (e->u.info <= MAXINDEXRK)  /* constant fits in 'argC'? */
        return RKASK(e->u.info);
      else break;
    default: break;
  }
  /* not a constant in the right range: put it in a register */
  return luaK_exp2anyreg(fs, e);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x16ac4
movl (%rbx), %eax
decl %eax
cmpl $0x5, %eax
ja 0x16bb1
leaq 0xca61(%rip), %rcx      # 0x2355c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x18(%rsp), %rdx
movl $0x0, 0x8(%rdx)
movq 0x10(%r14), %rax
movq 0x50(%rax), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x45, 0x8(%rsi)
jmp 0x16b92
movsd 0x8(%rbx), %xmm0
leaq 0x8(%rsp), %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
jmp 0x16b68
leaq 0x8(%rsp), %rdx
movl $0x0, (%rdx)
movl $0x1, 0x8(%rdx)
jmp 0x16b68
movl 0x8(%rbx), %eax
jmp 0x16b9d
movl $0x1, %eax
leaq 0x8(%rsp), %rdx
movl %eax, (%rdx)
movl %eax, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
jmp 0x16b95
movq 0x8(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x2, 0x8(%rsi)
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movl $0x13, 0x8(%rdx)
movq %r14, %rdi
callq 0x16539
movl %eax, 0x8(%rbx)
movl $0x4, (%rbx)
cmpl $0xff, %eax
jg 0x16bb1
orl $0x100, %eax            # imm = 0x100
jmp 0x16bbc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16a59
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_storevar
void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
  switch (var->k) {
    case VLOCAL: {
      freeexp(fs, ex);
      exp2reg(fs, ex, var->u.info);  /* compute 'ex' into proper place */
      return;
    }
    case VUPVAL: {
      int e = luaK_exp2anyreg(fs, ex);
      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0);
      break;
    }
    case VINDEXED: {
      OpCode op = (var->u.ind.vt == VLOCAL) ? OP_SETTABLE : OP_SETTABUP;
      int e = luaK_exp2RK(fs, ex);
      luaK_codeABC(fs, op, var->u.ind.t, var->u.ind.idx, e);
      break;
    }
    default: lua_assert(0);  /* invalid var kind to store */
  }
  freeexp(fs, ex);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0xa, %eax
je 0x16c3b
cmpl $0x9, %eax
je 0x16c1f
cmpl $0x8, %eax
jne 0x16c79
cmpl $0x7, (%r14)
jne 0x16c05
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x16c05
movzbl 0x3a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x16c05
decb 0x3c(%rbx)
movl 0x8(%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1692c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16a59
movl 0x8(%r15), %esi
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
orl $0x9, %esi
jmp 0x16c71
xorl %r12d, %r12d
cmpb $0x8, 0xb(%r15)
sete %r12b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16ad5
movl %eax, %esi
movzbl 0xa(%r15), %eax
shll $0x6, %eax
leal (%rax,%r12,2), %eax
movl 0x8(%r15), %ecx
shll $0x17, %ecx
orl %eax, %ecx
shll $0xe, %esi
orl %ecx, %esi
orl $0x8, %esi
movq %rbx, %rdi
callq 0x163c0
cmpl $0x7, (%r14)
jne 0x16c94
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x16c94
movzbl 0x3a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x16c94
decb 0x3c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_self
void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
  int ereg;
  luaK_exp2anyreg(fs, e);
  ereg = e->u.info;  /* register where 'e' was placed */
  freeexp(fs, e);
  e->u.info = fs->freereg;  /* base register for op_self */
  e->k = VNONRELOC;  /* self expression has a fixed register */
  luaK_reserveregs(fs, 2);  /* function and 'self' produced by op_self */
  luaK_codeABC(fs, OP_SELF, e->u.info, ereg, luaK_exp2RK(fs, key));
  freeexp(fs, key);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x16a59
movl (%r15), %eax
movl 0x8(%r15), %ebp
xorl $0x7, %eax
movl %ebp, %ecx
andl $0x100, %ecx            # imm = 0x100
orl %eax, %ecx
jne 0x16cd6
movzbl 0x3a(%rbx), %eax
cmpl %eax, %ebp
jl 0x16cd6
decb 0x3c(%rbx)
movzbl 0x3c(%rbx), %eax
movl %eax, 0x8(%r15)
movl $0x7, (%r15)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x164cf
addb $0x2, 0x3c(%rbx)
movl 0x8(%r15), %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16ad5
shll $0x6, %r15d
shll $0x17, %ebp
orl %r15d, %ebp
shll $0xe, %eax
orl %eax, %ebp
orl $0xc, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x163c0
cmpl $0x7, (%r14)
jne 0x16d3c
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x16d3c
movzbl 0x3a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x16d3c
decb 0x3c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_goiftrue
void luaK_goiftrue (FuncState *fs, expdesc *e) {
  int pc;  /* pc of new jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VJMP: {  /* condition? */
      negatecondition(fs, e);  /* jump when it is false */
      pc = e->u.info;  /* save jump position */
      break;
    }
    case VK: case VKFLT: case VKINT: case VTRUE: {
      pc = NO_JUMP;  /* always true; do nothing */
      break;
    }
    default: {
      pc = jumponcond(fs, e, 0);  /* jump when false */
      break;
    }
  }
  luaK_concat(fs, &e->f, pc);  /* insert new jump in false list */
  luaK_patchtohere(fs, e->t);  /* true list jumps to here (to go through) */
  e->t = NO_JUMP;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1684b
movl (%rbx), %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leal -0x4(%rax), %ecx
cmpl $0x3, %ecx
jb 0x16dd3
cmpl $0x2, %eax
je 0x16dd3
cmpl $0xb, %eax
jne 0x16da0
movq (%r14), %rcx
movslq 0x8(%rbx), %rdx
leaq (,%rdx,4), %rax
addq 0x38(%rcx), %rax
testq %rdx, %rdx
jle 0x16d9c
movl -0x4(%rax), %ecx
movl %ecx, %edx
andl $0x3f, %edx
leaq 0xbb4a(%rip), %rsi      # 0x228e0
cmpb $0x0, (%rdx,%rsi)
js 0x16db1
movl (%rax), %ecx
jmp 0x16db5
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x16e05
movl %eax, %edx
jmp 0x16dd3
addq $-0x4, %rax
movl %ecx, %edx
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
xorl %esi, %esi
testl $0x3fc0, %ecx           # imm = 0x3FC0
sete %sil
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax)
movl 0x8(%rbx), %edx
leaq 0x14(%rbx), %rsi
movq %r14, %rdi
callq 0x161d4
movl 0x10(%rbx), %edx
movl 0x20(%r14), %eax
movl %eax, 0x24(%r14)
leaq 0x28(%r14), %rsi
movq %r14, %rdi
callq 0x161d4
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: jumponcond
static int jumponcond (FuncState *fs, expdesc *e, int cond) {
  if (e->k == VRELOCABLE) {
    Instruction ie = getinstruction(fs, e);
    if (GET_OPCODE(ie) == OP_NOT) {
      fs->pc--;  /* remove previous OP_NOT */
      return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);
    }
    /* else go through */
  }
  discharge2anyreg(fs, e);
  freeexp(fs, e);
  return condjump(fs, OP_TESTSET, NO_REG, e->u.info, cond);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0xc, (%rsi)
jne 0x16e4c
movq (%rbx), %rax
movq 0x38(%rax), %rax
movslq 0x8(%r14), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
andl $0x3f, %ecx
cmpl $0x1b, %ecx
jne 0x16e4c
decl 0x20(%rbx)
xorl %esi, %esi
testl %ebp, %ebp
sete %sil
shrl $0x11, %eax
andl $-0x40, %eax
shll $0xe, %esi
orl %eax, %esi
orl $0x22, %esi
movq %rbx, %rdi
jmp 0x16e89
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1776a
cmpl $0x7, (%r14)
jne 0x16e72
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x16e72
movzbl 0x3a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x16e72
decb 0x3c(%rbx)
movl 0x8(%r14), %eax
shll $0x17, %eax
shll $0xe, %ebp
orl %eax, %ebp
orl $0x3fe3, %ebp           # imm = 0x3FE3
movq %rbx, %rdi
movl %ebp, %esi
callq 0x163c0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x16257
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_goiffalse
void luaK_goiffalse (FuncState *fs, expdesc *e) {
  int pc;  /* pc of new jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VJMP: {
      pc = e->u.info;  /* already jump if true */
      break;
    }
    case VNIL: case VFALSE: {
      pc = NO_JUMP;  /* always false; do nothing */
      break;
    }
    default: {
      pc = jumponcond(fs, e, 1);  /* jump if true */
      break;
    }
  }
  luaK_concat(fs, &e->t, pc);  /* insert new jump in 't' list */
  luaK_patchtohere(fs, e->f);  /* false list jumps to here (to go through) */
  e->f = NO_JUMP;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1684b
movl (%rbx), %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl $0x1, %eax
je 0x16ed6
cmpl $0x3, %eax
je 0x16ed6
cmpl $0xb, %eax
jne 0x16ec4
movl 0x8(%rbx), %edx
jmp 0x16ed6
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x16e05
movl %eax, %edx
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x161d4
movl 0x14(%rbx), %edx
movl 0x20(%r14), %eax
movl %eax, 0x24(%r14)
leaq 0x28(%r14), %rsi
movq %r14, %rdi
callq 0x161d4
movl $0xffffffff, 0x14(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_indexed
void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
  lua_assert(!hasjumps(t) && (vkisinreg(t->k) || t->k == VUPVAL));
  t->u.ind.t = t->u.info;  /* register or upvalue index */
  t->u.ind.idx = luaK_exp2RK(fs, k);  /* R/K index for key */
  t->u.ind.vt = (t->k == VUPVAL) ? VUPVAL : VLOCAL;
  t->k = VINDEXED;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movb 0x8(%rsi), %al
movb %al, 0xa(%rsi)
movq %rdx, %rsi
callq 0x16ad5
movw %ax, 0x8(%rbx)
cmpl $0x9, (%rbx)
sete %al
orb $0x8, %al
movb %al, 0xb(%rbx)
movl $0xa, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_prefix
void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) {
  static expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP};  /* fake 2nd operand */
  switch (op) {
    case OPR_MINUS: case OPR_BNOT:
      if (constfolding(fs, op + LUA_OPUNM, e, &ef))
        break;
      /* FALLTHROUGH */
    case OPR_LEN:
      codeunexpval(fs, cast(OpCode, op + OP_UNM), e, line);
      break;
    case OPR_NOT: codenot(fs, e); break;
    default: lua_assert(0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x2, %esi
jb 0x16f56
je 0x16fcf
cmpl $0x3, %r15d
je 0x16f70
jmp 0x16fc4
leal 0xc(%r15), %esi
leaq 0x1934f(%rip), %rcx     # 0x302b0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x170d3
testl %eax, %eax
jne 0x16fc4
addl $0x19, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16a59
cmpl $0x7, (%r14)
jne 0x16f9a
movl 0x8(%r14), %ecx
btl $0x8, %ecx
jb 0x16f9a
movzbl 0x3a(%rbx), %edx
cmpl %edx, %ecx
jl 0x16f9a
decb 0x3c(%rbx)
shll $0x17, %eax
orl %r15d, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x163c0
movl %eax, 0x8(%r14)
movl $0xc, (%r14)
movq (%rbx), %rax
movq 0x48(%rax), %rax
movslq 0x20(%rbx), %rcx
movl %ebp, -0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1684b
movl (%r14), %eax
decl %eax
cmpl $0xb, %eax
ja 0x170a5
leaq 0xc585(%rip), %rcx      # 0x23574
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, (%r14)
jmp 0x170a5
movl $0x2, (%r14)
jmp 0x170a5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1776a
cmpl $0x7, (%r14)
jne 0x17036
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x17036
movzbl 0x3a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x17036
decb 0x3c(%rbx)
movl 0x8(%r14), %esi
shll $0x17, %esi
orl $0x1b, %esi
movq %rbx, %rdi
callq 0x163c0
movl %eax, 0x8(%r14)
movl $0xc, (%r14)
jmp 0x170a5
movq (%rbx), %rcx
movslq 0x8(%r14), %rdx
leaq (,%rdx,4), %rax
addq 0x38(%rcx), %rax
testq %rdx, %rdx
jle 0x17082
movl -0x4(%rax), %ecx
movl %ecx, %edx
andl $0x3f, %edx
leaq 0xb864(%rip), %rsi      # 0x228e0
cmpb $0x0, (%rdx,%rsi)
js 0x17086
movl (%rax), %ecx
jmp 0x1708a
addq $-0x4, %rax
movl %ecx, %edx
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
xorl %esi, %esi
testl $0x3fc0, %ecx           # imm = 0x3FC0
sete %sil
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax)
movl 0x10(%r14), %esi
movl 0x14(%r14), %eax
movl %esi, 0x14(%r14)
movl %eax, 0x10(%r14)
movq %rbx, %rdi
callq 0x177a5
movl 0x10(%r14), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x177a5
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: constfolding
static int constfolding (FuncState *fs, int op, expdesc *e1, expdesc *e2) {
  TValue v1, v2, res;
  if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2))
    return 0;  /* non-numeric operands or not safe to fold */
  luaO_arith(fs->ls->L, op, &v1, &v2, &res);  /* does operation */
  if (ttisinteger(&res)) {
    e1->k = VKINT;
    e1->u.ival = ivalue(&res);
  }
  else {  /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */
    lua_Number n = fltvalue(&res);
    if (luai_numisnan(n) || n == 0)
      return 0;
    e1->k = VKFLT;
    e1->u.nval = n;
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl 0x10(%rdx), %eax
xorl %ebx, %ebx
cmpl 0x14(%rdx), %eax
jne 0x17249
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl (%rdx), %eax
cmpl $0x6, %eax
je 0x1710e
cmpl $0x5, %eax
jne 0x17249
movl $0x3, %edx
xorl %eax, %eax
jmp 0x17115
movl $0x13, %edx
movb $0x1, %al
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movl %edx, 0x28(%rsp)
movl 0x10(%rcx), %edx
cmpl 0x14(%rcx), %edx
jne 0x17249
movl (%rcx), %edx
cmpl $0x6, %edx
je 0x1714a
cmpl $0x5, %edx
jne 0x17249
movl $0x3, %edx
xorl %esi, %esi
jmp 0x17152
movl $0x13, %edx
movb $0x1, %sil
movq 0x8(%rcx), %xmm1
movq %xmm1, 0x10(%rsp)
movl %edx, 0x18(%rsp)
cmpl $0xd, %ebp
ja 0x171f1
movl $0x2f80, %ecx           # imm = 0x2F80
btl %ebp, %ecx
jae 0x1717f
testb %al, %al
je 0x171af
movsd %xmm0, (%rsp)
jmp 0x171c9
movl $0x68, %eax
btl %ebp, %eax
jae 0x171f1
testb %sil, %sil
je 0x1719b
movq %xmm1, %rax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
xorpd %xmm0, %xmm0
cmpneqsd %xmm1, %xmm0
movq %xmm0, %r12
andl $0x1, %r12d
jmp 0x171ec
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
xorl %r12d, %r12d
xorl %edx, %edx
callq 0x116b2
testl %eax, %eax
je 0x171ec
movl 0x18(%rsp), %edx
movl $0x1, %r12d
cmpl $0x13, %edx
je 0x171ec
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0x116b2
xorl %r12d, %r12d
testl %eax, %eax
setne %r12b
testl %r12d, %r12d
je 0x17249
movq 0x10(%r15), %rax
movq 0x38(%rax), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rsp, %r15
movl %ebp, %esi
movq %r15, %r8
callq 0xb9c1
cmpl $0x13, 0x8(%r15)
jne 0x17228
movl $0x6, (%r14)
movq (%rsp), %rax
movq %rax, 0x8(%r14)
jmp 0x17244
movsd (%rsp), %xmm0
pxor %xmm1, %xmm1
ucomisd %xmm0, %xmm1
je 0x17249
movl $0x5, (%r14)
movsd %xmm0, 0x8(%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: codebinexpval
static void codebinexpval (FuncState *fs, OpCode op,
                           expdesc *e1, expdesc *e2, int line) {
  int rk1 = luaK_exp2RK(fs, e1);  /* both operands are "RK" */
  int rk2 = luaK_exp2RK(fs, e2);
  freeexps(fs, e1, e2);
  e1->u.info = luaK_codeABC(fs, op, 0, rk1, rk2);  /* generate opcode */
  e1->k = VRELOCABLE;  /* all those operations are relocatable */
  luaK_fixline(fs, line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, 0x4(%rsp)
movq %rcx, %r12
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rsi
callq 0x16ad5
movl %eax, %r13d
movq %r14, %rdi
movq %r12, %rsi
callq 0x16ad5
movl %eax, %ebx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x177f6
shll $0x17, %r13d
orl %ebp, %r13d
shll $0xe, %ebx
orl %r13d, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x163c0
movl %eax, 0x8(%r15)
movl $0xc, (%r15)
movq (%r14), %rax
movq 0x48(%rax), %rax
movslq 0x20(%r14), %rcx
movl 0x4(%rsp), %edx
movl %edx, -0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_setlist
void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;
  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
  lua_assert(tostore != 0 && tostore <= LFIELDS_PER_FLUSH);
  if (c <= MAXARG_C)
    luaK_codeABC(fs, OP_SETLIST, base, b, c);
  else if (c <= MAXARG_Ax) {
    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
    codeextraarg(fs, c);
  }
  else
    luaX_syntaxerror(fs->ls, "constructor too long");
  fs->freereg = base + 1;  /* free registers with list values */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rdx), %eax
cltq
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rsi
sarq $0x24, %rsi
shrq $0x3f, %rax
leal (%rsi,%rax), %ebp
incl %ebp
movl %ecx, %edi
shll $0x17, %edi
movl %ebx, %eax
shll $0x6, %eax
xorl %esi, %esi
cmpl $-0x1, %ecx
cmovnel %edi, %esi
cmpl $0x63ce, %edx           # imm = 0x63CE
jg 0x17563
shll $0xe, %ebp
orl %eax, %esi
orl %ebp, %esi
orl $0x2b, %esi
jmp 0x1757a
orl %esi, %eax
orl $0x2b, %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x163c0
shll $0x6, %ebp
orl $0x2e, %ebp
movl %ebp, %esi
movq %r14, %rdi
callq 0x163c0
incb %bl
movb %bl, 0x3c(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: patchtestreg
static int patchtestreg (FuncState *fs, int node, int reg) {
  Instruction *i = getjumpcontrol(fs, node);
  if (GET_OPCODE(*i) != OP_TESTSET)
    return 0;  /* cannot patch other instructions */
  if (reg != NO_REG && reg != GETARG_B(*i))
    SETARG_A(*i, reg);
  else {
     /* no register to put value or register already has the value;
        change instruction to simple test */
    *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));
  }
  return 1;
}

// Assembly:
movslq %esi, %rax
leaq (%rdi,%rax,4), %rcx
testl %eax, %eax
jle 0x175ad
movl -0x4(%rcx), %esi
movl %esi, %eax
andl $0x3f, %eax
leaq 0xb339(%rip), %rdi      # 0x228e0
cmpb $0x0, (%rax,%rdi)
js 0x175b1
movl (%rcx), %esi
jmp 0x175b5
addq $-0x4, %rcx
movl %esi, %edi
andl $0x3f, %edi
xorl %eax, %eax
cmpl $0x23, %edi
jne 0x175fb
cmpl $0xff, %edx
je 0x175e4
movl %esi, %eax
shrl $0x17, %eax
cmpl %edx, %eax
je 0x175e4
andl $0xffffc023, %esi       # imm = 0xFFFFC023
movzbl %dl, %eax
shll $0x6, %eax
orl %esi, %eax
movl %eax, %esi
jmp 0x175f4
movl %esi, %eax
shrl $0x11, %eax
andl $-0x40, %eax
andl $0x7fc022, %esi         # imm = 0x7FC022
orl %eax, %esi
movl %esi, (%rcx)
movl $0x1, %eax
retq