LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_str2num
size_t luaO_str2num (const char *s, TValue *o) {
  lua_Integer i; lua_Number n;
  const char *e;
  if ((e = l_str2int(s, &i)) != NULL) {  /* try as an integer */
    setivalue(o, i);
  }
  else if ((e = l_str2d(s, &n)) != NULL) {  /* else try as a float */
    setfltvalue(o, n);
  }
  else
    return 0;  /* conversion failed */
  return (e - s) + 1;  /* success; return string size */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10960
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x108f7
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl $0x13, 0x8(%rax)
jmp 0x1093c
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x10b70
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x10930
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x40(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x40(%rbp), %rax
movl $0x3, 0x8(%rax)
jmp 0x1093a
movq $0x0, -0x8(%rbp)
jmp 0x1094f
jmp 0x1093c
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: l_str2d
static const char *l_str2d (const char *s, lua_Number *result) {
  const char *endptr;
  const char *pmode = strpbrk(s, ".xXnN");
  int mode = pmode ? ltolower(cast_uchar(*pmode)) : 0;
  if (mode == 'n')  /* reject 'inf' and 'nan' */
    return NULL;
  endptr = l_str2dloc(s, result, mode);  /* try to convert */
  if (endptr == NULL) {  /* failed? may be a different locale */
    char buff[L_MAXLENNUM + 1];
    char *pdot = strchr(s, '.');
    if (strlen(s) > L_MAXLENNUM || pdot == NULL)
      return NULL;  /* string too long or no dot; fail */
    strcpy(buff, s);  /* copy string to buffer */
    buff[pdot - s] = lua_getlocaledecpoint();  /* correct decimal point */
    endptr = l_str2dloc(buff, result, mode);  /* try again */
    if (endptr != NULL)
      endptr = s + (endptr - buff);  /* make relative to 's' */
  }
  return endptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x240a0(%rip), %rsi     # 0x34c2e
callq 0x53a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x10bb0
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
orl $0x20, %eax
movl %eax, -0x10c(%rbp)
jmp 0x10bba
xorl %eax, %eax
movl %eax, -0x10c(%rbp)
jmp 0x10bba
movl -0x10c(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x6e, -0x2c(%rbp)
jne 0x10bd6
movq $0x0, -0x8(%rbp)
jmp 0x10c9f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x117d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10c97
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x5170
movq %rax, -0x108(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5150
cmpq $0xc8, %rax
ja 0x10c25
cmpq $0x0, -0x108(%rbp)
jne 0x10c2f
movq $0x0, -0x8(%rbp)
jmp 0x10c9f
leaq -0x100(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x50b0
callq 0x5100
movq (%rax), %rax
movb (%rax), %cl
movq -0x108(%rbp), %rax
movq -0x10(%rbp), %rdx
subq %rdx, %rax
movb %cl, -0x100(%rbp,%rax)
leaq -0x100(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x117d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x10c95
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
leaq -0x100(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x10c97
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_utf8esc
int luaO_utf8esc (char *buff, unsigned long x) {
  int n = 1;  /* number of bytes put in buffer (backwards) */
  lua_assert(x <= 0x10FFFF);
  if (x < 0x80)  /* ascii? */
    buff[UTF8BUFFSZ - 1] = cast(char, x);
  else {  /* need continuation bytes */
    unsigned int mfb = 0x3f;  /* maximum that fits in first byte */
    do {  /* add continuation bytes */
      buff[UTF8BUFFSZ - (n++)] = cast(char, 0x80 | (x & 0x3f));
      x >>= 6;  /* remove added bits */
      mfb >>= 1;  /* now there is one less bit available in first byte */
    } while (x > mfb);  /* still needs continuation byte? */
    buff[UTF8BUFFSZ - n] = cast(char, (~mfb << 1) | x);  /* add first byte */
  }
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
cmpq $0x80, -0x10(%rbp)
jae 0x10cdc
movq -0x10(%rbp), %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x7(%rax)
jmp 0x10d51
movl $0x3f, -0x18(%rbp)
movq -0x10(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %esi
movl %esi, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movl $0x8, %ecx
subl %esi, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %eax
shrl %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
cmpq %rcx, %rax
ja 0x10ce3
movl -0x18(%rbp), %eax
xorl $-0x1, %eax
shll %eax
movl %eax, %eax
orq -0x10(%rbp), %rax
movb %al, %dl
movq -0x8(%rbp), %rax
movl $0x8, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_tostring
void luaO_tostring (lua_State *L, StkId obj) {
  char buff[MAXNUMBER2STR];
  size_t len;
  lua_assert(ttisnumber(obj));
  if (ttisinteger(obj))
    len = lua_integer2str(buff, sizeof(buff), ivalue(obj));
  else {
    len = lua_number2str(buff, sizeof(buff), fltvalue(obj));
#if !defined(LUA_COMPAT_FLOATSTRING)
    if (buff[strspn(buff, "-0123456789")] == '\0') {  /* looks like an int? */
      buff[len++] = lua_getlocaledecpoint();
      buff[len++] = '0';  /* adds '.0' to result */
    }
#endif
  }
  setsvalue2s(L, obj, luaS_newlstr(L, buff, len));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x13, 0x8(%rax)
jne 0x10da0
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x32, %esi
leaq 0x23e3f(%rip), %rdx     # 0x34bd0
movb $0x0, %al
callq 0x5190
cltq
movq %rax, -0x58(%rbp)
jmp 0x10e12
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movl $0x32, %esi
leaq 0x23e1d(%rip), %rdx     # 0x34bd5
movb $0x1, %al
callq 0x5190
cltq
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x23e0b(%rip), %rsi     # 0x34bdb
callq 0x51e0
movsbl -0x50(%rbp,%rax), %eax
cmpl $0x0, %eax
jne 0x10e10
callq 0x5100
movq (%rax), %rax
movb (%rax), %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, -0x50(%rbp,%rax)
movq -0x58(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x58(%rbp)
movb $0x30, -0x50(%rbp,%rax)
jmp 0x10e12
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x16890
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, (%rax)
movq -0x68(%rbp), %rax
movzbl 0x8(%rax), %ecx
orl $0x40, %ecx
movq -0x60(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_pushfstring
const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
  const char *msg;
  va_list argp;
  va_start(argp, fmt);
  msg = luaO_pushvfstring(L, fmt, argp);
  va_end(argp);
  return msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x114e8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x10e60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: l_str2dloc
static const char *l_str2dloc (const char *s, lua_Number *result, int mode) {
  char *endptr;
  *result = (mode == 'x') ? lua_strx2number(s, &endptr)  /* try to convert */
                          : lua_str2number(s, &endptr);
  if (endptr == s) return NULL;  /* nothing recognized? */
  while (lisspace(cast_uchar(*endptr))) endptr++;  /* skip trailing spaces */
  return (*endptr == '\0') ? endptr : NULL;  /* OK if no trailing characters */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x78, -0x1c(%rbp)
jne 0x117fd
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x50f0
movsd %xmm0, -0x30(%rbp)
jmp 0x1180f
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x50f0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x11830
movq $0x0, -0x8(%rbp)
jmp 0x11886
jmp 0x11832
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x2426a(%rip), %rax     # 0x35ab0
movzbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x11860
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x11832
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x11876
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1187e
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x1187e
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: luaY_parser
LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
                       Dyndata *dyd, const char *name, int firstchar) {
  LexState lexstate;
  FuncState funcstate;
  LClosure *cl = luaF_newLclosure(L, 1);  /* create main closure */
  setclLvalue(L, L->top, cl);  /* anchor it (to avoid being collected) */
  luaD_inctop(L);
  lexstate.h = luaH_new(L);  /* create table for scanner */
  sethvalue(L, L->top, lexstate.h);  /* anchor it */
  luaD_inctop(L);
  funcstate.f = cl->p = luaF_newproto(L);
  funcstate.f->source = luaS_new(L, name);  /* create and anchor TString */
  lua_assert(iswhite(funcstate.f));  /* do not need barrier here */
  lexstate.buff = buff;
  lexstate.dyd = dyd;
  dyd->actvar.n = dyd->gt.n = dyd->label.n = 0;
  luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar);
  mainfunc(&lexstate, &funcstate);
  lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs);
  /* all scopes should be correctly finished */
  lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0);
  L->top--;  /* remove scanner's table */
  return cl;  /* closure is on the stack, too */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xcfb0
movq %rax, -0xe8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xf0(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rcx
movq -0xf0(%rbp), %rax
movq %rcx, (%rax)
movq -0xf0(%rbp), %rax
movl $0x46, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0xb0b0
movq -0x8(%rbp), %rdi
callq 0x17540
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x100(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rcx
movq -0x100(%rbp), %rax
movq %rcx, (%rax)
movq -0x100(%rbp), %rax
movl $0x45, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0xb0b0
movq -0x8(%rbp), %rdi
callq 0xd2d0
movq -0xe8(%rbp), %rcx
movq %rax, 0x18(%rcx)
movq %rax, -0xe0(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x16c30
movq %rax, %rcx
movq -0xe0(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0xe0(%rbp), %rax
movq 0x68(%rax), %rcx
movl -0x2c(%rbp), %r8d
leaq -0xa0(%rbp), %rsi
callq 0x24550
leaq -0xa0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x11a20
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
movq -0xe8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: mainfunc
static void mainfunc (LexState *ls, FuncState *fs) {
  BlockCnt bl;
  expdesc v;
  open_func(ls, fs, &bl);
  fs->f->is_vararg = 2;  /* main function is always declared vararg */
  init_exp(&v, VLOCAL, 0);  /* create and... */
  newupvalue(fs, ls->envn, &v);  /* ...set environment upvalue */
  luaX_next(ls);  /* read first token */
  statlist(ls);  /* parse main body */
  check(ls, TK_EOS);
  close_func(ls);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x11aa0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x2, 0xb(%rax)
leaq -0x40(%rbp), %rdi
movl $0x8, %esi
xorl %edx, %edx
callq 0x11b90
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rsi
leaq -0x40(%rbp), %rdx
callq 0x11bd0
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x8(%rbp), %rdi
callq 0x11d60
movq -0x8(%rbp), %rdi
movl $0x121, %esi            # imm = 0x121
callq 0x11dc0
movq -0x8(%rbp), %rdi
callq 0x11df0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: open_func
static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) {
  Proto *f;
  fs->prev = ls->fs;  /* linked list of funcstates */
  fs->ls = ls;
  ls->fs = fs;
  fs->pc = 0;
  fs->lasttarget = 0;
  fs->jpc = NO_JUMP;
  fs->freereg = 0;
  fs->nk = 0;
  fs->np = 0;
  fs->nups = 0;
  fs->nlocvars = 0;
  fs->nactvar = 0;
  fs->firstlocal = ls->dyd->actvar.n;
  fs->bl = NULL;
  f = fs->f;
  f->source = ls->source;
  f->maxstacksize = 2;  /* registers 0/1 are always valid */
  enterblock(fs, bl, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movb $0x0, 0x3c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x3b(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x3a(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x20(%rbp), %rax
movb $0x2, 0xc(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x12000
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: newupvalue
static int newupvalue (FuncState *fs, TString *name, expdesc *v) {
  Proto *f = fs->f;
  int oldsize = f->sizeupvalues;
  checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues");
  luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues,
                  Upvaldesc, MAXUPVAL, "upvalues");
  while (oldsize < f->sizeupvalues)
    f->upvalues[oldsize++].name = NULL;
  f->upvalues[fs->nups].instack = (v->k == VLOCAL);
  f->upvalues[fs->nups].idx = cast_byte(v->u.info);
  f->upvalues[fs->nups].name = name;
  luaC_objbarrier(fs->ls->L, f, name);
  return fs->nups++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl 0x3b(%rax), %esi
addl $0x1, %esi
movl $0xff, %edx
leaq 0x23b48(%rip), %rcx     # 0x3575c
callq 0x12080
movq -0x8(%rbp), %rax
movzbl 0x3b(%rax), %eax
addl $0x1, %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0x11c6b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rsi
movq -0x20(%rbp), %rdx
addq $0x10, %rdx
movl $0x10, %ecx
movl $0xff, %r8d
leaq 0x23b01(%rip), %r9      # 0x3575c
callq 0x10070
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
jmp 0x11c6d
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x11c9f
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
jmp 0x11c6d
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdx
movzbl 0x3b(%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movb %cl, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdx
movzbl 0x3b(%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movb %cl, 0x9(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdx
movzbl 0x3b(%rdx), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x11d46
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x11d46
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xd5a0
jmp 0x11d48
jmp 0x11d48
movq -0x8(%rbp), %rcx
movb 0x3b(%rcx), %al
movb %al, %dl
addb $0x1, %dl
movb %dl, 0x3b(%rcx)
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: statlist
static void statlist (LexState *ls) {
  /* statlist -> { stat [';'] } */
  while (!block_follow(ls, 1)) {
    if (ls->t.token == TK_RETURN) {
      statement(ls);
      return;  /* 'return' must be last statement */
    }
    statement(ls);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x12160
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11d88
jmp 0x11dab
movq -0x8(%rbp), %rax
cmpl $0x112, 0x10(%rax)      # imm = 0x112
jne 0x11da0
movq -0x8(%rbp), %rdi
callq 0x121c0
jmp 0x11dab
movq -0x8(%rbp), %rdi
callq 0x121c0
jmp 0x11d6c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: enterblock
static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) {
  bl->isloop = isloop;
  bl->nactvar = fs->nactvar;
  bl->firstlabel = fs->ls->dyd->label.n;
  bl->firstgoto = fs->ls->dyd->gt.n;
  bl->upval = 0;
  bl->previous = fs->bl;
  fs->bl = bl;
  lua_assert(fs->freereg == fs->nactvar);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x12(%rax)
movq -0x8(%rbp), %rax
movb 0x3a(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x58(%rax), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x58(%rax), %rax
movl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x11(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: errorlimit
static l_noret errorlimit (FuncState *fs, int limit, const char *what) {
  lua_State *L = fs->ls->L;
  const char *msg;
  int line = fs->f->linedefined;
  const char *where = (line == 0)
                      ? "main function"
                      : luaO_pushfstring(L, "function at line %d", line);
  msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s",
                             what, limit, where);
  luaX_syntaxerror(fs->ls, msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x28(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x12103
leaq 0x22c72(%rip), %rax     # 0x34d6f
movq %rax, -0x40(%rbp)
jmp 0x1211c
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0x22c6c(%rip), %rsi     # 0x34d7d
movb $0x0, %al
callq 0x114b0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0xc(%rbp), %ecx
movq -0x38(%rbp), %r8
leaq 0x22c57(%rip), %rsi     # 0x34d91
movb $0x0, %al
callq 0x114b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x24390
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: block_follow
static int block_follow (LexState *ls, int withuntil) {
  switch (ls->t.token) {
    case TK_ELSE: case TK_ELSEIF:
    case TK_END: case TK_EOS:
      return 1;
    case TK_UNTIL: return withuntil;
    default: return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
addl $0xfffffefc, %eax       # imm = 0xFFFFFEFC
subl $0x3, %eax
jb 0x12199
jmp 0x12181
movl -0x18(%rbp), %eax
subl $0x115, %eax            # imm = 0x115
je 0x121a2
jmp 0x1218d
movl -0x18(%rbp), %eax
subl $0x121, %eax            # imm = 0x121
jne 0x121aa
jmp 0x12199
movl $0x1, -0x4(%rbp)
jmp 0x121b1
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x121b1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: ifstat
static void ifstat (LexState *ls, int line) {
  /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
  FuncState *fs = ls->fs;
  int escapelist = NO_JUMP;  /* exit list for finished parts */
  test_then_block(ls, &escapelist);  /* IF cond THEN block */
  while (ls->t.token == TK_ELSEIF)
    test_then_block(ls, &escapelist);  /* ELSEIF cond THEN block */
  if (testnext(ls, TK_ELSE))
    block(ls);  /* 'else' part */
  check_match(ls, TK_END, TK_IF, line);
  luaK_patchtohere(fs, escapelist);  /* patch escape list to 'if' end */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x12da0
movq -0x8(%rbp), %rax
cmpl $0x105, 0x10(%rax)      # imm = 0x105
jne 0x124bb
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x12da0
jmp 0x1249f
movq -0x8(%rbp), %rdi
movl $0x104, %esi            # imm = 0x104
callq 0x12890
cmpl $0x0, %eax
je 0x124d7
movq -0x8(%rbp), %rdi
callq 0x125c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x106, %esi            # imm = 0x106
movl $0x10b, %edx            # imm = 0x10B
callq 0x12600
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x21fc0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: whilestat
static void whilestat (LexState *ls, int line) {
  /* whilestat -> WHILE cond DO block END */
  FuncState *fs = ls->fs;
  int whileinit;
  int condexit;
  BlockCnt bl;
  luaX_next(ls);  /* skip WHILE */
  whileinit = luaK_getlabel(fs);
  condexit = cond(ls);
  enterblock(fs, &bl, 1);
  checknext(ls, TK_DO);
  block(ls);
  luaK_jumpto(fs, whileinit);
  check_match(ls, TK_END, TK_WHILE, line);
  leaveblock(fs);
  luaK_patchtohere(fs, condexit);  /* false conditions finish the loop */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x18(%rbp), %rdi
callq 0x21fa0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14fd0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x12000
movq -0x8(%rbp), %rdi
movl $0x103, %esi            # imm = 0x103
callq 0x12f20
movq -0x8(%rbp), %rdi
callq 0x125c0
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21ec0
movq -0x40(%rbp), %rdi
movl %eax, %esi
movl -0x1c(%rbp), %edx
callq 0x22000
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x106, %esi            # imm = 0x106
movl $0x116, %edx            # imm = 0x116
callq 0x12600
movq -0x18(%rbp), %rdi
callq 0x12fa0
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x21fc0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: block
static void block (LexState *ls) {
  /* block -> statlist */
  FuncState *fs = ls->fs;
  BlockCnt bl;
  enterblock(fs, &bl, 0);
  statlist(ls);
  leaveblock(fs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x12000
movq -0x8(%rbp), %rdi
callq 0x11d60
movq -0x10(%rbp), %rdi
callq 0x12fa0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: check_match
static void check_match (LexState *ls, int what, int who, int where) {
  if (!testnext(ls, what)) {
    if (where == ls->linenumber)
      error_expected(ls, what);
    else {
      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
             "%s expected (to close %s at line %d)",
              luaX_token2str(ls, what), luaX_token2str(ls, who), where));
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x12890
cmpl $0x0, %eax
jne 0x12697
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x1263e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x15010
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x24300
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x24300
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movl -0x14(%rbp), %r8d
leaq 0x2286d(%rip), %rsi     # 0x34ef1
movb $0x0, %al
callq 0x114b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x24390
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: forstat
static void forstat (LexState *ls, int line) {
  /* forstat -> FOR (fornum | forlist) END */
  FuncState *fs = ls->fs;
  TString *varname;
  BlockCnt bl;
  enterblock(fs, &bl, 1);  /* scope for loop and control variables */
  luaX_next(ls);  /* skip 'for' */
  varname = str_checkname(ls);  /* first variable name */
  switch (ls->t.token) {
    case '=': fornum(ls, varname, line); break;
    case ',': case TK_IN: forlist(ls, varname); break;
    default: luaX_syntaxerror(ls, "'=' or 'in' expected");
  }
  check_match(ls, TK_END, TK_FOR, line);
  leaveblock(fs);  /* loop scope ('break' jumps to this point) */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x12000
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x8(%rbp), %rdi
callq 0x12af0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x3c(%rbp)
subl $0x2c, %eax
je 0x1271c
jmp 0x126f4
movl -0x3c(%rbp), %eax
subl $0x3d, %eax
je 0x1270a
jmp 0x126fe
movl -0x3c(%rbp), %eax
subl $0x10c, %eax            # imm = 0x10C
je 0x1271c
jmp 0x1272b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x15060
jmp 0x1273b
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15180
jmp 0x1273b
movq -0x8(%rbp), %rdi
leaq 0x227ec(%rip), %rsi     # 0x34f22
callq 0x24390
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x106, %esi            # imm = 0x106
movl $0x108, %edx            # imm = 0x108
callq 0x12600
movq -0x18(%rbp), %rdi
callq 0x12fa0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: repeatstat
static void repeatstat (LexState *ls, int line) {
  /* repeatstat -> REPEAT block UNTIL cond */
  int condexit;
  FuncState *fs = ls->fs;
  int repeat_init = luaK_getlabel(fs);
  BlockCnt bl1, bl2;
  enterblock(fs, &bl1, 1);  /* loop block */
  enterblock(fs, &bl2, 0);  /* scope block */
  luaX_next(ls);  /* skip REPEAT */
  statlist(ls);
  check_match(ls, TK_UNTIL, TK_REPEAT, line);
  condexit = cond(ls);  /* read condition (inside scope block) */
  if (bl2.upval)  /* upvalues? */
    luaK_patchclose(fs, condexit, bl2.nactvar);
  leaveblock(fs);  /* finish scope */
  luaK_patchlist(fs, condexit, repeat_init);  /* close the loop */
  leaveblock(fs);  /* finish loop */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21fa0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x12000
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x12000
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x8(%rbp), %rdi
callq 0x11d60
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x115, %esi            # imm = 0x115
movl $0x111, %edx            # imm = 0x111
callq 0x12600
movq -0x8(%rbp), %rdi
callq 0x14fd0
movl %eax, -0x10(%rbp)
cmpb $0x0, -0x3f(%rbp)
je 0x127f2
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movzbl -0x40(%rbp), %edx
callq 0x220c0
movq -0x18(%rbp), %rdi
callq 0x12fa0
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x22000
movq -0x18(%rbp), %rdi
callq 0x12fa0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: funcstat
static void funcstat (LexState *ls, int line) {
  /* funcstat -> FUNCTION funcname body */
  int ismethod;
  expdesc v, b;
  luaX_next(ls);  /* skip FUNCTION */
  ismethod = funcname(ls, &v);
  body(ls, &b, ismethod, line);
  luaK_storevar(ls->fs, &v, &b);
  luaK_fixline(ls->fs, line);  /* definition "happens" in the first line */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x15500
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq -0x40(%rbp), %rsi
callq 0x138b0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x22e80
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x23b30
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: testnext
static int testnext (LexState *ls, int c) {
  if (ls->t.token == c) {
    luaX_next(ls);
    return 1;
  }
  else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x128bd
movq -0x10(%rbp), %rdi
callq 0x24650
movl $0x1, -0x4(%rbp)
jmp 0x128c4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: localfunc
static void localfunc (LexState *ls) {
  expdesc b;
  FuncState *fs = ls->fs;
  new_localvar(ls, str_checkname(ls));  /* new local variable */
  adjustlocalvars(ls, 1);  /* enter its scope */
  body(ls, &b, 0, ls->linenumber);  /* function created in next register */
  /* debug information will only see the variable after this point! */
  getlocvar(fs, b.u.info)->startpc = fs->pc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12af0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x141d0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x13fd0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
leaq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x138b0
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x143e0
movl -0x2c(%rbp), %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: localstat
static void localstat (LexState *ls) {
  /* stat -> LOCAL NAME {',' NAME} ['=' explist] */
  int nvars = 0;
  int nexps;
  expdesc e;
  do {
    new_localvar(ls, str_checkname(ls));
    nvars++;
  } while (testnext(ls, ','));
  if (testnext(ls, '='))
    nexps = explist(ls, &e);
  else {
    e.k = VVOID;
    nexps = 0;
  }
  adjust_assign(ls, nvars, nexps, &e);
  adjustlocalvars(ls, nvars);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12af0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x141d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x12890
cmpl $0x0, %eax
jne 0x12963
movq -0x8(%rbp), %rdi
movl $0x3d, %esi
callq 0x12890
cmpl $0x0, %eax
je 0x129c1
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14930
movl %eax, -0x10(%rbp)
jmp 0x129cf
movl $0x0, -0x28(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x28(%rbp), %rcx
callq 0x15430
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x13fd0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: labelstat
static void labelstat (LexState *ls, TString *label, int line) {
  /* label -> '::' NAME '::' */
  FuncState *fs = ls->fs;
  Labellist *ll = &ls->dyd->label;
  int l;  /* index of new label being created */
  checkrepeated(fs, ll, label);  /* check for repeated labels */
  checknext(ls, TK_DBCOLON);  /* skip double colon */
  /* create new entry for this label */
  l = newlabelentry(ls, ll, label, line, luaK_getlabel(fs));
  skipnoopstat(ls);  /* skip other no-op statements */
  if (block_follow(ls, 0)) {  /* label is last no-op statement in the block? */
    /* assume that locals are already out of scope */
    ll->arr[l].nactvar = fs->bl->nactvar;
  }
  findgotos(ls, &ll->arr[l]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x15570
movq -0x8(%rbp), %rdi
movl $0x120, %esi            # imm = 0x120
callq 0x12f20
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x21fa0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl -0x30(%rbp), %ecx
movl %eax, %r8d
callq 0x14be0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12f50
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x12160
cmpl $0x0, %eax
je 0x12ac8
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movb 0x10(%rax), %cl
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movslq -0x2c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0x14cd0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: str_checkname
static TString *str_checkname (LexState *ls) {
  TString *ts;
  check(ls, TK_NAME);
  ts = ls->t.seminfo.ts;
  luaX_next(ls);
  return ts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x124, %esi            # imm = 0x124
callq 0x11dc0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: retstat
static void retstat (LexState *ls) {
  /* stat -> RETURN [explist] [';'] */
  FuncState *fs = ls->fs;
  expdesc e;
  int first, nret;  /* registers with returned values */
  if (block_follow(ls, 1) || ls->t.token == ';')
    first = nret = 0;  /* return no values */
  else {
    nret = explist(ls, &e);  /* optional return values */
    if (hasmultret(e.k)) {
      luaK_setmultret(fs, &e);
      if (e.k == VCALL && nret == 1) {  /* tail call? */
        SET_OPCODE(getinstruction(fs,&e), OP_TAILCALL);
        lua_assert(GETARG_A(getinstruction(fs,&e)) == fs->nactvar);
      }
      first = fs->nactvar;
      nret = LUA_MULTRET;  /* return all values */
    }
    else {
      if (nret == 1)  /* only one single value? */
        first = luaK_exp2anyreg(fs, &e);
      else {
        luaK_exp2nextreg(fs, &e);  /* values must go to the stack */
        first = fs->nactvar;  /* return all active values */
        lua_assert(nret == fs->freereg - first);
      }
    }
  }
  luaK_ret(fs, first, nret);
  testnext(ls, ';');  /* skip optional semicolon */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x12160
cmpl $0x0, %eax
jne 0x12b65
movq -0x8(%rbp), %rax
cmpl $0x3b, 0x10(%rax)
jne 0x12b78
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
jmp 0x12c24
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14930
movl %eax, -0x30(%rbp)
cmpl $0xd, -0x28(%rbp)
je 0x12b94
cmpl $0xe, -0x28(%rbp)
jne 0x12bf0
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x22670
cmpl $0xd, -0x28(%rbp)
jne 0x12bdc
cmpl $0x1, -0x30(%rbp)
jne 0x12bdc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
andl $-0x40, %edx
orl $0x25, %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movzbl 0x3a(%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
jmp 0x12c22
cmpl $0x1, -0x30(%rbp)
jne 0x12c08
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x22b40
movl %eax, -0x2c(%rbp)
jmp 0x12c20
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x22950
movq -0x10(%rbp), %rax
movzbl 0x3a(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x12c22
jmp 0x12c24
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x21f60
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
callq 0x12890
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: gotostat
static void gotostat (LexState *ls, int pc) {
  int line = ls->linenumber;
  TString *label;
  int g;
  if (testnext(ls, TK_GOTO))
    label = str_checkname(ls);
  else {
    luaX_next(ls);  /* skip break */
    label = luaS_new(ls->L, "break");
  }
  g = newlabelentry(ls, &ls->dyd->gt, label, line, pc);
  findlabel(ls, g);  /* close it if label already defined */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x10a, %esi            # imm = 0x10A
callq 0x12890
cmpl $0x0, %eax
je 0x12c8b
movq -0x8(%rbp), %rdi
callq 0x12af0
movq %rax, -0x18(%rbp)
jmp 0x12cac
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x221b5(%rip), %rsi     # 0x34e58
callq 0x16c30
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rdx
movl -0x10(%rbp), %ecx
movl -0xc(%rbp), %r8d
callq 0x14be0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x14ec0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: exprstat
static void exprstat (LexState *ls) {
  /* stat -> func | assignment */
  FuncState *fs = ls->fs;
  struct LHS_assign v;
  suffixedexp(ls, &v.v);
  if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */
    v.prev = NULL;
    assignment(ls, &v, 1);
  }
  else {  /* stat -> func */
    check_condition(ls, v.v.k == VCALL, "syntax error");
    SETARG_C(getinstruction(fs, &v.v), 1);  /* call statement uses no results */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
addq $0x8, %rsi
callq 0x13990
movq -0x8(%rbp), %rax
cmpl $0x3d, 0x10(%rax)
je 0x12d2d
movq -0x8(%rbp), %rax
cmpl $0x2c, 0x10(%rax)
jne 0x12d49
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x15620
jmp 0x12d8f
cmpl $0xd, -0x28(%rbp)
je 0x12d5f
movq -0x8(%rbp), %rdi
leaq 0x22250(%rip), %rsi     # 0x34faa
callq 0x24390
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
andl $0xff803fff, %edx       # imm = 0xFF803FFF
orl $0x4000, %edx           # imm = 0x4000
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: test_then_block
static void test_then_block (LexState *ls, int *escapelist) {
  /* test_then_block -> [IF | ELSEIF] cond THEN block */
  BlockCnt bl;
  FuncState *fs = ls->fs;
  expdesc v;
  int jf;  /* instruction to skip 'then' code (if condition is false) */
  luaX_next(ls);  /* skip IF or ELSEIF */
  expr(ls, &v);  /* read condition */
  checknext(ls, TK_THEN);
  if (ls->t.token == TK_GOTO || ls->t.token == TK_BREAK) {
    luaK_goiffalse(ls->fs, &v);  /* will jump to label if condition is true */
    enterblock(fs, &bl, 0);  /* must enter block before 'goto' */
    gotostat(ls, v.t);  /* handle goto/break */
    skipnoopstat(ls);  /* skip other no-op statements */
    if (block_follow(ls, 0)) {  /* 'goto' is the entire block? */
      leaveblock(fs);
      return;  /* and that is it */
    }
    else  /* must skip over 'then' part if condition is false */
      jf = luaK_jump(fs);
  }
  else {  /* regular case (not goto/break) */
    luaK_goiftrue(ls->fs, &v);  /* skip over block if condition is false */
    enterblock(fs, &bl, 0);
    jf = v.f;
  }
  statlist(ls);  /* 'then' part */
  leaveblock(fs);
  if (ls->t.token == TK_ELSE ||
      ls->t.token == TK_ELSEIF)  /* followed by 'else'/'elseif'? */
    luaK_concat(fs, escapelist, luaK_jump(fs));  /* must jump over it */
  luaK_patchtohere(fs, jf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x12ef0
movq -0x8(%rbp), %rdi
movl $0x113, %esi            # imm = 0x113
callq 0x12f20
movq -0x8(%rbp), %rax
cmpl $0x10a, 0x10(%rax)      # imm = 0x10A
je 0x12dfa
movq -0x8(%rbp), %rax
cmpl $0x102, 0x10(%rax)      # imm = 0x102
jne 0x12e5b
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x48(%rbp), %rsi
callq 0x23210
movq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x12000
movq -0x8(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x12c50
movq -0x8(%rbp), %rdi
callq 0x12f50
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x12160
cmpl $0x0, %eax
je 0x12e4d
movq -0x30(%rbp), %rdi
callq 0x12fa0
jmp 0x12ee1
movq -0x30(%rbp), %rdi
callq 0x21ec0
movl %eax, -0x4c(%rbp)
jmp 0x12e81
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x48(%rbp), %rsi
callq 0x23020
movq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x12000
movl -0x34(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d60
movq -0x30(%rbp), %rdi
callq 0x12fa0
movq -0x8(%rbp), %rax
cmpl $0x104, 0x10(%rax)      # imm = 0x104
je 0x12ead
movq -0x8(%rbp), %rax
cmpl $0x105, 0x10(%rax)      # imm = 0x105
jne 0x12ed5
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
callq 0x21ec0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl %eax, %edx
callq 0x21d70
movq -0x30(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x21fc0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)