LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lmem.c
// Function: luaM_growaux_
void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
                     int limit, const char *what) {
  void *newblock;
  int newsize;
  if (*size >= limit/2) {  /* cannot double it? */
    if (*size >= limit)  /* cannot grow even a little? */
      luaG_runerror(L, "too many %s (limit is %d)", what, limit);
    newsize = limit;  /* still have at least one free place */
  }
  else {
    newsize = (*size)*2;
    if (newsize < MINSIZEARRAY)
      newsize = MINSIZEARRAY;  /* minimum size */
  }
  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
  *size = newsize;  /* update only when everything else is OK */
  return newblock;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movslq (%rdx), %rdx
movl %r8d, %eax
shrl $0x1f, %eax
addl %r8d, %eax
sarl %eax
cmpl %eax, %edx
jge 0xb3b7
leal (%rdx,%rdx), %eax
cmpl $0x5, %eax
movl $0x4, %r8d
cmovgel %eax, %r8d
jmp 0xb3bc
cmpl %r8d, %edx
jge 0xb3d7
imulq %rcx, %rdx
movslq %r8d, %r14
imulq %r14, %rcx
callq 0xb3eb
movl %r14d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1618b(%rip), %rsi     # 0x21569
movq %r9, %rdx
movl %r8d, %ecx
xorl %eax, %eax
callq 0x7cd8
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lmem.c
// Function: luaM_realloc_
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
  void *newblock;
  global_State *g = G(L);
  size_t realosize = (block) ? osize : 0;
  lua_assert((realosize == 0) == (block == NULL));
#if defined(HARDMEMTESTS)
  if (nsize > realosize && g->gcrunning)
    luaC_fullgc(L, 1);  /* force a GC whenever possible */
#endif
  newblock = (*g->frealloc)(g->ud, block, osize, nsize);
  if (newblock == NULL && nsize > 0) {
    lua_assert(nsize > realosize);  /* cannot fail when shrinking a block */
    if (g->version) {  /* is state fully built? */
      luaC_fullgc(L, 1);  /* try to free some memory... */
      newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
    }
    if (newblock == NULL)
      luaD_throw(L, LUA_ERRMEM);
  }
  lua_assert((nsize == 0) == (newblock == NULL));
  g->GCdebt = (g->GCdebt + nsize) - realosize;
  return newblock;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rdi), %r13
movq 0x8(%r13), %rdi
callq *(%r13)
testq %rbx, %rbx
je 0xb447
testq %rax, %rax
jne 0xb447
cmpq $0x0, 0xd0(%r13)
je 0xb440
movq %r12, %rdi
movl $0x1, %esi
callq 0xa7e2
movq 0x8(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq *(%r13)
jmp 0xb442
xorl %eax, %eax
testq %rax, %rax
je 0xb45f
testq %r15, %r15
cmoveq %r15, %r14
subq %r14, %rbx
addq %rbx, 0x18(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
movl $0x4, %esi
callq 0x848c
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_int2fb
int luaO_int2fb (unsigned int x) {
  int e = 0;  /* exponent */
  if (x < 8) return x;
  while (x >= (8 << 4)) {  /* coarse steps */
    x = (x + 0xf) >> 4;  /* x = ceil(x / 16) */
    e += 4;
  }
  while (x >= (8 << 1)) {  /* fine steps */
    x = (x + 1) >> 1;  /* x = ceil(x / 2) */
    e++;
  }
  return ((e+1) << 3) | (cast_int(x) - 8);
}

// Assembly:
movl %edi, %eax
cmpl $0x8, %edi
jb 0xb4c9
xorl %ecx, %ecx
cmpl $0x80, %eax
jb 0xb4a4
xorl %ecx, %ecx
addl $0xf, %eax
movl %eax, %edx
shrl $0x4, %edx
addl $0x4, %ecx
cmpl $0x7ff, %eax            # imm = 0x7FF
movl %edx, %eax
ja 0xb48e
jmp 0xb4a6
movl %eax, %edx
cmpl $0x10, %edx
jb 0xb4bb
leal 0x1(%rdx), %eax
shrl %eax
incl %ecx
cmpl $0x1e, %edx
movl %eax, %edx
ja 0xb4ab
jmp 0xb4bd
movl %edx, %eax
leal 0x8(,%rcx,8), %ecx
addl $-0x8, %eax
orl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_ceillog2
int luaO_ceillog2 (unsigned int x) {
  static const lu_byte log_2[256] = {  /* log_2[i] = ceil(log2(i - 1)) */
    0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
  };
  int l = 0;
  x--;
  while (x >= 256) { l += 8; x >>= 8; }
  return l + log_2[x];
}

// Assembly:
decl %edi
xorl %ecx, %ecx
cmpl $0x100, %edi            # imm = 0x100
jb 0xb507
xorl %ecx, %ecx
movl %edi, %eax
addl $0x8, %ecx
shrl $0x8, %eax
cmpl $0xffff, %edi           # imm = 0xFFFF
movl %eax, %edi
ja 0xb4f5
jmp 0xb509
movl %edi, %eax
movl %eax, %eax
leaq 0x1611e(%rip), %rdx     # 0x21630
movzbl (%rax,%rdx), %eax
addl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: intarith
static lua_Integer intarith (lua_State *L, int op, lua_Integer v1,
                                                   lua_Integer v2) {
  switch (op) {
    case LUA_OPADD: return intop(+, v1, v2);
    case LUA_OPSUB:return intop(-, v1, v2);
    case LUA_OPMUL:return intop(*, v1, v2);
    case LUA_OPMOD: return luaV_mod(L, v1, v2);
    case LUA_OPIDIV: return luaV_div(L, v1, v2);
    case LUA_OPBAND: return intop(&, v1, v2);
    case LUA_OPBOR: return intop(|, v1, v2);
    case LUA_OPBXOR: return intop(^, v1, v2);
    case LUA_OPSHL: return luaV_shiftl(v1, v2);
    case LUA_OPSHR: return luaV_shiftl(v1, -v2);
    case LUA_OPUNM: return intop(-, 0, v1);
    case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1);
    default: lua_assert(0); return 0;
  }
}

// Assembly:
xorl %eax, %eax
cmpl $0xd, %esi
ja 0xb72c
movl %esi, %esi
leaq 0x15ead(%rip), %r8      # 0x215b0
movslq (%r8,%rsi,4), %rsi
addq %r8, %rsi
jmpq *%rsi
addq %rdx, %rcx
jmp 0xb735
negq %rdx
jmp 0xb729
imulq %rdx, %rcx
jmp 0xb735
andq %rdx, %rcx
jmp 0xb735
notq %rdx
jmp 0xb729
subq %rcx, %rdx
movq %rdx, %rax
retq
orq %rdx, %rcx
jmp 0xb735
xorq %rdx, %rcx
movq %rcx, %rax
retq
movq %rdx, %rsi
movq %rcx, %rdx
jmp 0x11b64
movq %rdx, %rsi
movq %rcx, %rdx
jmp 0x11b25
negq %rcx
movq %rdx, %rdi
movq %rcx, %rsi
jmp 0x11ba6
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: numarith
static lua_Number numarith (lua_State *L, int op, lua_Number v1,
                                                  lua_Number v2) {
  switch (op) {
    case LUA_OPADD: return luai_numadd(L, v1, v2);
    case LUA_OPSUB: return luai_numsub(L, v1, v2);
    case LUA_OPMUL: return luai_nummul(L, v1, v2);
    case LUA_OPDIV: return luai_numdiv(L, v1, v2);
    case LUA_OPPOW: return luai_numpow(L, v1, v2);
    case LUA_OPIDIV: return luai_numidiv(L, v1, v2);
    case LUA_OPUNM: return luai_numunm(L, v1);
    case LUA_OPMOD: {
      lua_Number m;
      luai_nummod(L, v1, v2, m);
      return m;
    }
    default: lua_assert(0); return 0;
  }
}

// Assembly:
movapd %xmm0, %xmm2
xorpd %xmm0, %xmm0
cmpl $0xc, %edi
ja 0xb7e9
movl %edi, %eax
leaq 0x15e75(%rip), %rcx     # 0x215e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addsd %xmm1, %xmm2
jmp 0xb7a9
divsd %xmm1, %xmm2
jmp 0xb7a9
subsd %xmm1, %xmm2
jmp 0xb7a9
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
jmp 0x5470
xorpd 0x15f8d(%rip), %xmm2    # 0x21730
jmp 0xb7a9
mulsd %xmm1, %xmm2
movapd %xmm2, %xmm0
retq
subq $0x18, %rsp
movapd %xmm2, %xmm0
movaps %xmm1, (%rsp)
callq 0x51f0
movapd %xmm0, %xmm1
movapd (%rsp), %xmm3
mulsd %xmm3, %xmm0
addsd %xmm1, %xmm3
xorpd %xmm2, %xmm2
cmpltsd %xmm2, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm1, %xmm0
orpd %xmm3, %xmm0
addq $0x18, %rsp
retq
movapd %xmm2, %xmm0
jmp 0x5120
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x80, %rsi
jae 0xba68
movl $0x1, %eax
movl $0x7, %ecx
jmp 0xbab8
movl $0x3f, %edx
movabsq $0x700000000, %rcx      # imm = 0x700000000
xorl %r8d, %r8d
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %rax, %rcx
movl %esi, %r9d
andb $0x3f, %r9b
orb $-0x80, %r9b
movb %r9b, 0x7(%rdi,%r8)
shrq $0x6, %rsi
shrl %edx
decq %r8
cmpq %rdx, %rsi
ja 0xba84
movl $0x1, %eax
subl %r8d, %eax
notl %edx
addl %edx, %edx
orq %rdx, %rsi
sarq $0x20, %rcx
movb %sil, (%rdi,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x13, 0x8(%rsi)
jne 0xbaf2
movq (%rbx), %rcx
leaq 0x15c62(%rip), %rdx     # 0x21740
movq %rsp, %rdi
movl $0x32, %esi
xorl %eax, %eax
callq 0x5190
movslq %eax, %r15
jmp 0xbb3f
movsd (%rbx), %xmm0
leaq 0x15c48(%rip), %rdx     # 0x21745
movq %rsp, %r12
movl $0x32, %esi
movq %r12, %rdi
movb $0x1, %al
callq 0x5190
movslq %eax, %r15
leaq 0x15c32(%rip), %rsi     # 0x2174b
movq %r12, %rdi
callq 0x5200
cmpb $0x0, (%rsp,%rax)
jne 0xbb3f
callq 0x5100
movq (%rax), %rax
movb (%rax), %al
movb %al, (%rsp,%r15)
movb $0x30, 0x1(%rsp,%r15)
addq $0x2, %r15
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xf2f1
movq %rax, (%rbx)
movzbl 0x8(%rax), %eax
orl $0x40, %eax
movl %eax, 0x8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lobject.c
// Function: luaO_chunkid
void luaO_chunkid (char *out, const char *source, size_t bufflen) {
  size_t l = strlen(source);
  if (*source == '=') {  /* 'literal' source */
    if (l <= bufflen)  /* small enough? */
      memcpy(out, source + 1, l * sizeof(char));
    else {  /* truncate it */
      addstr(out, source + 1, bufflen - 1);
      *out = '\0';
    }
  }
  else if (*source == '@') {  /* file name */
    if (l <= bufflen)  /* small enough? */
      memcpy(out, source + 1, l * sizeof(char));
    else {  /* add '...' before rest of name */
      addstr(out, RETS, LL(RETS));
      bufflen -= LL(RETS);
      memcpy(out, source + 1 + l - bufflen, bufflen * sizeof(char));
    }
  }
  else {  /* string; format as [string "source"] */
    const char *nl = strchr(source, '\n');  /* find first new line (if any) */
    addstr(out, PRE, LL(PRE));  /* add prefix */
    bufflen -= LL(PRE RETS POS) + 1;  /* save space for prefix+suffix+'\0' */
    if (l < bufflen && nl == NULL) {  /* small one-line source? */
      addstr(out, source, l);  /* keep it */
    }
    else {
      if (nl != NULL) l = nl - source;  /* stop at first newline */
      if (l > bufflen) l = bufflen;
      addstr(out, source, l);
      addstr(out, RETS, LL(RETS));
    }
    memcpy(out, POS, (LL(POS) + 1) * sizeof(char));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5150
movq %rax, %r12
movzbl (%r14), %eax
cmpl $0x40, %eax
je 0xbfd9
cmpl $0x3d, %eax
jne 0xc004
incq %r14
cmpq %r15, %r12
jbe 0xc053
leaq -0x1(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5320
movb $0x0, -0x1(%rbx,%r15)
jmp 0xc0af
cmpq %r15, %r12
jbe 0xc050
movb $0x2e, 0x2(%rbx)
movw $0x2e2e, (%rbx)         # imm = 0x2E2E
addq $0x3, %rbx
addq %r12, %r14
subq %r15, %r14
addq $-0x3, %r15
addq $0x4, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
jmp 0xc05c
movq %r14, %rdi
movl $0xa, %esi
callq 0x5170
movabsq $0x20676e697274735b, %rcx # imm = 0x20676E697274735B
movq %rcx, (%rbx)
movb $0x22, 0x8(%rbx)
addq $0x9, %rbx
addq $-0xf, %r15
cmpq %r15, %r12
setb %cl
testq %rax, %rax
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xc06a
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5320
addq %rbx, %r12
jmp 0xc0a2
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5320
movq %rax, %r13
subq %r14, %r13
testq %rax, %rax
cmoveq %r12, %r13
cmpq %r15, %r13
cmovaeq %r15, %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x5320
leaq (%rbx,%r13), %r12
addq $0x3, %r12
movw $0x2e2e, -0x3(%r12)     # imm = 0x2E2E
movb $0x2e, -0x1(%r12)
movb $0x0, 0x2(%r12)
movw $0x5d22, (%r12)         # imm = 0x5D22
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x50f0
movsd %xmm0, (%rbx)
cmpq %r14, (%r15)
je 0xc10a
movq 0x8(%rsp), %rcx
decq %rcx
leaq 0x16513(%rip), %rax     # 0x22600
movzbl 0x1(%rcx), %edx
incq %rcx
testb $0x8, 0x1(%rdx,%rax)
jne 0xc0ed
movq %rcx, 0x8(%rsp)
xorl %eax, %eax
testb %dl, %dl
cmoveq %rcx, %rax
jmp 0xc10c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl 0x3b(%rdi), %eax
cmpl $0xff, %eax
je 0xc3ae
movq %rdx, %r12
movq %rsi, %r14
movq (%rbx), %r15
leaq 0x10(%r15), %r13
movslq 0x10(%r15), %rbp
cmpl %eax, %ebp
jg 0xc32e
movq 0x10(%rbx), %rax
movq 0x38(%rax), %rdi
movq 0x58(%r15), %rsi
leaq 0x15ff9(%rip), %r9      # 0x22310
movl $0x10, %ecx
movq %r13, %rdx
movl $0xff, %r8d
callq 0xb38c
movq %rax, 0x58(%r15)
movslq (%r13), %rax
cmpl %eax, %ebp
jge 0xc352
subq %rbp, %rax
shlq $0x4, %rbp
addq 0x58(%r15), %rbp
movq $0x0, (%rbp)
addq $0x10, %rbp
decq %rax
jne 0xc341
movzbl 0x3b(%rbx), %eax
shll $0x4, %eax
cmpl $0x8, (%r12)
movq 0x58(%r15), %rcx
sete 0x8(%rcx,%rax)
movb 0x8(%r12), %dl
movb %dl, 0x9(%rcx,%rax)
movq %r14, (%rcx,%rax)
testb $0x4, 0x9(%r15)
je 0xc395
testb $0x3, 0x9(%r14)
je 0xc395
movq 0x10(%rbx), %rax
movq 0x38(%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x9ddc
movzbl 0x3b(%rbx), %eax
leal 0x1(%rax), %ecx
movb %cl, 0x3b(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15f5b(%rip), %rdx     # 0x22310
movq %rbx, %rdi
movl $0xff, %esi
callq 0xc567
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xfffffefc, %ebp       # imm = 0xFFFFFEFC
movl $0x20020007, %r14d      # imm = 0x20020007
movl 0x10(%rbx), %eax
addl %ebp, %eax
cmpl $0x1d, %eax
ja 0xc3e9
btl %eax, %r14d
jb 0xc3f3
cmpl $0xe, %eax
je 0xc3f8
movq %rbx, %rdi
callq 0xc5c7
jmp 0xc3d4
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc5c7
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: close_func
static void close_func (LexState *ls) {
  lua_State *L = ls->L;
  FuncState *fs = ls->fs;
  Proto *f = fs->f;
  luaK_ret(fs, 0, 0);  /* final return */
  leaveblock(fs);
  luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
  f->sizecode = fs->pc;
  luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
  f->sizelineinfo = fs->pc;
  luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
  f->sizek = fs->nk;
  luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
  f->sizep = fs->np;
  luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
  f->sizelocvars = fs->nlocvars;
  luaM_reallocvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc);
  f->sizeupvalues = fs->nups;
  lua_assert(fs->bl == NULL);
  ls->fs = fs->prev;
  luaC_checkGC(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x30(%rdi), %r15
movq 0x38(%rdi), %rbx
movq (%r15), %r12
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x157cb
movq %r15, %rdi
callq 0xd204
movq 0x38(%r12), %rsi
movslq 0x18(%r12), %rdx
shlq $0x2, %rdx
movslq 0x20(%r15), %rcx
shlq $0x2, %rcx
movq %rbx, %rdi
callq 0xb3eb
movq %rax, 0x38(%r12)
movslq 0x20(%r15), %rcx
movl %ecx, 0x18(%r12)
movq 0x48(%r12), %rsi
movslq 0x1c(%r12), %rdx
shlq $0x2, %rdx
shlq $0x2, %rcx
movq %rbx, %rdi
callq 0xb3eb
movq %rax, 0x48(%r12)
movl 0x20(%r15), %eax
movl %eax, 0x1c(%r12)
movq 0x30(%r12), %rsi
movslq 0x14(%r12), %rdx
shlq $0x4, %rdx
movslq 0x2c(%r15), %rcx
shlq $0x4, %rcx
movq %rbx, %rdi
callq 0xb3eb
movq %rax, 0x30(%r12)
movl 0x2c(%r15), %eax
movl %eax, 0x14(%r12)
movq 0x40(%r12), %rsi
movslq 0x20(%r12), %rdx
shlq $0x3, %rdx
movslq 0x30(%r15), %rcx
shlq $0x3, %rcx
movq %rbx, %rdi
callq 0xb3eb
movq %rax, 0x40(%r12)
movl 0x30(%r15), %eax
movl %eax, 0x20(%r12)
movq 0x50(%r12), %rsi
movslq 0x24(%r12), %rdx
shlq $0x4, %rdx
movswq 0x38(%r15), %rcx
shlq $0x4, %rcx
movq %rbx, %rdi
callq 0xb3eb
movq %rax, 0x50(%r12)
movswl 0x38(%r15), %eax
movl %eax, 0x24(%r12)
movq 0x58(%r12), %rsi
movslq 0x10(%r12), %rdx
shlq $0x4, %rdx
movzbl 0x3b(%r15), %ecx
shll $0x4, %ecx
movq %rbx, %rdi
callq 0xb3eb
movq %rax, 0x58(%r12)
movzbl 0x3b(%r15), %eax
movl %eax, 0x10(%r12)
movq 0x8(%r15), %rax
movq %rax, 0x30(%r14)
movq 0x18(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jle 0xc55b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa65d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x38(%rcx), %r15
movl 0x28(%rax), %edx
testl %edx, %edx
jne 0xc591
leaq 0x1544b(%rip), %r8      # 0x219da
jmp 0xc5a5
leaq 0x15450(%rip), %rsi     # 0x219e8
movq %r15, %rdi
xorl %eax, %eax
callq 0xbf04
movq %rax, %r8
leaq 0x15450(%rip), %rsi     # 0x219fc
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0xbf04
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x16d86
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x20, %rsp
movq 0x30(%rdi), %rbx
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
movb %al, 0x12(%rcx)
movb 0x3a(%rbx), %dl
movb %dl, 0x10(%rcx)
movq 0x10(%rbx), %rdx
movq 0x58(%rdx), %rdx
movl 0x28(%rdx), %esi
movl %esi, 0x8(%rcx)
movl 0x18(%rdx), %edx
movl %edx, 0xc(%rcx)
movb %al, 0x11(%rcx)
movq 0x18(%rbx), %rax
movq %rax, (%rcx)
movq %rcx, 0x18(%rbx)
callq 0xc3c2
movq %rbx, %rdi
callq 0xd204
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl %esi, 0x10(%rdi)
jne 0xcfa7
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x16f0a
movl %ecx, %ebp
cmpl %ecx, 0x4(%rbx)
jne 0xcfb6
movq %rbx, %rdi
callq 0xe6ef
movl %edx, %r14d
movq 0x38(%rbx), %r15
movq %rbx, %rdi
callq 0x16d3b
movq %rax, %r12
movq %rbx, %rdi
movl %r14d, %esi
callq 0x16d3b
leaq 0x14b6b(%rip), %rsi     # 0x21b45
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0xbf04
movq %rbx, %rdi
movq %rax, %rsi
callq 0x16d86
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
cmpl $0x124, 0x10(%rdi)      # imm = 0x124
jne 0xd010
movq 0x18(%rdi), %rbx
callq 0x16f0a
movq %rbx, %rax
popq %rbx
retq
movl $0x124, %esi            # imm = 0x124
callq 0xe6ef
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x4(%rdi), %r14d
movl 0x10(%rdi), %r15d
callq 0x16f0a
cmpl $0x10a, %r15d           # imm = 0x10A
jne 0xd046
movq %rbx, %rdi
callq 0xcff8
jmp 0xd056
movq 0x38(%rbx), %rdi
leaq 0x14a5b(%rip), %rsi     # 0x21aac
callq 0xf52a
movq 0x58(%rbx), %rsi
addq $0x10, %rsi
movq %rbx, %rdi
movq %rax, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
callq 0xe474
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe61d
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: leaveblock
static void leaveblock (FuncState *fs) {
  BlockCnt *bl = fs->bl;
  LexState *ls = fs->ls;
  if (bl->previous && bl->upval) {
    /* create a 'jump to here' to close upvalues */
    int j = luaK_jump(fs);
    luaK_patchclose(fs, j, bl->nactvar);
    luaK_patchtohere(fs, j);
  }
  if (bl->isloop)
    breaklabel(ls);  /* close pending breaks */
  fs->bl = bl->previous;
  removevars(fs, bl->nactvar);
  lua_assert(bl->nactvar == fs->nactvar);
  fs->freereg = fs->nactvar;  /* free registers */
  ls->dyd->label.n = bl->firstlabel;  /* remove local labels */
  if (bl->previous)  /* inner block? */
    movegotosout(fs, bl);  /* update pending gotos to outer block */
  else if (bl->firstgoto < ls->dyd->gt.n)  /* pending gotos in outer block? */
    undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]);  /* error */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq $0x0, (%r15)
je 0xd247
cmpb $0x0, 0x11(%r15)
je 0xd247
movq %rbx, %rdi
callq 0x1577c
movl %eax, %ebp
movzbl 0x10(%r15), %edx
movq %rbx, %rdi
movl %eax, %esi
callq 0x15897
movq %rbx, %rdi
movl %ebp, %esi
callq 0x157e8
cmpb $0x0, 0x12(%r15)
je 0xd295
movq 0x38(%r14), %rdi
leaq 0x14853(%rip), %rsi     # 0x21aac
callq 0xf52a
movq 0x30(%r14), %rcx
movq 0x58(%r14), %rsi
addq $0x20, %rsi
movl 0x20(%rcx), %r8d
movq %r14, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xe474
movq 0x58(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq 0x20(%rcx), %rsi
movq %r14, %rdi
callq 0xe4f8
movq (%r15), %rax
movq %rax, 0x18(%rbx)
movzbl 0x10(%r15), %ecx
movzbl 0x3a(%rbx), %edx
movl %ecx, %esi
subl %edx, %esi
movq 0x10(%rbx), %rdi
movq 0x58(%rdi), %r12
addl %esi, 0x8(%r12)
cmpb %cl, %dl
jbe 0xd2ed
movl 0x20(%rbx), %esi
movq (%r12), %r8
movslq 0x34(%rbx), %r9
movq (%rbx), %rdi
movq 0x50(%rdi), %rdi
leaq (%r8,%r9,2), %r8
addq $-0x2, %r8
movswq (%r8,%rdx,2), %r9
decq %rdx
shlq $0x4, %r9
movl %esi, 0xc(%rdi,%r9)
cmpq %rcx, %rdx
ja 0xd2d4
movb %dl, 0x3a(%rbx)
movb 0x3a(%rbx), %cl
movb %cl, 0x3c(%rbx)
movl 0x8(%r15), %edx
movq 0x58(%r14), %rcx
movl %edx, 0x28(%rcx)
movl 0xc(%r15), %ebp
testq %rax, %rax
je 0xd357
cmpl 0x18(%r12), %ebp
jge 0xd35c
movq 0x10(%r12), %rax
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rcx
movzbl 0x10(%r15), %edx
cmpb %dl, 0x10(%rax,%rcx,8)
jbe 0xd344
leaq (%rax,%rcx,8), %r14
cmpb $0x0, 0x11(%r15)
je 0xd33c
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x15897
movb 0x10(%r15), %al
movb %al, 0x10(%r14)
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq 0xe61d
cmpl $0x1, %eax
adcl $0x0, %ebp
jmp 0xd307
cmpl 0x18(%rcx), %ebp
jl 0xd365
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movslq %ebp, %rax
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq 0x10(%rcx), %rsi
movq %r14, %rdi
callq 0xe428
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: suffixedexp
static void suffixedexp (LexState *ls, expdesc *v) {
  /* suffixedexp ->
       primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */
  FuncState *fs = ls->fs;
  int line = ls->linenumber;
  primaryexp(ls, v);
  for (;;) {
    switch (ls->t.token) {
      case '.': {  /* fieldsel */
        fieldsel(ls, v);
        break;
      }
      case '[': {  /* '[' exp1 ']' */
        expdesc key;
        luaK_exp2anyregup(fs, v);
        yindex(ls, &key);
        luaK_indexed(fs, v, &key);
        break;
      }
      case ':': {  /* ':' NAME funcargs */
        expdesc key;
        luaX_next(ls);
        checkname(ls, &key);
        luaK_self(fs, v, &key);
        funcargs(ls, v, line);
        break;
      }
      case '(': case TK_STRING: case '{': {  /* funcargs */
        luaK_exp2nextreg(fs, v);
        funcargs(ls, v, line);
        break;
      }
      default: return;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %r15
movl 0x4(%rdi), %ebp
movl 0x10(%rdi), %eax
cmpl $0x124, %eax            # imm = 0x124
je 0xdd14
cmpl $0x28, %eax
jne 0xddf8
movq %rbx, %rdi
callq 0x16f0a
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd37c
movq %rbx, %rdi
movl $0x29, %esi
movl $0x28, %edx
movl %ebp, %ecx
callq 0xcf87
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x15c92
jmp 0xdd1f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe264
leaq 0x8(%rsp), %r12
movl 0x10(%rbx), %eax
cmpl $0x5a, %eax
jg 0xdd84
cmpl $0x28, %eax
je 0xdd95
cmpl $0x2e, %eax
je 0xdddb
cmpl $0x3a, %eax
jne 0xddeb
movq %rbx, %rdi
callq 0x16f0a
movq %rbx, %rdi
callq 0xcff8
movq 0x30(%rbx), %rdi
movq %rax, %rsi
callq 0x15a2c
movq $-0x1, 0x18(%rsp)
movl $0x4, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x160dc
jmp 0xdda0
cmpl $0x5b, %eax
je 0xddb2
cmpl $0x7b, %eax
je 0xdd95
cmpl $0x125, %eax            # imm = 0x125
jne 0xddeb
movq %r15, %rdi
movq %r14, %rsi
callq 0x15d1e
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xe12d
jmp 0xdd24
movq %r15, %rdi
movq %r14, %rsi
callq 0x15eec
movq %rbx, %rdi
movq %r12, %rsi
callq 0xded1
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x16368
jmp 0xdd24
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe0cb
jmp 0xdd24
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13c7f(%rip), %rsi     # 0x21a7e
movq %rbx, %rdi
callq 0x16d86
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: recfield
static void recfield (LexState *ls, struct ConsControl *cc) {
  /* recfield -> (NAME | '['exp1']') = exp1 */
  FuncState *fs = ls->fs;
  int reg = ls->fs->freereg;
  expdesc key, val;
  int rkkey;
  if (ls->t.token == TK_NAME) {
    checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
    checkname(ls, &key);
  }
  else  /* ls->t.token == '[' */
    yindex(ls, &key);
  cc->nh++;
  checknext(ls, '=');
  rkkey = luaK_exp2RK(fs, &key);
  expr(ls, &val);
  luaK_codeABC(fs, OP_SETTABLE, cc->t->u.info, rkkey, luaK_exp2RK(fs, &val));
  fs->freereg = reg;  /* free registers */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rbx
movb 0x3c(%rbx), %r13b
cmpl $0x124, 0x10(%rdi)      # imm = 0x124
jne 0xde57
movq %r15, %rdi
callq 0xcff8
movq 0x30(%r15), %rdi
movq %rax, %rsi
callq 0x15a2c
movq $-0x1, 0x18(%rsp)
movl $0x4, 0x8(%rsp)
movl %eax, 0x10(%rsp)
jmp 0xde64
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xded1
incl 0x20(%r14)
movq %r15, %rdi
movl $0x3d, %esi
callq 0xd1f5
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x15f13
movl %eax, %ebp
leaq 0x20(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xd37c
movq 0x18(%r14), %rax
movl 0x8(%rax), %r14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x15f13
movq %rbx, %rdi
movl $0xa, %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %eax, %r8d
callq 0x156de
movb %r13b, 0x3c(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: yindex
static void yindex (LexState *ls, expdesc *v) {
  /* index -> '[' expr ']' */
  luaX_next(ls);  /* skip the '[' */
  expr(ls, v);
  luaK_exp2val(ls->fs, v);
  checknext(ls, ']');
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x16f0a
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd37c
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x15f02
movq %r14, %rdi
movl $0x5d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd1f5
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: adjustlocalvars
static void adjustlocalvars (LexState *ls, int nvars) {
  FuncState *fs = ls->fs;
  fs->nactvar = cast_byte(fs->nactvar + nvars);
  for (; nvars; nvars--) {
    getlocvar(fs, fs->nactvar - nvars)->startpc = fs->pc;
  }
}

// Assembly:
movq 0x30(%rdi), %r8
movb 0x3a(%r8), %cl
addb %sil, %cl
movb %cl, 0x3a(%r8)
testl %esi, %esi
je 0xdf66
movl 0x20(%r8), %eax
movzbl %cl, %ecx
movq (%r8), %rdi
movq 0x10(%r8), %rdx
movq 0x58(%rdx), %rdx
movq (%rdx), %rdx
movq 0x50(%rdi), %rdi
addl 0x34(%r8), %ecx
movl %esi, %r8d
subl %esi, %ecx
decq %r8
movq %r8, %rsi
movslq %ecx, %rcx
movswq (%rdx,%rcx,2), %r9
shlq $0x4, %r9
movl %eax, 0x8(%rdi,%r9)
incl %ecx
decq %rsi
testl %r8d, %r8d
movq %rsi, %r8
jne 0xdf48
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: new_localvar
static void new_localvar (LexState *ls, TString *name) {
  FuncState *fs = ls->fs;
  Dyndata *dyd = ls->dyd;
  int reg = registerlocalvar(ls, name);
  checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal,
                  MAXVARS, "local variables");
  luaM_growvector(ls->L, dyd->actvar.arr, dyd->actvar.n + 1,
                  dyd->actvar.size, Vardesc, MAX_INT, "local variables");
  dyd->actvar.arr[dyd->actvar.n++].idx = cast(short, reg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x30(%rdi), %r14
movq 0x58(%rdi), %rbp
movq (%r14), %r12
leaq 0x24(%r12), %r13
movslq 0x24(%r12), %r15
movswl 0x38(%r14), %eax
cmpl %eax, %r15d
jg 0xdfcd
movq 0x38(%rbx), %rdi
movq 0x50(%r12), %rsi
leaq 0x13aae(%rip), %r9      # 0x21a55
movl $0x10, %ecx
movq %rbx, (%rsp)
movq %rdx, %rbx
movq %r13, %rdx
movl $0x7fff, %r8d           # imm = 0x7FFF
callq 0xb38c
movq %rbx, %rdx
movq (%rsp), %rbx
movq %rax, 0x50(%r12)
movslq (%r13), %rax
cmpl %eax, %r15d
jge 0xdff2
subq %r15, %rax
shlq $0x4, %r15
addq 0x50(%r12), %r15
movq $0x0, (%r15)
addq $0x10, %r15
decq %rax
jne 0xdfe2
movq 0x50(%r12), %rax
movswq 0x38(%r14), %rcx
shlq $0x4, %rcx
movq %rdx, (%rax,%rcx)
testb $0x4, 0x9(%r12)
je 0xe01e
testb $0x3, 0x9(%rdx)
je 0xe01e
movq 0x38(%rbx), %rdi
movq %r12, %rsi
callq 0x9ddc
movl 0x34(%r14), %ecx
movl 0x38(%r14), %r15d
leal 0x1(%r15), %eax
movw %ax, 0x38(%r14)
movl 0x8(%rbp), %eax
negl %ecx
addl %eax, %ecx
incl %ecx
cmpl $0xc9, %ecx
jge 0xe091
addl $0x2, %eax
cmpl 0xc(%rbp), %eax
jle 0xe06f
leaq 0xc(%rbp), %rdx
movq 0x38(%rbx), %rdi
movq (%rbp), %rsi
leaq 0x139fa(%rip), %r9      # 0x21a55
movl $0x2, %ecx
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
callq 0xb38c
movq %rax, (%rbp)
movq (%rbp), %rax
movslq 0x8(%rbp), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbp)
movw %r15w, (%rax,%rcx,2)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x139bd(%rip), %rdx     # 0x21a55
movq %r14, %rdi
movl $0xc8, %esi
callq 0xc567
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: fieldsel
static void fieldsel (LexState *ls, expdesc *v) {
  /* fieldsel -> ['.' | ':'] NAME */
  FuncState *fs = ls->fs;
  expdesc key;
  luaK_exp2anyregup(fs, v);
  luaX_next(ls);  /* skip the dot or colon */
  checkname(ls, &key);
  luaK_indexed(fs, v, &key);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0x15eec
movq %r14, %rdi
callq 0x16f0a
movq %r14, %rdi
callq 0xcff8
movq 0x30(%r14), %rdi
movq %rax, %rsi
callq 0x15a2c
leaq 0x8(%rsp), %rdx
movq $-0x1, 0x10(%rdx)
movl $0x4, (%rdx)
movl %eax, 0x8(%rdx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x16368
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: funcargs
static void funcargs (LexState *ls, expdesc *f, int line) {
  FuncState *fs = ls->fs;
  expdesc args;
  int base, nparams;
  switch (ls->t.token) {
    case '(': {  /* funcargs -> '(' [ explist ] ')' */
      luaX_next(ls);
      if (ls->t.token == ')')  /* arg list is empty? */
        args.k = VVOID;
      else {
        explist(ls, &args);
        luaK_setmultret(fs, &args);
      }
      check_match(ls, ')', '(', line);
      break;
    }
    case '{': {  /* funcargs -> constructor */
      constructor(ls, &args);
      break;
    }
    case TK_STRING: {  /* funcargs -> STRING */
      codestring(ls, &args, ls->t.seminfo.ts);
      luaX_next(ls);  /* must use 'seminfo' before 'next' */
      break;
    }
    default: {
      luaX_syntaxerror(ls, "function arguments expected");
    }
  }
  lua_assert(f->k == VNONRELOC);
  base = f->u.info;  /* base register for call */
  if (hasmultret(args.k))
    nparams = LUA_MULTRET;  /* open call */
  else {
    if (args.k != VVOID)
      luaK_exp2nextreg(fs, &args);  /* close last argument */
    nparams = fs->freereg - (base+1);
  }
  init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
  luaK_fixline(fs, line);
  fs->freereg = base+1;  /* call remove function and arguments and leaves
                            (unless changed) one result */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rbx
movl 0x10(%rdi), %eax
cmpl $0x125, %eax            # imm = 0x125
je 0xe185
cmpl $0x7b, %eax
je 0xe176
cmpl $0x28, %eax
jne 0xe255
movq %r15, %rdi
callq 0x16f0a
cmpl $0x29, 0x10(%r15)
jne 0xe1b0
movl $0x0, 0x8(%rsp)
jmp 0xe1d0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xd805
jmp 0xe1e4
movq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x15a2c
movq $-0x1, 0x18(%rsp)
movl $0x4, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movq %r15, %rdi
callq 0x16f0a
jmp 0xe1e4
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3df
movq %rbx, %rdi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x15bc7
movq %r15, %rdi
movl $0x29, %esi
movl $0x28, %edx
movl %ebp, %ecx
callq 0xcf87
movl 0x8(%r14), %r15d
movl 0x8(%rsp), %eax
leal -0xd(%rax), %edx
xorl %ecx, %ecx
cmpl $0x2, %edx
jb 0xe20e
testl %eax, %eax
je 0xe207
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x15d1e
movzbl 0x3c(%rbx), %ecx
subl %r15d, %ecx
movq %rbx, %rdi
movl $0x24, %esi
movl %r15d, %edx
movl $0x2, %r8d
callq 0x156de
movq $-0x1, 0x10(%r14)
movl $0xd, (%r14)
movl %eax, 0x8(%r14)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1697a
incb %r15b
movb %r15b, 0x3c(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13834(%rip), %rsi     # 0x21a90
movq %r15, %rdi
callq 0x16d86
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: singlevar
static void singlevar (LexState *ls, expdesc *var) {
  TString *varname = str_checkname(ls);
  FuncState *fs = ls->fs;
  singlevaraux(fs, varname, var, 1);
  if (var->k == VVOID) {  /* global name? */
    expdesc key;
    singlevaraux(fs, ls->envn, var, 1);  /* get environment variable */
    lua_assert(var->k != VVOID);  /* this one must exist */
    codestring(ls, &key, varname);  /* key is variable name */
    luaK_indexed(fs, var, &key);  /* env[varname] */
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0xcff8
movq %rax, %r12
movq 0x30(%r15), %r14
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xe2e4
cmpl $0x0, (%rbx)
jne 0xe2d8
movq 0x68(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xe2e4
movq 0x30(%r15), %rdi
movq %r12, %rsi
callq 0x15a2c
movq %rsp, %rdx
movq $-0x1, 0x10(%rdx)
movl $0x4, (%rdx)
movl %eax, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x16368
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: singlevaraux
static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
  if (fs == NULL)  /* no more levels? */
    init_exp(var, VVOID, 0);  /* default is global */
  else {
    int v = searchvar(fs, n);  /* look up locals at current level */
    if (v >= 0) {  /* found? */
      init_exp(var, VLOCAL, v);  /* variable is local */
      if (!base)
        markupval(fs, v);  /* local will be used as an upval */
    }
    else {  /* not found as local at current level; try upvalues */
      int idx = searchupvalue(fs, n);  /* try existing upvalues */
      if (idx < 0) {  /* not found? */
        singlevaraux(fs->prev, n, var, 0);  /* try upper levels */
        if (var->k == VVOID)  /* not found? */
          return;  /* it is a global */
        /* else was LOCAL or UPVAL */
        idx  = newupvalue(fs, n, var);  /* will be a new upvalue */
      }
      init_exp(var, VUPVAL, idx);  /* new or old upvalue */
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
testq %rdi, %rdi
je 0xe32d
movq %rsi, %r15
movq %rdi, %r14
movzbl 0x3a(%rdi), %eax
testl %eax, %eax
jle 0xe33e
decl %eax
movq (%r14), %rdx
movq 0x10(%r14), %rsi
movq 0x58(%rsi), %rsi
movq (%rsi), %rsi
movl 0x34(%r14), %edi
addl %eax, %edi
movslq %edi, %rdi
movswq (%rsi,%rdi,2), %rsi
movq 0x50(%rdx), %rdx
shlq $0x4, %rsi
cmpq %r15, (%rdx,%rsi)
jne 0xe2fb
jmp 0xe343
movq $-0x1, 0x10(%rbx)
xorl %eax, %eax
movl %eax, (%rbx)
jmp 0xe3d6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0xe373
movq $-0x1, 0x10(%rbx)
movl $0x8, (%rbx)
movl %eax, 0x8(%rbx)
testl %ecx, %ecx
jne 0xe3d9
addq $0x18, %r14
movq (%r14), %r14
movzbl 0x10(%r14), %ecx
cmpl %ecx, %eax
jl 0xe360
movb $0x1, 0x11(%r14)
jmp 0xe3d9
movzbl 0x3b(%r14), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0xe3a0
movq (%r14), %rdx
movq 0x58(%rdx), %rsi
xorl %edx, %edx
cmpq %r15, (%rsi)
je 0xe39e
incq %rdx
addq $0x10, %rsi
cmpq %rdx, %rcx
jne 0xe38b
jmp 0xe3a0
movl %edx, %eax
testl %eax, %eax
jns 0xe3c8
movq 0x8(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xe2e4
cmpl $0x0, (%rbx)
je 0xe3d9
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xc2d2
movq $-0x1, 0x10(%rbx)
movl $0x9, (%rbx)
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: explist
static int explist (LexState *ls, expdesc *v) {
  /* explist -> expr { ',' expr } */
  int n = 1;  /* at least one expression */
  expr(ls, v);
  while (testnext(ls, ',')) {
    luaK_exp2nextreg(ls->fs, v);
    expr(ls, v);
    n++;
  }
  return n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0xd37c
movl $0x1, %ebp
cmpl $0x2c, 0x10(%r14)
jne 0xe421
movq %r14, %rdi
callq 0x16f0a
movq 0x30(%r14), %rdi
movq %rbx, %rsi
callq 0x15d1e
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd37c
incl %ebp
jmp 0xe3f5
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: undefgoto
static l_noret undefgoto (LexState *ls, Labeldesc *gt) {
  const char *msg = isreserved(gt->name)
                    ? "<%s> at line %d not inside a loop"
                    : "no visible label '%s' for <goto> at line %d";
  msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line);
  semerror(ls, msg);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdx
cmpb $0x4, 0x8(%rdx)
jne 0xe44d
cmpb $0x0, 0xa(%rdx)
leaq 0x136d9(%rip), %rcx     # 0x21b19
leaq 0x136b0(%rip), %rax     # 0x21af7
cmoveq %rcx, %rax
jmp 0xe454
leaq 0x136c5(%rip), %rax     # 0x21b19
movq 0x38(%rbx), %rdi
addq $0x18, %rdx
movl 0xc(%rsi), %ecx
movq %rax, %rsi
xorl %eax, %eax
callq 0xbf04
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe610
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: newlabelentry
static int newlabelentry (LexState *ls, Labellist *l, TString *name,
                          int line, int pc) {
  int n = l->n;
  luaM_growvector(ls->L, l->arr, n, l->size,
                  Labeldesc, SHRT_MAX, "labels/gotos");
  l->arr[n].name = name;
  l->arr[n].line = line;
  l->arr[n].nactvar = ls->fs->nactvar;
  l->arr[n].pc = pc;
  l->n = n + 1;
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r12
movslq 0x8(%rsi), %r15
cmpl 0xc(%rsi), %r15d
jl 0xe4bd
leaq 0xc(%r14), %rdx
movq 0x38(%r12), %rdi
movq (%r14), %rsi
leaq 0x13608(%rip), %r9      # 0x21ab2
movl $0x18, %ecx
movl $0x7fff, %r8d           # imm = 0x7FFF
callq 0xb38c
movq %rax, (%r14)
leal 0x1(%r15), %eax
movq (%r14), %rcx
leaq (%r15,%r15,2), %rdx
movq %r13, (%rcx,%rdx,8)
movl %ebp, 0xc(%rcx,%rdx,8)
movq 0x30(%r12), %rsi
movb 0x3a(%rsi), %sil
movb %sil, 0x10(%rcx,%rdx,8)
movl %ebx, 0x8(%rcx,%rdx,8)
movl %eax, 0x8(%r14)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: findgotos
static void findgotos (LexState *ls, Labeldesc *lb) {
  Labellist *gl = &ls->dyd->gt;
  int i = ls->fs->bl->firstgoto;
  while (i < gl->n) {
    if (eqstr(gl->arr[i].name, lb->name))
      closegoto(ls, i, lb);
    else
      i++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rax
movq 0x58(%rdi), %r15
movq 0x18(%rax), %rax
movl 0xc(%rax), %ebp
cmpl 0x18(%r15), %ebp
jge 0xe545
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%r15), %rax
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %rax
cmpq (%rbx), %rax
je 0xe532
incl %ebp
jmp 0xe53f
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0xe550
cmpl 0x18(%r15), %ebp
jl 0xe51a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: closegoto
static void closegoto (LexState *ls, int g, Labeldesc *label) {
  int i;
  FuncState *fs = ls->fs;
  Labellist *gl = &ls->dyd->gt;
  Labeldesc *gt = &gl->arr[g];
  lua_assert(eqstr(gt->name, label->name));
  if (gt->nactvar < label->nactvar) {
    TString *vname = getlocvar(fs, gt->nactvar)->varname;
    const char *msg = luaO_pushfstring(ls->L,
      "<goto %s> at line %d jumps into the scope of local '%s'",
      getstr(gt->name), gt->line, getstr(vname));
    semerror(ls, msg);
  }
  luaK_patchlist(fs, gt->pc, label->pc);
  /* remove goto from pending list */
  for (i = g; i < gl->n - 1; i++)
    gl->arr[i] = gl->arr[i + 1];
  gl->n--;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq 0x58(%rbx), %r14
movq 0x10(%r14), %rax
movslq %esi, %r15
leaq (%r15,%r15,2), %rcx
leaq (%rax,%rcx,8), %r12
movzbl 0x10(%r12), %esi
cmpb 0x10(%rdx), %sil
jb 0xe5da
movl 0x8(%r12), %esi
movl 0x8(%rdx), %edx
callq 0x157f9
movl 0x18(%r14), %ecx
decl %ecx
cmpl %ebp, %ecx
jle 0xe5cd
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %rax
movq 0x10(%r14), %rcx
incq %r15
movq 0x28(%rcx,%rax), %rdx
movq %rdx, 0x10(%rcx,%rax)
movups 0x18(%rcx,%rax), %xmm0
movups %xmm0, (%rcx,%rax)
movslq 0x18(%r14), %rcx
decq %rcx
addq $0x18, %rax
cmpq %rcx, %r15
jl 0xe5a3
movl %ecx, 0x18(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xe0a5
movq (%rax), %r8
movq 0x38(%rbx), %rdi
movq (%r12), %rdx
addq $0x18, %rdx
movl 0xc(%r12), %ecx
addq $0x18, %r8
leaq 0x134c1(%rip), %rsi     # 0x21abf
xorl %eax, %eax
callq 0xbf04
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe610
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: findlabel
static int findlabel (LexState *ls, int g) {
  int i;
  BlockCnt *bl = ls->fs->bl;
  Dyndata *dyd = ls->dyd;
  Labeldesc *gt = &dyd->gt.arr[g];
  /* check labels in current block for a match */
  for (i = bl->firstlabel; i < dyd->label.n; i++) {
    Labeldesc *lb = &dyd->label.arr[i];
    if (eqstr(lb->name, gt->name)) {  /* correct label? */
      if (gt->nactvar > lb->nactvar &&
          (bl->upval || dyd->label.n > bl->firstlabel))
        luaK_patchclose(ls->fs, gt->pc, lb->nactvar);
      closegoto(ls, g, lb);  /* close it */
      return 1;
    }
  }
  return 0;  /* label not found; cannot close goto */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x30(%rdi), %rax
movq 0x58(%rdi), %rdi
movq 0x18(%rax), %rcx
movslq 0x8(%rcx), %r9
movslq 0x28(%rdi), %rsi
xorl %eax, %eax
cmpl %esi, %r9d
jge 0xe6ab
movslq %ebx, %rdx
leaq (%rdx,%rdx,2), %r8
shlq $0x3, %r8
addq 0x10(%rdi), %r8
movq (%r8), %rdx
leaq (%r9,%r9,2), %r15
shlq $0x3, %r15
addq 0x20(%rdi), %r15
movq %rsi, %rdi
subq %r9, %rdi
cmpq %rdx, (%r15)
je 0xe676
addq $0x18, %r15
decq %rdi
jne 0xe666
jmp 0xe6ab
movzbl 0x10(%r15), %edx
cmpb %dl, 0x10(%r8)
jbe 0xe699
cmpb $0x0, 0x11(%rcx)
jne 0xe68c
cmpl 0x8(%rcx), %esi
jle 0xe699
movq 0x30(%r14), %rdi
movl 0x8(%r8), %esi
callq 0x15897
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0xe550
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq