LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: addk
static int addk (FuncState *fs, TValue *key, TValue *v) {
  lua_State *L = fs->ls->L;
  Proto *f = fs->f;
  TValue *idx = luaH_set(L, fs->ls->h, key);  /* index scanner table */
  int k, oldsize;
  if (ttisinteger(idx)) {  /* is there an index there? */
    k = cast_int(ivalue(idx));
    /* correct value? (warning: must distinguish floats from integers!) */
    if (k < fs->nk && ttype(&f->k[k]) == ttype(v) &&
                      luaV_rawequalobj(&f->k[k], v))
      return k;  /* reuse index */
  }
  /* constant not found; create a new entry */
  oldsize = f->sizek;
  k = fs->nk;
  /* numerical value does not need GC barrier;
     table has no metatable, so it does not need to invalidate cache */
  setivalue(idx, k);
  luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants");
  while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
  setobj(L, &f->k[k], v);
  fs->nk++;
  luaC_barrier(L, f, v);
  return k;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r13
movq (%rdi), %rbx
movq 0x10(%rdi), %rax
movq 0x38(%rax), %rdi
movq 0x50(%rax), %rsi
movq %rdi, 0x8(%rsp)
callq 0xecaa
movq %rax, %rbp
cmpl $0x13, 0x8(%rax)
jne 0x145d2
movq (%rbp), %r14
cmpl %r14d, 0x2c(%r13)
jle 0x145d2
movq 0x30(%rbx), %rsi
movslq %r14d, %rax
shlq $0x4, %rax
movl 0x8(%r15), %ecx
xorl 0x8(%rsi,%rax), %ecx
testb $0x3f, %cl
je 0x1467d
movq %r15, 0x10(%rsp)
movslq 0x14(%rbx), %r12
movl 0x2c(%r13), %r14d
movslq %r14d, %r15
movq %r15, (%rbp)
movl $0x13, 0x8(%rbp)
movl 0x14(%rbx), %eax
cmpl %eax, %r15d
jl 0x1461e
leaq 0x14(%rbx), %rdx
movq 0x30(%rbx), %rsi
leaq 0xc107(%rip), %r9       # 0x2070b
pushq $0x10
popq %rcx
movq 0x8(%rsp), %rdi
movl $0x3ffffff, %r8d        # imm = 0x3FFFFFF
callq 0xab14
movq %rax, 0x30(%rbx)
movl 0x14(%rbx), %eax
movslq %eax, %rcx
movq 0x30(%rbx), %rax
movq %r12, %rdx
shlq $0x4, %rdx
addq %rax, %rdx
addq $0x8, %rdx
cmpq %rcx, %r12
jge 0x14644
incq %r12
andl $0x0, (%rdx)
addq $0x10, %rdx
jmp 0x14633
shlq $0x4, %r15
movq 0x10(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%rax,%r15)
incl 0x2c(%r13)
testb $0x40, 0x8(%rcx)
je 0x14692
testb $0x4, 0x9(%rbx)
je 0x14692
movq (%rcx), %rdx
testb $0x3, 0x9(%rdx)
je 0x14692
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x972c
jmp 0x14692
addq %rax, %rsi
xorl %edi, %edi
movq %r15, %rdx
callq 0x104c8
testl %eax, %eax
je 0x145d2
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/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 0x14573
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rsi), %eax
cmpl $0xe, %eax
je 0x14707
cmpl $0xd, %eax
jne 0x14706
movq (%rdi), %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)
retq
movq (%rdi), %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(%rdi), %esi
shll $0x6, %esi
addl %esi, %edx
addl $0x800000, %edx         # imm = 0x800000
movl %edx, (%rax,%rcx,4)
pushq $0x1
popq %rsi
jmp 0x14536
// File: /workspace/github_c_makefile_star2_O2/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 0x14763
cmpl $0xd, %eax
jne 0x14785
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_O2/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 %r14
pushq %rbx
pushq %rax
movl (%rsi), %eax
addl $-0x8, %eax
cmpl $0x6, %eax
ja 0x1481c
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xbdd7(%rip), %rcx      # 0x2057c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14739
movswl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x14824
cmpb $0x8, 0xb(%rbx)
jne 0x147fd
movzbl 0xa(%rbx), %esi
movq %r14, %rdi
callq 0x14824
pushq $0x7
jmp 0x147ff
movl $0x7, (%rbx)
jmp 0x1481c
movl 0x8(%rbx), %esi
shll $0x17, %esi
orl $0x5, %esi
movq %r14, %rdi
callq 0x143fd
jmp 0x14813
pushq $0x6
popq %rsi
movzbl 0xa(%rbx), %ecx
movswl 0x8(%rbx), %r8d
movq %r14, %rdi
xorl %edx, %edx
callq 0x14213
movl %eax, 0x8(%rbx)
movl $0xc, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14786
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14871
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x14536
movzbl 0x3c(%r14), %edx
decl %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1487c
// File: /workspace/github_c_makefile_star2_O2/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 0x153ea
cmpl $0xb, (%rbx)
jne 0x148a8
leaq 0x10(%rbx), %rsi
movl 0x8(%rbx), %edx
movq %r14, %rdi
callq 0x1422a
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %r15d
cmpl %r15d, %esi
je 0x14952
movq %r14, %rdi
callq 0x154bd
testl %eax, %eax
jne 0x148d7
movq %r14, %rdi
movl %r15d, %esi
callq 0x154bd
testl %eax, %eax
je 0x1496f
cmpl $0xb, (%rbx)
jne 0x148e2
pushq $-0x1
popq %r15
jmp 0x148ed
movq %r14, %rdi
callq 0x142ce
movl %eax, %r15d
pushq $0x1
popq %r12
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
movl %r12d, %ecx
callq 0x154f9
movl %eax, %r13d
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x154f9
movl %eax, %r12d
movq %r14, %rdi
movl %r15d, %esi
callq 0x14333
movl %r13d, %r8d
movl 0x14(%rbx), %r15d
movl 0x20(%r14), %r13d
movl %r13d, 0x24(%r14)
movq %r14, %rdi
movl %r15d, %esi
movl %r13d, %edx
movl %ebp, %ecx
callq 0x14358
movl 0x10(%rbx), %esi
movq %r14, %rdi
movl %r13d, %edx
movl %ebp, %ecx
movl %r12d, %r8d
callq 0x14358
orq $-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
pushq $-0x1
popq %r12
movl %r12d, %r8d
jmp 0x14927
// File: /workspace/github_c_makefile_star2_O2/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 0x14786
cmpl $0x7, (%rbx)
jne 0x149a5
movl 0x10(%rbx), %eax
leaq 0x8(%rbx), %r15
cmpl 0x14(%rbx), %eax
je 0x149b7
movl (%r15), %edx
movzbl 0x3a(%r14), %eax
cmpl %eax, %edx
jge 0x149c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14836
addq $0x8, %rbx
movq %rbx, %r15
movl (%r15), %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1487c
jmp 0x149b7
// File: /workspace/github_c_makefile_star2_O2/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 0x149e3
movl (%rbx), %eax
decl %eax
cmpl $0x5, %eax
ja 0x14a98
leaq 0xbb7e(%rip), %rcx      # 0x20598
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %rdx
andl $0x0, 0x8(%rdx)
movq 0x10(%r14), %rax
movq 0x50(%rax), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movl $0x45, 0x8(%rsi)
movq %r14, %rdi
callq 0x14573
jmp 0x14a81
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x14aca
jmp 0x14a81
movq %r14, %rdi
xorl %esi, %esi
jmp 0x14a6e
movl 0x8(%rbx), %eax
jmp 0x14a84
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x14aab
jmp 0x14a81
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x146a4
movl %eax, 0x8(%rbx)
movl $0x4, (%rbx)
cmpl $0xff, %eax
jg 0x14a98
orl $0x100, %eax            # imm = 0x100
jmp 0x14aa3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14978
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rsi), %eax
cmpl $0xa, %eax
je 0x14b4c
cmpl $0x9, %eax
je 0x14b30
cmpl $0x8, %eax
jne 0x14b7f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14871
movl 0x8(%r15), %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1487c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14978
movl 0x8(%r15), %ecx
pushq $0x9
popq %rsi
movq %r14, %rdi
movl %eax, %edx
xorl %r8d, %r8d
jmp 0x14b7a
xorl %eax, %eax
cmpb $0x8, 0xb(%r15)
sete %al
leal 0x8(,%rax,2), %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x149f4
movzbl 0xa(%r15), %edx
movswl 0x8(%r15), %ecx
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %r8d
callq 0x14213
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14871
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x14978
movl 0x8(%r15), %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x14871
movzbl 0x3c(%r14), %eax
movl %eax, 0x8(%r15)
movl $0x7, (%r15)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x14536
movl 0x8(%r15), %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x149f4
pushq $0xc
popq %rsi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
movl %eax, %r8d
callq 0x14213
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14871
// File: /workspace/github_c_makefile_star2_O2/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 0x14786
movl (%rbx), %eax
pushq $-0x1
popq %rdx
leal -0x4(%rax), %ecx
cmpl $0x3, %ecx
jb 0x14c49
cmpl $0x2, %eax
je 0x14c49
movq %r14, %rdi
movq %rbx, %rsi
cmpl $0xb, %eax
jne 0x14c40
callq 0x14c6c
movl 0x8(%rbx), %edx
jmp 0x14c49
xorl %edx, %edx
callq 0x14c93
movl %eax, %edx
leaq 0x14(%rbx), %rsi
movq %r14, %rdi
callq 0x1422a
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x14333
orl $-0x1, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0xc, (%rsi)
jne 0x14cd7
movq (%r14), %rax
movq 0x38(%rax), %rax
movslq 0x8(%r15), %rcx
movl (%rax,%rcx,4), %edx
movl %edx, %eax
andl $0x3f, %eax
cmpl $0x1b, %eax
jne 0x14cd7
decl 0x20(%r14)
shrl $0x17, %edx
xorl %r8d, %r8d
testl %ebx, %ebx
sete %r8b
pushq $0x22
popq %rsi
movq %r14, %rdi
xorl %ecx, %ecx
jmp 0x14cff
movq %r14, %rdi
movq %r15, %rsi
callq 0x15520
movq %r14, %rdi
movq %r15, %rsi
callq 0x14871
movl 0x8(%r15), %ecx
pushq $0x23
popq %rsi
movq %r14, %rdi
movl $0xff, %edx
movl %ebx, %r8d
popq %rbx
popq %r14
popq %r15
jmp 0x1550e
// File: /workspace/github_c_makefile_star2_O2/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 0x14786
movl (%rbx), %eax
pushq $-0x1
popq %rdx
cmpl $0x1, %eax
je 0x14d41
cmpl $0x3, %eax
je 0x14d41
cmpl $0xb, %eax
jne 0x14d31
movl 0x8(%rbx), %edx
jmp 0x14d41
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14c93
movl %eax, %edx
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x1422a
movl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x14333
orl $-0x1, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x149f4
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_O2/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 %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x2, %esi
jb 0x14dff
je 0x14e1b
cmpl $0x3, %r15d
jne 0x14df6
addl $0x19, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14978
movl %eax, %r12d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14871
shll $0x17, %r12d
orl %r15d, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x143fd
movl %eax, 0x8(%r14)
movl $0xc, (%r14)
movq (%rbx), %rax
movq 0x48(%rax), %rax
movslq 0x20(%rbx), %rcx
movl %ebp, -0x4(%rax,%rcx,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leal 0xc(%r15), %esi
leaq 0x1a4a6(%rip), %rcx     # 0x2f2b0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x14ebe
testl %eax, %eax
jne 0x14df6
jmp 0x14dad
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14786
movl (%r14), %eax
decl %eax
cmpl $0xb, %eax
ja 0x14e92
leaq 0xb779(%rip), %rcx      # 0x205b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, (%r14)
jmp 0x14e92
movl $0x2, (%r14)
jmp 0x14e92
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15520
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14871
movl 0x8(%r14), %esi
shll $0x17, %esi
orl $0x1b, %esi
movq %rbx, %rdi
callq 0x143fd
movl %eax, 0x8(%r14)
movl $0xc, (%r14)
jmp 0x14e92
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14c6c
movl 0x10(%r14), %esi
movl 0x14(%r14), %eax
movl %esi, 0x14(%r14)
movl %eax, 0x10(%r14)
movq %rbx, %rdi
callq 0x15551
movl 0x10(%r14), %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x15551
// File: /workspace/github_c_makefile_star2_O2/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
movq %rcx, %r12
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x20(%rsp), %rsi
movq %rdx, %rdi
callq 0x1507e
xorl %ebx, %ebx
testl %eax, %eax
je 0x14ff0
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x1507e
testl %eax, %eax
je 0x14ff0
cmpl $0xd, %ebp
ja 0x14f9a
movl $0x2f80, %eax           # imm = 0x2F80
btl %ebp, %eax
jae 0x14f26
cmpl $0x13, 0x28(%rsp)
jne 0x14f41
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
jmp 0x14f57
pushq $0x68
popq %rax
btl %ebp, %eax
jae 0x14f9a
cmpl $0x13, 0x18(%rsp)
movq 0x10(%rsp), %rax
je 0x14f7e
movq %rax, %xmm0
jmp 0x14f83
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
xorl %r12d, %r12d
xorl %edx, %edx
callq 0xfed4
testl %eax, %eax
je 0x14f95
cmpl $0x13, 0x18(%rsp)
jne 0x14f64
pushq $0x1
popq %r12
jmp 0x14f95
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0xfed4
xorl %r12d, %r12d
testl %eax, %eax
setne %r12b
jmp 0x14f95
cvtsi2sd %rax, %xmm0
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movq %xmm1, %r12
andl $0x1, %r12d
testl %r12d, %r12d
je 0x14ff0
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 0xac6b
cmpl $0x13, 0x8(%r15)
jne 0x14fd1
movl $0x6, (%r14)
movq (%rsp), %rax
movq %rax, 0x8(%r14)
jmp 0x14fed
movsd (%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
je 0x14ff0
movl $0x5, (%r14)
movsd %xmm0, 0x8(%r14)
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_infix
void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
  switch (op) {
    case OPR_AND: {
      luaK_goiftrue(fs, v);  /* go ahead only if 'v' is true */
      break;
    }
    case OPR_OR: {
      luaK_goiffalse(fs, v);  /* go ahead only if 'v' is false */
      break;
    }
    case OPR_CONCAT: {
      luaK_exp2nextreg(fs, v);  /* operand must be on the 'stack' */
      break;
    }
    case OPR_ADD: case OPR_SUB:
    case OPR_MUL: case OPR_DIV: case OPR_IDIV:
    case OPR_MOD: case OPR_POW:
    case OPR_BAND: case OPR_BOR: case OPR_BXOR:
    case OPR_SHL: case OPR_SHR: {
      if (!tonumeral(v, NULL))
        luaK_exp2RK(fs, v);
      /* else keep numeral, which may be folded with 2nd operand */
      break;
    }
    default: {
      luaK_exp2RK(fs, v);
      break;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x14, %esi
ja 0x15036
movl %esi, %eax
leaq 0xb5c9(%rip), %rcx      # 0x205e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1507e
testl %eax, %eax
je 0x15036
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x149f4
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14836
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14d09
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14c0a
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: tonumeral
static int tonumeral(expdesc *e, TValue *v) {
  if (hasjumps(e))
    return 0;  /* not a numeral */
  switch (e->k) {
    case VKINT:
      if (v) setivalue(v, e->u.ival);
      return 1;
    case VKFLT:
      if (v) setfltvalue(v, e->u.nval);
      return 1;
    default: return 0;
  }
}

// Assembly:
movl 0x10(%rdi), %ecx
xorl %eax, %eax
cmpl 0x14(%rdi), %ecx
jne 0x150b6
movl (%rdi), %edx
pushq $0x1
popq %rcx
cmpl $0x5, %edx
je 0x150a0
cmpl $0x6, %edx
jne 0x150b6
testq %rsi, %rsi
je 0x150b4
pushq $0x13
jmp 0x150a7
testq %rsi, %rsi
je 0x150b4
pushq $0x3
popq %rax
movsd 0x8(%rdi), %xmm0
movsd %xmm0, (%rsi)
movl %eax, 0x8(%rsi)
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x149f4
movl %eax, %r13d
movq %r14, %rdi
movq %r12, %rsi
callq 0x149f4
movl %eax, %ebx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x15582
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
movl %r13d, %ecx
movl %ebx, %r8d
callq 0x14213
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_O2/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 %ecx, %r8d
movl %edx, %r9d
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%r9), %eax
pushq $0x32
popq %rcx
cltd
idivl %ecx
movl %eax, %ebp
incl %ebp
xorl %ecx, %ecx
cmpl $-0x1, %r8d
cmovnel %r8d, %ecx
pushq $0x2b
popq %rsi
movl %ebx, %edx
cmpl $0x63ce, %r9d           # imm = 0x63CE
jg 0x15344
movl %ebp, %r8d
callq 0x14213
jmp 0x15356
xorl %r8d, %r8d
callq 0x14213
movq %r14, %rdi
movl %ebp, %esi
callq 0x144fe
incb %bl
movb %bl, 0x3c(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movl %edx, %ebx
callq 0x153bb
movl (%rax), %edx
movl %edx, %esi
andl $0x3f, %esi
xorl %ecx, %ecx
cmpl $0x23, %esi
jne 0x153b7
cmpl $0xff, %ebx
sete %cl
movl %edx, %esi
shrl $0x17, %esi
cmpl %ebx, %esi
sete %sil
orb %cl, %sil
je 0x153a4
movl %edx, %ecx
shrl $0x11, %ecx
andl $-0x40, %ecx
andl $0x7fc022, %edx         # imm = 0x7FC022
orl %ecx, %edx
movl %edx, %ecx
jmp 0x153b2
andl $0xffffc023, %edx       # imm = 0xFFFFC023
movzbl %bl, %ecx
shll $0x6, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
pushq $0x1
popq %rcx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: getjumpcontrol
static Instruction *getjumpcontrol (FuncState *fs, int pc) {
  Instruction *pi = &fs->f->code[pc];
  if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))
    return pi-1;
  else
    return pi;
}

// Assembly:
movq (%rdi), %rcx
movslq %esi, %rdx
leaq (,%rdx,4), %rax
addq 0x38(%rcx), %rax
testl %edx, %edx
jle 0x153e4
movl -0x4(%rax), %ecx
andl $0x3f, %ecx
leaq 0xa522(%rip), %rdx      # 0x1f900
cmpb $0x0, (%rcx,%rdx)
js 0x153e5
retq
addq $-0x4, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: discharge2reg
static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VNIL: {
      luaK_nil(fs, reg, 1);
      break;
    }
    case VFALSE: case VTRUE: {
      luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
      break;
    }
    case VK: {
      luaK_codek(fs, reg, e->u.info);
      break;
    }
    case VKFLT: {
      luaK_codek(fs, reg, luaK_numberK(fs, e->u.nval));
      break;
    }
    case VKINT: {
      luaK_codek(fs, reg, luaK_intK(fs, e->u.ival));
      break;
    }
    case VRELOCABLE: {
      Instruction *pc = &getinstruction(fs, e);
      SETARG_A(*pc, reg);  /* instruction will put result in 'reg' */
      break;
    }
    case VNONRELOC: {
      if (reg != e->u.info)
        luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0);
      break;
    }
    default: {
      lua_assert(e->k == VJMP);
      return;  /* nothing to do... */
    }
  }
  e->u.info = reg;
  e->k = VNONRELOC;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x14786
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0xb, %ecx
ja 0x154b8
leaq 0xb278(%rip), %rdx      # 0x20688
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %ecx, %ecx
cmpl $0x2, %eax
sete %cl
pushq $0x3
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
xorl %r8d, %r8d
callq 0x14213
jmp 0x154af
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x146a4
jmp 0x154a3
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x1415c
jmp 0x154af
movl 0x8(%rbx), %esi
cmpl %ebp, %esi
je 0x154af
movl %ebp, %eax
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
movq %r14, %rdi
callq 0x143fd
jmp 0x154af
movq (%r14), %rax
movq 0x38(%rax), %rax
movslq 0x8(%rbx), %rcx
movl $0xffffc03f, %edx       # imm = 0xFFFFC03F
andl (%rax,%rcx,4), %edx
movzbl %bpl, %esi
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax,%rcx,4)
jmp 0x154af
movl 0x8(%rbx), %edx
movq %r14, %rdi
movl %ebp, %esi
jmp 0x154aa
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x14aca
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x144b7
movl %ebp, 0x8(%rbx)
movl $0x7, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: need_value
static int need_value (FuncState *fs, int list) {
  for (; list != NO_JUMP; list = getjump(fs, list)) {
    Instruction i = *getjumpcontrol(fs, list);
    if (GET_OPCODE(i) != OP_TESTSET) return 1;
  }
  return 0;  /* not found */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x1
popq %rbx
cmpl $-0x1, %ebp
je 0x154f0
movq %r14, %rdi
movl %ebp, %esi
callq 0x153bb
movl (%rax), %eax
andl $0x3f, %eax
cmpl $0x23, %eax
jne 0x154f2
movq %r14, %rdi
movl %ebp, %esi
callq 0x14264
movl %eax, %ebp
jmp 0x154c9
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: luaX_init
void luaX_init (lua_State *L) {
  int i;
  TString *e = luaS_newliteral(L, LUA_ENV);  /* create env name */
  luaC_fix(L, obj2gco(e));  /* never collect this name */
  for (i=0; i<NUM_RESERVED; i++) {
    TString *ts = luaS_new(L, luaX_tokens[i]);
    luaC_fix(L, obj2gco(ts));  /* reserved words are never collected */
    ts->extra = cast_byte(i+1);  /* reserved word */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x9dc3(%rip), %rsi      # 0x1f395
pushq $0x4
popq %rdx
callq 0xe658
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9853
movb $0x1, %bpl
xorl %r15d, %r15d
leaq 0x18bfe(%rip), %r12     # 0x2e1f0
cmpq $0xb0, %r15
je 0x15622
movq (%r15,%r12), %rsi
movq %rbx, %rdi
callq 0xe823
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9853
movb %bpl, 0xa(%r14)
addq $0x8, %r15
incb %bpl
jmp 0x155f2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: luaX_token2str
const char *luaX_token2str (LexState *ls, int token) {
  if (token < FIRST_RESERVED) {  /* single-byte symbols? */
    lua_assert(token == cast_uchar(token));
    return luaO_pushfstring(ls->L, "'%c'", token);
  }
  else {
    const char *s = luaX_tokens[token - FIRST_RESERVED];
    if (token < TK_EOS)  /* fixed format (symbols and reserved words)? */
      return luaO_pushfstring(ls->L, "'%s'", s);
    else  /* names, strings, and numerals */
      return s;
  }
}

// Assembly:
movl %esi, %edx
cmpl $0x100, %esi            # imm = 0x100
jg 0x15647
movq 0x38(%rdi), %rdi
leaq 0xc2e4(%rip), %rsi      # 0x21924
xorl %eax, %eax
jmp 0xb593
leal -0x101(%rdx), %eax
leaq 0x18b9c(%rip), %rcx     # 0x2e1f0
movq (%rcx,%rax,8), %rax
cmpl $0x120, %edx            # imm = 0x120
ja 0x15675
movq 0x38(%rdi), %rdi
leaq 0xc770(%rip), %rsi      # 0x21ddb
movq %rax, %rdx
xorl %eax, %eax
jmp 0xb593
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: lexerror
static l_noret lexerror (LexState *ls, const char *msg, int token) {
  msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber);
  if (token)
    luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token));
  luaD_throw(ls->L, LUA_ERRSYNTAX);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movq 0x60(%rbx), %rdx
movl 0x4(%rbx), %ecx
callq 0x7bdf
testl %r12d, %r12d
je 0x156fa
movq %rax, %r14
movq 0x38(%rbx), %r15
leal -0x122(%r12), %eax
movq %rbx, %rdi
cmpl $0x3, %eax
ja 0x156db
xorl %esi, %esi
callq 0x1615d
movq 0x38(%rbx), %rdi
movq 0x48(%rbx), %rax
movq (%rax), %rdx
leaq 0xc709(%rip), %rsi      # 0x21ddb
xorl %eax, %eax
callq 0xb593
jmp 0x156e3
movl %r12d, %esi
callq 0x1562b
leaq 0xb2e6(%rip), %rsi      # 0x209d0
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xb593
movq 0x38(%rbx), %rdi
pushq $0x3
popq %rsi
callq 0x80fc
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: luaX_newstring
TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
  lua_State *L = ls->L;
  TValue *o;  /* entry for 'str' */
  TString *ts = luaS_newlstr(L, str, l);  /* create new string */
  setsvalue2s(L, L->top++, ts);  /* temporarily anchor it in stack */
  o = luaH_set(L, ls->h, L->top - 1);
  if (ttisnil(o)) {  /* not in use yet? */
    /* boolean value does not need GC barrier;
       table has no metatable, so it does not need to invalidate cache */
    setbvalue(o, 1);  /* t[string] = true */
    luaC_checkGC(L);
  }
  else {  /* string already present */
    ts = tsvalue(keyfromval(o));  /* re-use value previously stored */
  }
  L->top--;  /* remove string from stack */
  return ts;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0xe658
movq %rax, %r14
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq %r14, (%rax)
movzbl 0x8(%r14), %ecx
orl $0x40, %ecx
movl %ecx, 0x8(%rax)
movq 0x50(%r15), %rsi
movq 0x10(%rbx), %rdx
addq $-0x10, %rdx
movq %rbx, %rdi
callq 0xecaa
cmpl $0x0, 0x8(%rax)
je 0x15757
movq 0x10(%rax), %r14
jmp 0x15772
pushq $0x1
popq %rcx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
movq 0x18(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jle 0x15772
movq %rbx, %rdi
callq 0x9f05
addq $-0x10, 0x10(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: luaX_setinput
void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source,
                    int firstchar) {
  ls->t.token = 0;
  ls->L = L;
  ls->current = firstchar;
  ls->lookahead.token = TK_EOS;  /* no look-ahead token */
  ls->z = z;
  ls->fs = NULL;
  ls->linenumber = 1;
  ls->lastline = 1;
  ls->source = source;
  ls->envn = luaS_newliteral(L, LUA_ENV);  /* get env name */
  luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
andl $0x0, 0x10(%rsi)
movq %rdi, 0x38(%rsi)
movl %r8d, (%rsi)
movl $0x121, 0x20(%rsi)      # imm = 0x121
movq %rdx, 0x40(%rsi)
andq $0x0, 0x30(%rsi)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x4(%rsi)
movq %rcx, 0x60(%rsi)
leaq 0x9bdd(%rip), %rsi      # 0x1f395
pushq $0x4
popq %rdx
callq 0xe658
movq %rax, 0x68(%rbx)
movq 0x38(%rbx), %rdi
movq 0x48(%rbx), %rax
movq (%rax), %rsi
movq 0x10(%rax), %rdx
pushq $0x20
popq %rcx
callq 0xab76
movq 0x48(%rbx), %rcx
movq %rax, (%rcx)
movq $0x20, 0x10(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: luaX_next
void luaX_next (LexState *ls) {
  ls->lastline = ls->linenumber;
  if (ls->lookahead.token != TK_EOS) {  /* is there a look-ahead token? */
    ls->t = ls->lookahead;  /* use this one */
    ls->lookahead.token = TK_EOS;  /* and discharge it */
  }
  else
    ls->t.token = llex(ls, &ls->t.seminfo);  /* read next token */
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %ecx
movl %eax, 0x8(%rdi)
cmpl $0x121, %ecx            # imm = 0x121
jne 0x15812
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x15828
movl %eax, 0x10(%rbx)
jmp 0x15826
leaq 0x20(%rbx), %rax
addq $0x10, %rbx
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movl $0x121, (%rax)          # imm = 0x121
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: save
static void save (LexState *ls, int c) {
  Mbuffer *b = ls->buff;
  if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) {
    size_t newsize;
    if (luaZ_sizebuffer(b) >= MAX_SIZE/2)
      lexerror(ls, "lexical element too long", 0);
    newsize = luaZ_sizebuffer(b) * 2;
    luaZ_resizebuffer(ls->L, b, newsize);
  }
  b->buffer[luaZ_bufflen(b)++] = cast(char, c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq 0x48(%rdi), %r15
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rdx
leaq 0x1(%rcx), %rsi
cmpq %rdx, %rsi
jbe 0x161ac
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rax, %rdx
jae 0x161bc
leaq (%rdx,%rdx), %r14
movq 0x38(%rdi), %rdi
movq (%r15), %rsi
movq %r14, %rcx
callq 0xab76
movq %rax, (%r15)
movq %r14, 0x10(%r15)
movq 0x8(%r15), %rcx
leaq 0x1(%rcx), %rsi
jmp 0x161af
movq (%r15), %rax
movq %rsi, 0x8(%r15)
movb %bl, (%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0xa818(%rip), %rsi      # 0x209db
xorl %edx, %edx
callq 0x1567f
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: inclinenumber
static void inclinenumber (LexState *ls) {
  int old = ls->current;
  lua_assert(currIsNewline(ls));
  next(ls);  /* skip '\n' or '\r' */
  if (currIsNewline(ls) && ls->current != old)
    next(ls);  /* skip '\n\r' or '\r\n' */
  if (++ls->linenumber >= MAX_INT)
    lexerror(ls, "chunk has too many lines", 0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
movq 0x40(%rdi), %rdi
subq $0x1, (%rdi)
jae 0x161e3
callq 0x1273c
jmp 0x161f2
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
cmpl $0xd, %eax
je 0x161fe
cmpl $0xa, %eax
jne 0x16224
cmpl %ebp, %eax
je 0x16224
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x16213
callq 0x1273c
jmp 0x16222
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
movl 0x4(%rbx), %eax
incl %eax
movl %eax, 0x4(%rbx)
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x1623a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xa7d1(%rip), %rsi      # 0x20a12
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1567f
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: skip_sep
static int skip_sep (LexState *ls) {
  int count = 0;
  int s = ls->current;
  lua_assert(s == '[' || s == ']');
  save_and_next(ls);
  while (ls->current == '=') {
    save_and_next(ls);
    count++;
  }
  return (ls->current == s) ? count : (-count) - 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %ebx
movl %ebx, %esi
callq 0x1615d
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x1626f
callq 0x1273c
jmp 0x1627e
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
xorl %ebp, %ebp
pushq $0x3d
popq %r15
cmpl $0x3d, %eax
jne 0x162be
movq %r14, %rdi
movl %r15d, %esi
callq 0x1615d
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x162a8
callq 0x1273c
jmp 0x162b7
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
incl %ebp
jmp 0x16287
xorl %ecx, %ecx
cmpl %ebx, %eax
setne %cl
negl %ecx
xorl %ecx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: check_next1
static int check_next1 (LexState *ls, int c) {
  if (ls->current == c) {
    next(ls);
    return 1;
  }
  else return 0;
}

// Assembly:
xorl %eax, %eax
cmpl %esi, (%rdi)
jne 0x16474
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
subq $0x1, (%rdi)
jae 0x1645f
callq 0x1273c
jmp 0x1646e
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: read_numeral
static int read_numeral (LexState *ls, SemInfo *seminfo) {
  TValue obj;
  const char *expo = "Ee";
  int first = ls->current;
  lua_assert(lisdigit(ls->current));
  save_and_next(ls);
  if (first == '0' && check_next2(ls, "xX"))  /* hexadecimal? */
    expo = "Pp";
  for (;;) {
    if (check_next2(ls, expo))  /* exponent part? */
      check_next2(ls, "-+");  /* optional exponent sign */
    if (lisxdigit(ls->current))
      save_and_next(ls);
    else if (ls->current == '.')
      save_and_next(ls);
    else break;
  }
  save(ls, '\0');
  if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0)  /* format error? */
    lexerror(ls, "malformed number", TK_FLT);
  if (ttisinteger(&obj)) {
    seminfo->i = ivalue(&obj);
    return TK_INT;
  }
  else {
    lua_assert(ttisfloat(&obj));
    seminfo->r = fltvalue(&obj);
    return TK_FLT;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ebp
movl %ebp, %esi
callq 0x1615d
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x164a3
callq 0x1273c
jmp 0x164b2
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
cmpl $0x30, %ebp
jne 0x164df
leaq 0xa62a(%rip), %rsi      # 0x20aeb
movq %r14, %rdi
callq 0x16654
testl %eax, %eax
leaq 0xa616(%rip), %rax      # 0x20ae8
leaq 0xa615(%rip), %r15      # 0x20aee
cmoveq %rax, %r15
jmp 0x164e6
leaq 0xa602(%rip), %r15      # 0x20ae8
leaq 0xa233(%rip), %r13      # 0x20720
pushq $0x2e
popq %rbp
leaq 0xa5fa(%rip), %r12      # 0x20af1
movq %r14, %rdi
movq %r15, %rsi
callq 0x16654
testl %eax, %eax
je 0x16511
movq %r14, %rdi
movq %r12, %rsi
callq 0x16654
movslq (%r14), %rsi
testb $0x10, 0x1(%rsi,%r13)
jne 0x16528
movq %r14, %rdi
cmpl $0x2e, %esi
jne 0x16555
movl %ebp, %esi
jmp 0x1652b
movq %r14, %rdi
callq 0x1615d
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x16541
callq 0x1273c
jmp 0x16550
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
jmp 0x164f7
xorl %esi, %esi
callq 0x1615d
movq 0x48(%r14), %rax
movq (%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0xaf5a
testq %rax, %rax
je 0x1659a
xorl %eax, %eax
cmpl $0x13, 0x10(%rsp)
sete %al
movsd 0x8(%rsp), %xmm0
orl $0x122, %eax            # imm = 0x122
movsd %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa553(%rip), %rsi      # 0x20af4
movq %r14, %rdi
movl $0x122, %edx            # imm = 0x122
callq 0x1567f
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: esccheck
static void esccheck (LexState *ls, int c, const char *msg) {
  if (!c) {
    if (ls->current != EOZ)
      save_and_next(ls);  /* add current to buffer for error message */
    lexerror(ls, msg, TK_STRING);
  }
}

// Assembly:
testl %esi, %esi
je 0x165b3
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl (%rdi), %esi
cmpl $-0x1, %esi
je 0x165ef
movq %r14, %rdi
callq 0x1615d
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x165dd
callq 0x1273c
jmp 0x165ec
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x125, %edx            # imm = 0x125
callq 0x1567f
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: check_next2
static int check_next2 (LexState *ls, const char *set) {
  lua_assert(set[2] == '\0');
  if (ls->current == set[0] || ls->current == set[1]) {
    save_and_next(ls);
    return 1;
  }
  else return 0;
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movl (%rdi), %esi
movsbl (%rax), %ecx
cmpl %ecx, %esi
je 0x1666e
movsbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %esi
jne 0x1669b
movq %rbx, %rdi
callq 0x1615d
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x16687
callq 0x1273c
jmp 0x16696
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
nopl (%rax)