LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1684b
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0xb, %ecx
ja 0x176fd
leaq 0xbfd2(%rip), %rdx      # 0x235f8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %ebp, %ecx
shll $0x6, %ecx
cmpl $0x2, %eax
movl $0x800000, %eax         # imm = 0x800000
movl $0x2, %esi
cmovel %eax, %esi
orl %ecx, %esi
orl $0x3, %esi
movq %r14, %rdi
callq 0x163c0
jmp 0x176f4
movq 0x8(%rbx), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movl $0x2, 0x8(%rsi)
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movl $0x13, 0x8(%rdx)
movq %r14, %rdi
jmp 0x176e3
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x16100
jmp 0x176f4
movl 0x8(%rbx), %esi
cmpl %ebp, %esi
je 0x176f4
movl %ebp, %eax
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
jmp 0x17649
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 0x176f4
movl 0x8(%rbx), %edx
movq %r14, %rdi
movl %ebp, %esi
jmp 0x176ef
movsd 0x8(%rbx), %xmm0
movq %rsp, %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x16539
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x16481
movl %ebp, 0x8(%rbx)
movl $0x7, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
cmpl $-0x1, %esi
je 0x17763
movq (%rdi), %rcx
movq 0x38(%rcx), %rcx
leaq 0xb1c5(%rip), %rdx      # 0x228e0
movslq %esi, %rdi
testl %edi, %edi
jle 0x17735
movl -0x4(%rcx,%rdi,4), %r8d
movl %r8d, %r9d
andl $0x3f, %r9d
cmpb $0x0, (%r9,%rdx)
js 0x17739
movl (%rcx,%rdi,4), %r8d
andl $0x3f, %r8d
cmpl $0x23, %r8d
jne 0x17764
movl (%rcx,%rdi,4), %edi
shrl $0xe, %edi
leal -0x1ffff(%rdi), %r8d
cmpl $-0x1, %r8d
je 0x17763
addl %edi, %esi
addl $0xfffe0002, %esi       # imm = 0xFFFE0002
cmpl $-0x1, %esi
jne 0x1771b
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: freeexps
static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) {
  int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1;
  int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1;
  if (r1 > r2) {
    freereg(fs, r1);
    freereg(fs, r2);
  }
  else {
    freereg(fs, r2);
    freereg(fs, r1);
  }
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x7, (%rsi)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jne 0x17808
movl 0x8(%rsi), %ecx
cmpl $0x7, (%rdx)
jne 0x17810
movl 0x8(%rdx), %eax
cmpl %eax, %ecx
jle 0x17834
btl $0x8, %ecx
jb 0x17825
movzbl 0x3a(%rdi), %edx
cmpl %edx, %ecx
jl 0x17825
decb 0x3c(%rdi)
btl $0x8, %eax
jb 0x17833
movzbl 0x3a(%rdi), %ecx
cmpl %ecx, %eax
jge 0x17853
retq
btl $0x8, %eax
jb 0x17845
movzbl 0x3a(%rdi), %edx
cmpl %edx, %eax
jl 0x17845
decb 0x3c(%rdi)
btl $0x8, %ecx
jb 0x17833
movzbl 0x3a(%rdi), %eax
cmpl %eax, %ecx
jl 0x17833
decb 0x3c(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xab47(%rip), %rsi      # 0x223b1
movl $0x4, %edx
callq 0xf828
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa276
movb $0x1, %bpl
xorl %r15d, %r15d
leaq 0x17964(%rip), %r12     # 0x2f1f0
movq (%r15,%r12), %rsi
movq %rbx, %rdi
callq 0xfa60
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa276
movb %bpl, 0xa(%r14)
addq $0x8, %r15
incb %bpl
cmpq $0xb0, %r15
jne 0x1788c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x178df
movq 0x38(%rdi), %rdi
leaq 0xcfe4(%rip), %rsi      # 0x248bc
xorl %eax, %eax
jmp 0xc391
leal -0x101(%rdx), %eax
leaq 0x17904(%rip), %rcx     # 0x2f1f0
movq (%rcx,%rax,8), %rax
cmpl $0x120, %edx            # imm = 0x120
ja 0x1790d
movq 0x38(%rdi), %rdi
leaq 0xd478(%rip), %rsi      # 0x24d7b
movq %rax, %rdx
xorl %eax, %eax
jmp 0xc391
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8097
testl %r12d, %r12d
je 0x17992
movq %rax, %r14
movq 0x38(%rbx), %r15
leal -0x122(%r12), %eax
movq %rbx, %rdi
cmpl $0x3, %eax
ja 0x17973
xorl %esi, %esi
callq 0x18472
movq 0x38(%rbx), %rdi
movq 0x48(%rbx), %rax
movq (%rax), %rdx
leaq 0xd411(%rip), %rsi      # 0x24d7b
xorl %eax, %eax
callq 0xc391
jmp 0x1797b
movl %r12d, %esi
callq 0x178c3
leaq 0xbfbe(%rip), %rsi      # 0x23940
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xc391
movq 0x38(%rbx), %rdi
movl $0x3, %esi
callq 0x8578
// File: /workspace/github_c_makefile_star2_O3/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 0xf828
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 0x1005a
cmpl $0x0, 0x8(%rax)
je 0x179f1
movq 0x10(%rax), %r14
jmp 0x17a0e
movl $0x1, %ecx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
movq 0x18(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jle 0x17a0e
movq %rbx, %rdi
callq 0xa9cc
addq $-0x10, 0x10(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, 0x10(%rsi)
movq %rdi, 0x38(%rsi)
movl %r8d, (%rsi)
movl $0x121, 0x20(%rsi)      # imm = 0x121
movq %rdx, 0x40(%rsi)
movq $0x0, 0x30(%rsi)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x4(%rsi)
movq %rcx, 0x60(%rsi)
leaq 0xa957(%rip), %rsi      # 0x223b1
movl $0x4, %edx
callq 0xf828
movq %rax, 0x68(%rbx)
movq 0x38(%rbx), %rdi
movq 0x48(%rbx), %rax
movq (%rax), %rsi
movq 0x10(%rax), %rdx
movl $0x20, %ecx
callq 0xb897
movq 0x48(%rbx), %rcx
movq %rax, (%rcx)
movq $0x20, 0x10(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17ab8
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x17ace
movl %eax, 0x10(%rbx)
jmp 0x17acc
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_O3/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 0x184c1
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rax, %rdx
jae 0x184d1
leaq (%rdx,%rdx), %r14
movq 0x38(%rdi), %rdi
movq (%r15), %rsi
movq %r14, %rcx
callq 0xb897
movq %rax, (%r15)
movq %r14, 0x10(%r15)
movq 0x8(%r15), %rcx
leaq 0x1(%rcx), %rsi
jmp 0x184c4
movq (%r15), %rax
movq %rsi, 0x8(%r15)
movb %bl, (%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb473(%rip), %rsi      # 0x2394b
xorl %edx, %edx
callq 0x17917
// File: /workspace/github_c_makefile_star2_O3/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 0x184f8
callq 0x14598
jmp 0x18507
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
cmpl $0xd, %eax
je 0x18513
cmpl $0xa, %eax
jne 0x18539
cmpl %ebp, %eax
je 0x18539
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x18528
callq 0x14598
jmp 0x18537
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 0x1854f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xb42c(%rip), %rsi      # 0x23982
movq %rbx, %rdi
xorl %edx, %edx
callq 0x17917
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %r14
movl (%rdi), %ebx
movl %ebx, %esi
callq 0x18472
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x18581
callq 0x14598
jmp 0x18590
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
xorl %ebp, %ebp
cmpl $0x3d, %eax
jne 0x185d3
xorl %ebp, %ebp
movq %r14, %rdi
movl $0x3d, %esi
callq 0x18472
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x185ba
callq 0x14598
jmp 0x185c9
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
incl %ebp
cmpl $0x3d, %eax
je 0x1859c
xorl %ecx, %ecx
cmpl %ebx, %eax
setne %cl
negl %ecx
xorl %ebp, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1878a
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
subq $0x1, (%rdi)
jae 0x18773
callq 0x14598
jmp 0x18782
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18472
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x187b9
callq 0x14598
jmp 0x187c8
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
cmpl $0x30, %ebp
jne 0x187f5
leaq 0xb284(%rip), %rsi      # 0x23a5b
movq %r14, %rdi
callq 0x1896a
testl %eax, %eax
leaq 0xb270(%rip), %rax      # 0x23a58
leaq 0xb26f(%rip), %r15      # 0x23a5e
cmoveq %rax, %r15
jmp 0x187fc
leaq 0xb25c(%rip), %r15      # 0x23a58
leaq 0xae8d(%rip), %r13      # 0x23690
leaq 0xb257(%rip), %r12      # 0x23a61
movq %r14, %rdi
movq %r15, %rsi
callq 0x1896a
testl %eax, %eax
je 0x18824
movq %r14, %rdi
movq %r12, %rsi
callq 0x1896a
movslq (%r14), %rsi
testb $0x10, 0x1(%rsi,%r13)
jne 0x1883e
movq %r14, %rdi
cmpl $0x2e, %esi
jne 0x1886b
movl $0x2e, %esi
jmp 0x18841
movq %r14, %rdi
callq 0x18472
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x18857
callq 0x14598
jmp 0x18866
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
jmp 0x1880a
xorl %esi, %esi
callq 0x18472
movq 0x48(%r14), %rax
movq (%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0xbcb7
testq %rax, %rax
je 0x188b0
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 0xb1ad(%rip), %rsi      # 0x23a64
movq %r14, %rdi
movl $0x122, %edx            # imm = 0x122
callq 0x17917
// File: /workspace/github_c_makefile_star2_O3/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 0x188c9
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl (%rdi), %esi
cmpl $-0x1, %esi
je 0x18905
movq %r14, %rdi
callq 0x18472
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x188f3
callq 0x14598
jmp 0x18902
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 0x17917
// File: /workspace/github_c_makefile_star2_O3/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 0x18984
movsbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %esi
jne 0x189b3
movq %rbx, %rdi
callq 0x18472
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x1899d
callq 0x14598
jmp 0x189ac
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
movl $0x1, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaopen_base
LUAMOD_API int luaopen_base (lua_State *L) {
  /* open lib into global table */
  lua_pushglobaltable(L);
  luaL_setfuncs(L, base_funcs, 0);
  /* set global _G */
  lua_pushvalue(L, -1);
  lua_setfield(L, -2, "_G");
  /* set global _VERSION */
  lua_pushliteral(L, LUA_VERSION);
  lua_setfield(L, -2, "_VERSION");
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, %edx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6970
leaq 0x1694e(%rip), %rsi     # 0x2f320
movq %rbx, %rdi
xorl %edx, %edx
callq 0x15bde
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x606b
leaq 0xab32(%rip), %rdx      # 0x23522
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
leaq 0xb07c(%rip), %rsi      # 0x23a80
movq %rbx, %rdi
callq 0x656b
leaq 0xb075(%rip), %rdx      # 0x23a88
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_assert
static int luaB_assert (lua_State *L) {
  if (lua_toboolean(L, 1))  /* condition is true? */
    return lua_gettop(L);  /* return all arguments */
  else {  /* error */
    luaL_checkany(L, 1);  /* there must be a condition */
    lua_remove(L, 1);  /* remove it */
    lua_pushliteral(L, "assertion failed!");  /* default message */
    lua_settop(L, 1);  /* leave only message (default if no other one) */
    return luaB_error(L);  /* call 'error' */
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x6333
testl %eax, %eax
je 0x18a42
movq %rbx, %rdi
popq %rbx
jmp 0x5d39
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1506d
movq %rbx, %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5eb2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
leaq 0xb0a3(%rip), %rsi      # 0x23b18
movq %rbx, %rdi
callq 0x656b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5d4d
movq %rbx, %rdi
popq %rbx
jmp 0x18baa
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_collectgarbage
static int luaB_collectgarbage (lua_State *L) {
  static const char *const opts[] = {"stop", "restart", "collect",
    "count", "step", "setpause", "setstepmul",
    "isrunning", NULL};
  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
    LUA_GCISRUNNING};
  int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
  int ex = (int)luaL_optinteger(L, 2, 0);
  int res = lua_gc(L, o, ex);
  switch (o) {
    case LUA_GCCOUNT: {
      int b = lua_gc(L, LUA_GCCOUNTB, 0);
      lua_pushnumber(L, (lua_Number)res + ((lua_Number)b/1024));
      return 1;
    }
    case LUA_GCSTEP: case LUA_GCISRUNNING: {
      lua_pushboolean(L, res);
      return 1;
    }
    default: {
      lua_pushinteger(L, res);
      return 1;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xb096(%rip), %rdx      # 0x23b37
leaq 0x16a08(%rip), %rcx     # 0x2f4b0
movl $0x1, %esi
callq 0x14f15
cltq
leaq 0xb1b5(%rip), %rcx      # 0x23c70
movl (%rcx,%rax,4), %ebp
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1518f
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x71b2
movl %eax, %r14d
cmpl $0x9, %ebp
je 0x18b19
cmpl $0x5, %ebp
je 0x18b19
cmpl $0x3, %ebp
jne 0x18b26
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x71b2
cvtsi2sd %r14d, %xmm1
cvtsi2sd %eax, %xmm0
mulsd 0xaf6d(%rip), %xmm0     # 0x23a78
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x64e1
jmp 0x18b31
movq %rbx, %rdi
movl %r14d, %esi
callq 0x6725
jmp 0x18b31
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x64f6
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_dofile
static int luaB_dofile (lua_State *L) {
  const char *fname = luaL_optstring(L, 1, NULL);
  lua_settop(L, 1);
  if (luaL_loadfile(L, fname) != LUA_OK)
    return lua_error(L);
  lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);
  return dofilecont(L, 0, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x14fa6
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5d4d
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1560a
testl %eax, %eax
je 0x18b80
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x72d9
leaq 0x9c5(%rip), %r8        # 0x1954c
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x6f67
movq %rbx, %rdi
callq 0x5d39
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_error
static int luaB_error (lua_State *L) {
  int level = (int)luaL_optinteger(L, 2, 1);
  lua_settop(L, 1);
  if (lua_type(L, 1) == LUA_TSTRING && level > 0) {
    luaL_where(L, level);   /* add extra information */
    lua_pushvalue(L, 1);
    lua_concat(L, 2);
  }
  return lua_error(L);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edx
movl $0x2, %esi
callq 0x1518f
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5d4d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x608f
cmpl $0x4, %eax
sete %al
testl %r14d, %r14d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x18c15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x14bf4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x606b
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7316
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x72d9
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_getmetatable
static int luaB_getmetatable (lua_State *L) {
  luaL_checkany(L, 1);
  if (!lua_getmetatable(L, 1)) {
    lua_pushnil(L);
    return 1;  /* no metatable */
  }
  luaL_getmetafield(L, 1, "__metatable");
  return 1;  /* returns either __metatable field (if present) or metatable */
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1506d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6a5a
testl %eax, %eax
je 0x18c59
leaq 0xaf1e(%rip), %rdx      # 0x23b68
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1599b
jmp 0x18c61
movq %rbx, %rdi
callq 0x64cd
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_ipairs
static int luaB_ipairs (lua_State *L) {
#if defined(LUA_COMPAT_IPAIRS)
  return pairsmeta(L, "__ipairs", 1, ipairsaux);
#else
  luaL_checkany(L, 1);
  lua_pushcfunction(L, ipairsaux);  /* iteration function */
  lua_pushvalue(L, 1);  /* state */
  lua_pushinteger(L, 0);  /* initial value */
  return 3;
#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1506d
leaq 0x8d9(%rip), %rsi       # 0x19556
movq %rbx, %rdi
xorl %edx, %edx
callq 0x66a8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x606b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x64f6
movl $0x3, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_loadfile
static int luaB_loadfile (lua_State *L) {
  const char *fname = luaL_optstring(L, 1, NULL);
  const char *mode = luaL_optstring(L, 2, NULL);
  int env = (!lua_isnone(L, 3) ? 3 : 0);  /* 'env' index or 0 if no 'env' */
  int status = luaL_loadfilex(L, fname, mode);
  return load_aux(L, status, env);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x14fa6
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x14fa6
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x608f
xorl %ecx, %ecx
cmpl $-0x1, %eax
setne %cl
leal (%rcx,%rcx,2), %ebp
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1560a
movq %rbx, %rdi
movl %eax, %esi
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x19598
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_load
static int luaB_load (lua_State *L) {
  int status;
  size_t l;
  const char *s = lua_tolstring(L, 1, &l);
  const char *mode = luaL_optstring(L, 3, "bt");
  int env = (!lua_isnone(L, 4) ? 4 : 0);  /* 'env' index or 0 if no 'env' */
  if (s != NULL) {  /* loading a string? */
    const char *chunkname = luaL_optstring(L, 2, s);
    status = luaL_loadbufferx(L, s, l, chunkname, mode);
  }
  else {  /* loading from a reader function */
    const char *chunkname = luaL_optstring(L, 2, "=(load)");
    luaL_checktype(L, 1, LUA_TFUNCTION);
    lua_settop(L, RESERVEDSLOT);  /* create reserved slot */
    status = lua_load(L, generic_reader, NULL, chunkname, mode);
  }
  return load_aux(L, status, env);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdx
movl $0x1, %esi
callq 0x6359
movq %rax, %r15
leaq 0xae43(%rip), %rdx      # 0x23b74
movq %rbx, %rdi
movl $0x3, %esi
xorl %ecx, %ecx
callq 0x14fa6
movq %rax, %r14
movq %rbx, %rdi
movl $0x4, %esi
callq 0x608f
movl %eax, %ebp
testq %r15, %r15
je 0x18d80
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x14fa6
movq (%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rcx
movq %r14, %r8
callq 0x1591e
jmp 0x18dcf
leaq 0xadf0(%rip), %rdx      # 0x23b77
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x14fa6
movq %rax, %r15
movq %rbx, %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x15039
movq %rbx, %rdi
movl $0x5, %esi
callq 0x5d4d
leaq 0x84b(%rip), %rsi       # 0x1960a
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x70d3
xorl %edx, %edx
cmpl $-0x1, %ebp
setne %dl
shll $0x2, %edx
movq %rbx, %rdi
movl %eax, %esi
callq 0x19598
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_next
static int luaB_next (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  lua_settop(L, 2);  /* create a 2nd argument if there isn't one */
  if (lua_next(L, 1))
    return 2;
  else {
    lua_pushnil(L);
    return 1;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x15039
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5d4d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x72df
testl %eax, %eax
jne 0x18e34
movq %rbx, %rdi
callq 0x64cd
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_pcall
static int luaB_pcall (lua_State *L) {
  int status;
  luaL_checkany(L, 1);
  lua_pushboolean(L, 1);  /* first result if no errors */
  lua_insert(L, 1);  /* put it in place */
  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall);
  return finishpcall(L, status, 0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1506d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6725
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x5eb2
movq %rbx, %rdi
callq 0x5d39
leal -0x2(%rax), %esi
leaq 0x7db(%rip), %r9        # 0x196cd
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6fcf
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x196cd
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_print
static int luaB_print (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  lua_getglobal(L, "tostring");
  for (i=1; i<=n; i++) {
    const char *s;
    size_t l;
    lua_pushvalue(L, -1);  /* function to be called */
    lua_pushvalue(L, i);   /* value to print */
    lua_call(L, 1, 1);
    s = lua_tolstring(L, -1, &l);  /* get result */
    if (s == NULL)
      return luaL_error(L, "'tostring' must return a string to 'print'");
    if (i>1) lua_writestring("\t", 1);
    lua_writestring(s, l);
    lua_pop(L, 1);  /* pop result */
  }
  lua_writeline();
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5d39
movl %eax, %r14d
leaq 0xa44b(%rip), %rsi      # 0x23379
movq %rbx, %rdi
callq 0x6777
testl %r14d, %r14d
jle 0x18fe6
negl %r14d
movl $0x1, %r15d
movq %rsp, %r12
movq 0x17076(%rip), %rbp     # 0x2ffc8
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x606b
movq %rbx, %rdi
movl %r15d, %esi
callq 0x606b
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6f67
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r12, %rdx
callq 0x6359
testq %rax, %rax
je 0x19006
movq %rax, %r13
cmpl $0x2, %r15d
jb 0x18fad
movq (%rbp), %rsi
movl $0x9, %edi
callq 0x5210
movq (%rsp), %rdx
movq (%rbp), %rcx
movl $0x1, %esi
movq %r13, %rdi
callq 0x5490
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
leal (%r14,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0x18f52
movq 0x16fdb(%rip), %rbx     # 0x2ffc8
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x5210
movq (%rbx), %rdi
callq 0x5350
xorl %eax, %eax
jmp 0x19017
leaq 0xabb9(%rip), %rsi      # 0x23bc6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x14a62
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/lbaselib.c
// Function: luaB_rawequal
static int luaB_rawequal (lua_State *L) {
  luaL_checkany(L, 1);
  luaL_checkany(L, 2);
  lua_pushboolean(L, lua_rawequal(L, 1, 2));
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1506d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1506d
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x6146
movq %rbx, %rdi
movl %eax, %esi
callq 0x6725
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_rawlen
static int luaB_rawlen (lua_State *L) {
  int t = lua_type(L, 1);
  luaL_argcheck(L, t == LUA_TTABLE || t == LUA_TSTRING, 1,
                   "table or string expected");
  lua_pushinteger(L, lua_rawlen(L, 1));
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x608f
andl $-0x2, %eax
cmpl $0x4, %eax
je 0x1908e
leaq 0xab70(%rip), %rdx      # 0x23bf1
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1497c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x63d9
movq %rbx, %rdi
movq %rax, %rsi
callq 0x64f6
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_rawget
static int luaB_rawget (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_checkany(L, 2);
  lua_settop(L, 2);
  lua_rawget(L, 1);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x15039
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1506d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5d4d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x693a
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_rawset
static int luaB_rawset (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_checkany(L, 2);
  luaL_checkany(L, 3);
  lua_settop(L, 3);
  lua_rawset(L, 1);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x15039
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1506d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1506d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5d4d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6d43
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_select
static int luaB_select (lua_State *L) {
  int n = lua_gettop(L);
  if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
    lua_pushinteger(L, n-1);
    return 1;
  }
  else {
    lua_Integer i = luaL_checkinteger(L, 1);
    if (i < 0) i = n + i;
    else if (i > n) i = n;
    luaL_argcheck(L, 1 <= i, 1, "index out of range");
    return n - (int)i;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5d39
movl %eax, %ebx
movq %r14, %rdi
movl $0x1, %esi
callq 0x608f
cmpl $0x4, %eax
jne 0x19187
movl $0x1, %ebp
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x6359
cmpb $0x23, (%rax)
jne 0x19187
decl %ebx
movslq %ebx, %rsi
movq %r14, %rdi
callq 0x64f6
jmp 0x191c7
movq %r14, %rdi
movl $0x1, %esi
callq 0x15124
movslq %ebx, %r15
leaq (%rax,%r15), %rcx
cmpq %r15, %rax
cmovlq %rax, %r15
testq %rax, %rax
cmovsq %rcx, %r15
testq %r15, %r15
jg 0x191c2
leaq 0xaa55(%rip), %rdx      # 0x23c0a
movq %r14, %rdi
movl $0x1, %esi
callq 0x1497c
subl %r15d, %ebx
movl %ebx, %ebp
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/lbaselib.c
// Function: luaB_setmetatable
static int luaB_setmetatable (lua_State *L) {
  int t = lua_type(L, 2);
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
                    "nil or table expected");
  if (luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL)
    return luaL_error(L, "cannot change a protected metatable");
  lua_settop(L, 2);
  lua_setmetatable(L, 1);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, %esi
callq 0x608f
movl %eax, %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x15039
testl %ebp, %ebp
je 0x19215
cmpl $0x5, %ebp
je 0x19215
leaq 0xaa15(%rip), %rdx      # 0x23c1d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1497c
leaq 0xa94c(%rip), %rdx      # 0x23b68
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1599b
testl %eax, %eax
je 0x19244
leaq 0xa9ff(%rip), %rsi      # 0x23c33
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x14a62
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5d4d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6e85
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_type
static int luaB_type (lua_State *L) {
  int t = lua_type(L, 1);
  luaL_argcheck(L, t != LUA_TNONE, 1, "value expected");
  lua_pushstring(L, lua_typename(L, t));
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x608f
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x194a7
leaq 0x9e88(%rip), %rdx      # 0x23322
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1497c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x60b0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x656b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_xpcall
static int luaB_xpcall (lua_State *L) {
  int status;
  int n = lua_gettop(L);
  luaL_checktype(L, 2, LUA_TFUNCTION);  /* check error function */
  lua_pushboolean(L, 1);  /* first result */
  lua_pushvalue(L, 1);  /* function */
  lua_rotate(L, 3, 2);  /* move them below function's arguments */
  status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall);
  return finishpcall(L, status, 2);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5d39
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x15039
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6725
movq %rbx, %rdi
movl $0x1, %esi
callq 0x606b
movq %rbx, %rdi
movl $0x3, %esi
movl $0x2, %edx
callq 0x5eb2
addl $-0x2, %ebp
leaq 0x1b0(%rip), %r9        # 0x196cd
movl $0x2, %r8d
movq %rbx, %rdi
movl %ebp, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x2, %ecx
callq 0x6fcf
movl $0x2, %edx
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x196cd
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: load_aux
static int load_aux (lua_State *L, int status, int envidx) {
  if (status == LUA_OK) {
    if (envidx != 0) {  /* 'env' parameter? */
      lua_pushvalue(L, envidx);  /* environment for loaded function */
      if (!lua_setupvalue(L, -2, 1))  /* set it as 1st upvalue */
        lua_pop(L, 1);  /* remove 'env' if not used by previous call */
    }
    return 1;
  }
  else {  /* error (message is on top of the stack) */
    lua_pushnil(L);
    lua_insert(L, -2);  /* put before error message */
    return 2;  /* return nil plus error message */
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x195ca
movq %rbx, %rdi
callq 0x64cd
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5eb2
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
testl %edx, %edx
je 0x19603
movq %rbx, %rdi
movl %edx, %esi
callq 0x606b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x74df
testq %rax, %rax
jne 0x195c1
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
jmp 0x195c1
movl $0x1, %ebp
jmp 0x195c1
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: generic_reader
static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
  (void)(ud);  /* not used */
  luaL_checkstack(L, 2, "too many nested functions");
  lua_pushvalue(L, 1);  /* get function */
  lua_call(L, 0, 1);  /* call it */
  if (lua_isnil(L, -1)) {
    lua_pop(L, 1);  /* pop result */
    *size = 0;
    return NULL;
  }
  else if (!lua_isstring(L, -1))
    luaL_error(L, "reader function must return a string");
  lua_replace(L, RESERVEDSLOT);  /* save string in reserved slot */
  return lua_tolstring(L, RESERVEDSLOT, size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xa564(%rip), %rdx      # 0x23b7f
movl $0x2, %esi
callq 0x14929
movq %r14, %rdi
movl $0x1, %esi
callq 0x606b
movq %r14, %rdi
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6f67
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x608f
testl %eax, %eax
je 0x196af
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6111
testl %eax, %eax
jne 0x19679
leaq 0xa52a(%rip), %rsi      # 0x23b99
movq %r14, %rdi
xorl %eax, %eax
callq 0x14a62
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x5, %edx
callq 0x6010
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movq %r14, %rdi
movl $0x5, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6359
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: finishpcall
static int finishpcall (lua_State *L, int status, lua_KContext extra) {
  if (status != LUA_OK && status != LUA_YIELD) {  /* error? */
    lua_pushboolean(L, 0);  /* first result (false) */
    lua_pushvalue(L, -2);  /* error message */
    return 2;  /* return false, msg */
  }
  else
    return lua_gettop(L) - (int)extra;  /* return all results */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x2, %esi
jb 0x196f7
movq %r14, %rdi
xorl %esi, %esi
callq 0x6725
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x606b
movl $0x2, %eax
jmp 0x19704
movq %rdx, %rbx
movq %r14, %rdi
callq 0x5d39
subl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcorolib.c
// Function: luaB_cocreate
static int luaB_cocreate (lua_State *L) {
  lua_State *NL;
  luaL_checktype(L, 1, LUA_TFUNCTION);
  NL = lua_newthread(L);
  lua_pushvalue(L, 1);  /* move function to top */
  lua_xmove(L, NL, 1);  /* move function from L to NL */
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x6, %edx
callq 0x15039
movq %rbx, %rdi
callq 0xf0d1
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x606b
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x5ca7
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcorolib.c
// Function: luaB_coresume
static int luaB_coresume (lua_State *L) {
  lua_State *co = getco(L);
  int r;
  r = auxresume(L, co, lua_gettop(L) - 1);
  if (r < 0) {
    lua_pushboolean(L, 0);
    lua_insert(L, -2);
    return 2;  /* return false + error message */
  }
  else {
    lua_pushboolean(L, 1);
    lua_insert(L, -(r + 1));
    return r + 1;  /* return true + 'resume' returns */
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x19908
movq %rax, %r14
movq %rbx, %rdi
callq 0x5d39
leal -0x1(%rax), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19940
testl %eax, %eax
js 0x197d6
movl %eax, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6725
leal 0x1(%r14), %ebp
notl %r14d
jmp 0x197eb
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6725
movl $0x2, %ebp
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
movq %rbx, %rdi
movl %r14d, %esi
movl $0x1, %edx
callq 0x5eb2
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcorolib.c
// Function: luaB_costatus
static int luaB_costatus (lua_State *L) {
  lua_State *co = getco(L);
  if (L == co) lua_pushliteral(L, "running");
  else {
    switch (lua_status(co)) {
      case LUA_YIELD:
        lua_pushliteral(L, "suspended");
        break;
      case LUA_OK: {
        lua_Debug ar;
        if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
          lua_pushliteral(L, "normal");  /* it is running */
        else if (lua_gettop(co) == 0)
            lua_pushliteral(L, "dead");
        else
          lua_pushliteral(L, "suspended");  /* initial state */
        break;
      }
      default:  /* some error occurred */
        lua_pushliteral(L, "dead");
        break;
    }
  }
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x19908
cmpq %rbx, %rax
je 0x19850
movq %rax, %r14
movq %rax, %rdi
callq 0x71ad
testl %eax, %eax
je 0x19859
cmpl $0x1, %eax
jne 0x19875
leaq 0xa4b7(%rip), %rsi      # 0x23d05
jmp 0x1989a
leaq 0xa309(%rip), %rsi      # 0x23b60
jmp 0x1989a
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x76f2
testl %eax, %eax
jle 0x1987e
leaq 0xa49c(%rip), %rsi      # 0x23d0f
jmp 0x1989a
leaq 0xa49a(%rip), %rsi      # 0x23d16
jmp 0x1989a
movq %r14, %rdi
callq 0x5d39
testl %eax, %eax
leaq 0xa487(%rip), %rax      # 0x23d16
leaq 0xa46f(%rip), %rsi      # 0x23d05
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x656b
movl $0x1, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lcorolib.c
// Function: auxresume
static int auxresume (lua_State *L, lua_State *co, int narg) {
  int status;
  if (!lua_checkstack(co, narg)) {
    lua_pushliteral(L, "too many arguments to resume");
    return -1;  /* error flag */
  }
  if (lua_status(co) == LUA_OK && lua_gettop(co) == 0) {
    lua_pushliteral(L, "cannot resume dead coroutine");
    return -1;  /* error flag */
  }
  lua_xmove(L, co, narg);
  status = lua_resume(co, L, narg);
  if (status == LUA_OK || status == LUA_YIELD) {
    int nres = lua_gettop(co);
    if (!lua_checkstack(L, nres + 1)) {
      lua_pop(co, nres);  /* remove results anyway */
      lua_pushliteral(L, "too many results to resume");
      return -1;  /* error flag */
    }
    lua_xmove(co, L, nres);  /* move yielded values */
    return nres;
  }
  else {
    lua_xmove(co, L, 1);  /* move error message */
    return -1;  /* error flag */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x5c18
testl %eax, %eax
je 0x199bf
movq %r14, %rdi
callq 0x71ad
testl %eax, %eax
jne 0x19975
movq %r14, %rdi
callq 0x5d39
testl %eax, %eax
je 0x199f1
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x5ca7
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x90d7
cmpl $0x1, %eax
ja 0x199c8
movq %r14, %rdi
callq 0x5d39
movl %eax, %r15d
leal 0x1(%r15), %esi
movq %rbx, %rdi
callq 0x5c18
testl %eax, %eax
je 0x199da
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x5ca7
jmp 0x19a06
leaq 0xa307(%rip), %rsi      # 0x23ccd
jmp 0x199f8
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x5ca7
jmp 0x19a00
notl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5d4d
leaq 0xa2fb(%rip), %rsi      # 0x23cea
jmp 0x199f8
leaq 0x8a82(%rip), %rsi      # 0x2247a
movq %rbx, %rdi
callq 0x656b
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq