LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x13007
movq -0x10(%rbp), %rax
movzbl 0x11(%rax), %eax
cmpl $0x0, %eax
je 0x13007
movq -0x8(%rbp), %rdi
callq 0x21ec0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %edx
callq 0x220c0
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x21fc0
movq -0x10(%rbp), %rax
cmpb $0x0, 0x12(%rax)
je 0x1301a
movq -0x18(%rbp), %rdi
callq 0x149a0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %esi
callq 0x14a20
movq -0x8(%rbp), %rax
movb 0x3a(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3c(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x13073
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14a90
jmp 0x130ad
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
movq 0x58(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jge 0x130ab
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0xc(%rax), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0x14b50
jmp 0x130ad
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: subexpr
static BinOpr subexpr (LexState *ls, expdesc *v, int limit) {
  BinOpr op;
  UnOpr uop;
  enterlevel(ls);
  uop = getunopr(ls->t.token);
  if (uop != OPR_NOUNOPR) {
    int line = ls->linenumber;
    luaX_next(ls);
    subexpr(ls, v, UNARY_PRIORITY);
    luaK_prefix(ls->fs, uop, v, line);
  }
  else simpleexp(ls, v);
  /* expand while operators have priorities higher than 'limit' */
  op = getbinopr(ls->t.token);
  while (op != OPR_NOBINOPR && priority[op].left > limit) {
    expdesc v2;
    BinOpr nextop;
    int line = ls->linenumber;
    luaX_next(ls);
    luaK_infix(ls->fs, op, v);
    /* read sub-expression with higher priority */
    nextop = subexpr(ls, &v2, priority[op].right);
    luaK_posfix(ls->fs, op, v, &v2, line);
    op = nextop;
  }
  leavelevel(ls);
  return op;  /* return first untreated operator */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12410
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x13210
movl %eax, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
je 0x1312f
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xc, %edx
callq 0x130c0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x20(%rbp), %ecx
callq 0x23320
jmp 0x1313c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13280
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x13480
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x15, -0x18(%rbp)
movb %al, -0x41(%rbp)
je 0x1316f
movl -0x18(%rbp), %eax
movl %eax, %ecx
leaq 0x21e5e(%rip), %rax     # 0x34fc0
movzbl (%rax,%rcx,2), %eax
cmpl -0x14(%rbp), %eax
setg %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x13178
jmp 0x131e7
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x23630
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %ecx
leaq 0x21e11(%rip), %rax     # 0x34fc0
movzbl 0x1(%rax,%rcx,2), %edx
leaq -0x38(%rbp), %rsi
callq 0x130c0
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x40(%rbp), %r8d
leaq -0x38(%rbp), %rcx
callq 0x23790
movl -0x3c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1314b
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movw 0xc6(%rax), %cx
addw $-0x1, %cx
movw %cx, 0xc6(%rax)
movl -0x18(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: getunopr
static UnOpr getunopr (int op) {
  switch (op) {
    case TK_NOT: return OPR_NOT;
    case '-': return OPR_MINUS;
    case '~': return OPR_BNOT;
    case '#': return OPR_LEN;
    default: return OPR_NOUNOPR;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x23, %eax
je 0x1325f
jmp 0x13224
movl -0xc(%rbp), %eax
subl $0x2d, %eax
je 0x1324d
jmp 0x1322e
movl -0xc(%rbp), %eax
subl $0x7e, %eax
je 0x13256
jmp 0x13238
movl -0xc(%rbp), %eax
subl $0x10f, %eax            # imm = 0x10F
jne 0x13268
jmp 0x13244
movl $0x2, -0x4(%rbp)
jmp 0x1326f
movl $0x0, -0x4(%rbp)
jmp 0x1326f
movl $0x1, -0x4(%rbp)
jmp 0x1326f
movl $0x3, -0x4(%rbp)
jmp 0x1326f
movl $0x4, -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: body
static void body (LexState *ls, expdesc *e, int ismethod, int line) {
  /* body ->  '(' parlist ')' block END */
  FuncState new_fs;
  BlockCnt bl;
  new_fs.f = addprototype(ls);
  new_fs.f->linedefined = line;
  open_func(ls, &new_fs, &bl);
  checknext(ls, '(');
  if (ismethod) {
    new_localvarliteral(ls, "self");  /* create 'self' parameter */
    adjustlocalvars(ls, 1);
  }
  parlist(ls);
  checknext(ls, ')');
  statlist(ls);
  new_fs.f->lastlinedefined = ls->linenumber;
  check_match(ls, TK_END, TK_FUNCTION, line);
  codeclosure(ls, e);
  close_func(ls);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13e50
movq %rax, -0x58(%rbp)
movl -0x18(%rbp), %ecx
movq -0x58(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x11aa0
movq -0x8(%rbp), %rdi
movl $0x28, %esi
callq 0x12f20
cmpl $0x0, -0x14(%rbp)
je 0x13925
movq -0x8(%rbp), %rdi
leaq 0x214ef(%rip), %rsi     # 0x34dfc
movl $0x4, %edx
callq 0x13f90
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x13fd0
movq -0x8(%rbp), %rdi
callq 0x14040
movq -0x8(%rbp), %rdi
movl $0x29, %esi
callq 0x12f20
movq -0x8(%rbp), %rdi
callq 0x11d60
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x58(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %ecx
movl $0x106, %esi            # imm = 0x106
movl $0x109, %edx            # imm = 0x109
callq 0x12600
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14160
movq -0x8(%rbp), %rdi
callq 0x11df0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14430
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x54(%rbp)
subl $0x28, %eax
je 0x13a8b
jmp 0x139d8
movl -0x54(%rbp), %eax
subl $0x2e, %eax
je 0x13a13
jmp 0x139e2
movl -0x54(%rbp), %eax
subl $0x3a, %eax
je 0x13a52
jmp 0x139ec
movl -0x54(%rbp), %eax
subl $0x5b, %eax
je 0x13a25
jmp 0x139f6
movl -0x54(%rbp), %eax
subl $0x7b, %eax
je 0x13a8b
jmp 0x13a04
movl -0x54(%rbp), %eax
subl $0x125, %eax            # imm = 0x125
je 0x13a8b
jmp 0x13aaa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x144d0
jmp 0x13ab0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22be0
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13e00
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x232b0
jmp 0x13ab0
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x13dc0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x22f70
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x14530
jmp 0x13ab0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22950
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x14530
jmp 0x13ab0
addq $0x60, %rsp
popq %rbp
retq
jmp 0x139c3
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: closelistfield
static void closelistfield (FuncState *fs, struct ConsControl *cc) {
  if (cc->v.k == VVOID) return;  /* there is no list item */
  luaK_exp2nextreg(fs, &cc->v);
  cc->v.k = VVOID;
  if (cc->tostore == LFIELDS_PER_FLUSH) {
    luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore);  /* flush */
    cc->tostore = 0;  /* no more items pending */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x13adb
jmp 0x13b29
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22950
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x32, 0x28(%rax)
jne 0x13b29
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x24(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
callq 0x23b60
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: field
static void field (LexState *ls, struct ConsControl *cc) {
  /* field -> listfield | recfield */
  switch(ls->t.token) {
    case TK_NAME: {  /* may be 'listfield' or 'recfield' */
      if (luaX_lookahead(ls) != '=')  /* expression? */
        listfield(ls, cc);
      else
        recfield(ls, cc);
      break;
    }
    case '[': {
      recfield(ls, cc);
      break;
    }
    default: {
      listfield(ls, cc);
      break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x5b, %eax
je 0x13b89
jmp 0x13b51
movl -0x14(%rbp), %eax
subl $0x124, %eax            # imm = 0x124
jne 0x13b98
jmp 0x13b5d
movq -0x8(%rbp), %rdi
callq 0x24f40
cmpl $0x3d, %eax
je 0x13b7a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13c60
jmp 0x13b87
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13cc0
jmp 0x13ba5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13cc0
jmp 0x13ba5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13c60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: lastlistfield
static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
  if (cc->tostore == 0) return;
  if (hasmultret(cc->v.k)) {
    luaK_setmultret(fs, &cc->v);
    luaK_setlist(fs, cc->t->u.info, cc->na, LUA_MULTRET);
    cc->na--;  /* do not count last expression (unknown number of elements) */
  }
  else {
    if (cc->v.k != VVOID)
      luaK_exp2nextreg(fs, &cc->v);
    luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x13bcf
jmp 0x13c5a
movq -0x10(%rbp), %rax
cmpl $0xd, (%rax)
je 0x13be1
movq -0x10(%rbp), %rax
cmpl $0xe, (%rax)
jne 0x13c22
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x22670
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x24(%rax), %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x23b60
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x24(%rax)
jmp 0x13c5a
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x13c38
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22950
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x24(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
callq 0x23b60
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: listfield
static void listfield (LexState *ls, struct ConsControl *cc) {
  /* listfield -> exp */
  expr(ls, &cc->v);
  checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
  cc->na++;
  cc->tostore++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12ef0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x24(%rax), %esi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
leaq 0x2114d(%rip), %rcx     # 0x34de5
callq 0x12080
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movzbl 0x3c(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x124, 0x10(%rax)      # imm = 0x124
jne 0x13d23
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
leaq 0x210d6(%rip), %rcx     # 0x34de5
callq 0x12080
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13dc0
jmp 0x13d30
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13e00
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movl $0x3d, %esi
callq 0x12f20
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x22c70
movl %eax, -0x54(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x12ef0
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x5c(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x22c70
movq -0x68(%rbp), %rdi
movl -0x5c(%rbp), %edx
movl -0x58(%rbp), %ecx
movl %eax, %r8d
movl $0xa, %esi
callq 0x21d20
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3c(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12ef0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x22c20
movq -0x8(%rbp), %rdi
movl $0x5d, %esi
callq 0x12f20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: addprototype
static Proto *addprototype (LexState *ls) {
  Proto *clp;
  lua_State *L = ls->L;
  FuncState *fs = ls->fs;
  Proto *f = fs->f;  /* prototype of current function */
  if (fs->np >= f->sizep) {
    int oldsize = f->sizep;
    luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions");
    while (oldsize < f->sizep)
      f->p[oldsize++] = NULL;
  }
  f->p[fs->np++] = clp = luaF_newproto(L);
  luaC_objbarrier(L, f, clp);
  return clp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jl 0x13f16
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl 0x30(%rax), %eax
addl $0x1, %eax
movq -0x28(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jle 0x13ee6
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x28(%rbp), %rdx
addq $0x20, %rdx
movl $0x8, %ecx
movl $0x3ffff, %r8d          # imm = 0x3FFFF
leaq 0x22399(%rip), %r9      # 0x3626f
callq 0x10070
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0x13ee8
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x13f14
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x2c(%rbp)
movslq %ecx, %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x13ee8
jmp 0x13f16
movq -0x18(%rbp), %rdi
callq 0xd2d0
movq %rax, %rdx
movq %rdx, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rsi
movl 0x30(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x30(%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x13f77
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x13f77
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xd5a0
jmp 0x13f79
jmp 0x13f79
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
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)
movq -0x18(%rbp), %rax
movzbl 0x3a(%rax), %eax
addl -0xc(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3a(%rax)
cmpl $0x0, -0xc(%rbp)
je 0x14034
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl 0x3a(%rax), %esi
subl -0xc(%rbp), %esi
callq 0x143e0
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13fff
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: parlist
static void parlist (LexState *ls) {
  /* parlist -> [ param { ',' param } ] */
  FuncState *fs = ls->fs;
  Proto *f = fs->f;
  int nparams = 0;
  f->is_vararg = 0;
  if (ls->t.token != ')') {  /* is 'parlist' not empty? */
    do {
      switch (ls->t.token) {
        case TK_NAME: {  /* param -> NAME */
          new_localvar(ls, str_checkname(ls));
          nparams++;
          break;
        }
        case TK_DOTS: {  /* param -> '...' */
          luaX_next(ls);
          f->is_vararg = 2;  /* declared vararg */
          break;
        }
        default: luaX_syntaxerror(ls, "<name> or '...' expected");
      }
    } while (!f->is_vararg && testnext(ls, ','));
  }
  adjustlocalvars(ls, nparams);
  f->numparams = cast_byte(fs->nactvar);
  luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */
}

// 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), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, 0xb(%rax)
movq -0x8(%rbp), %rax
cmpl $0x29, 0x10(%rax)
je 0x14121
jmp 0x14082
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x119, %eax            # imm = 0x119
je 0x140c9
jmp 0x14095
movl -0x20(%rbp), %eax
subl $0x124, %eax            # imm = 0x124
jne 0x140dc
jmp 0x140a1
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12af0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x141d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x140ec
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x18(%rbp), %rax
movb $0x2, 0xb(%rax)
jmp 0x140ec
movq -0x8(%rbp), %rdi
leaq 0x20d2a(%rip), %rsi     # 0x34e11
callq 0x24390
jmp 0x140ee
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, 0xb(%rcx)
movb %al, -0x29(%rbp)
jne 0x14114
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x12890
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x14082
jmp 0x14121
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x13fd0
movq -0x10(%rbp), %rax
movb 0x3a(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0xa(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x3a(%rax), %esi
callq 0x22350
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x142b0
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
addl $0x1, %esi
movq -0x18(%rbp), %rax
subl 0x34(%rax), %esi
movl $0xc8, %edx
leaq 0x20bd8(%rip), %rcx     # 0x34e01
callq 0x12080
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
addl $0x1, %eax
movq -0x20(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x1427c
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
addq $0xc, %rdx
movl $0x2, %ecx
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
leaq 0x20b94(%rip), %r9      # 0x34e01
callq 0x10070
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
movw %ax, %dx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rsi
movl 0x8(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x8(%rsi)
movslq %ecx, %rcx
movw %dx, (%rax,%rcx,2)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: registerlocalvar
static int registerlocalvar (LexState *ls, TString *varname) {
  FuncState *fs = ls->fs;
  Proto *f = fs->f;
  int oldsize = f->sizelocvars;
  luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,
                  LocVar, SHRT_MAX, "local variables");
  while (oldsize < f->sizelocvars)
    f->locvars[oldsize++].varname = NULL;
  f->locvars[fs->nlocvars].varname = varname;
  luaC_objbarrier(ls->L, f, varname);
  return fs->nlocvars++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movswl 0x38(%rax), %eax
addl $0x1, %eax
movq -0x20(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jle 0x1432f
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x20(%rbp), %rdx
addq $0x24, %rdx
movl $0x10, %ecx
movl $0x7fff, %r8d           # imm = 0x7FFF
leaq 0x20ae2(%rip), %r9      # 0x34e01
callq 0x10070
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
jmp 0x14331
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jge 0x14363
movq -0x20(%rbp), %rax
movq 0x50(%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 0x14331
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x18(%rbp), %rdx
movswq 0x38(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x143b9
movq -0x10(%rbp), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x143b9
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xd5a0
jmp 0x143bb
jmp 0x143bb
movq -0x18(%rbp), %rcx
movw 0x38(%rcx), %ax
movw %ax, %dx
addw $0x1, %dx
movw %dx, 0x38(%rcx)
cwtl
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: primaryexp
static void primaryexp (LexState *ls, expdesc *v) {
  /* primaryexp -> NAME | '(' expr ')' */
  switch (ls->t.token) {
    case '(': {
      int line = ls->linenumber;
      luaX_next(ls);
      expr(ls, v);
      check_match(ls, ')', '(', line);
      luaK_dischargevars(ls->fs, v);
      return;
    }
    case TK_NAME: {
      singlevar(ls, v);
      return;
    }
    default: {
      luaX_syntaxerror(ls, "unexpected symbol");
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x28, %eax
je 0x1445d
jmp 0x14451
movl -0x18(%rbp), %eax
subl $0x124, %eax            # imm = 0x124
je 0x144a6
jmp 0x144b5
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12ef0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl $0x29, %esi
movl $0x28, %edx
callq 0x12600
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x22800
jmp 0x144c5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x146b0
jmp 0x144c5
movq -0x8(%rbp), %rdi
leaq 0x2096a(%rip), %rsi     # 0x34e2a
callq 0x24390
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22be0
movq -0x8(%rbp), %rdi
callq 0x24650
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13dc0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x232b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12af0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x14740
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x14734
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rsi
movq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x14740
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x136b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x232b0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x14770
movq -0x18(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x11b90
jmp 0x1480a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14810
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x147ab
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %edx
movl $0x8, %esi
callq 0x11b90
cmpl $0x0, -0x1c(%rbp)
jne 0x147a9
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x14880
jmp 0x14808
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x148c0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x147f7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x14740
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x147e3
jmp 0x1480a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x11bd0
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %edx
movl $0x9, %esi
callq 0x11b90
jmp 0x1480a
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: searchvar
static int searchvar (FuncState *fs, TString *n) {
  int i;
  for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) {
    if (eqstr(n, getlocvar(fs, i)->varname))
      return i;
  }
  return -1;  /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x3a(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x14869
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x143e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq (%rcx), %rax
jne 0x1485c
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14870
jmp 0x1485e
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1482e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: markupval
static void markupval (FuncState *fs, int level) {
  BlockCnt *bl = fs->bl;
  while (bl->nactvar > level)
    bl = bl->previous;
  bl->upval = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x148b1
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x14897
movq -0x18(%rbp), %rax
movb $0x1, 0x11(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: searchupvalue
static int searchupvalue (FuncState *fs, TString *name) {
  int i;
  Upvaldesc *up = fs->f->upvalues;
  for (i = 0; i < fs->nups; i++) {
    if (eqstr(up[i].name, name)) return i;
  }
  return -1;  /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x3b(%rcx), %ecx
cmpl %ecx, %eax
jge 0x1491e
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x14911
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14925
jmp 0x14913
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x148e2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12ef0
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x12890
cmpl $0x0, %eax
je 0x14990
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x22950
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12ef0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14954
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: movegotosout
static void movegotosout (FuncState *fs, BlockCnt *bl) {
  int i = bl->firstgoto;
  Labellist *gl = &fs->ls->dyd->gt;
  /* correct pending gotos to current block and try to close it
     with visible labels */
  while (i < gl->n) {
    Labeldesc *gt = &gl->arr[i];
    if (gt->nactvar > bl->nactvar) {
      if (bl->upval)
        luaK_patchclose(fs, gt->pc, bl->nactvar);
      gt->nactvar = bl->nactvar;
    }
    if (!findlabel(fs->ls, i))
      i++;  /* move to next one */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x58(%rax), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x14b47
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jle 0x14b24
movq -0x10(%rbp), %rax
cmpb $0x0, 0x11(%rax)
je 0x14b16
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %edx
callq 0x220c0
movq -0x10(%rbp), %rax
movb 0x10(%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x14ec0
cmpl $0x0, %eax
jne 0x14b42
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14abe
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x8(%rax), %ecx
xorl %eax, %eax
cmpl $0x4, %ecx
movb %al, -0x19(%rbp)
jne 0x14b89
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0xa(%rax), %eax
cmpl $0x0, %eax
setg %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %dl
leaq 0x20332(%rip), %rax     # 0x34ec5
leaq 0x20309(%rip), %rcx     # 0x34ea3
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
addq $0x18, %rdx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movb $0x0, %al
callq 0x114b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14e90
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x14c4c
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0xc, %rdx
movl $0x18, %ecx
movl $0x7fff, %r8d           # imm = 0x7FFF
leaq 0x20221(%rip), %r9      # 0x34e5e
callq 0x10070
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movb 0x3a(%rax), %cl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x10(%rax)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x14d49
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x14d3e
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x14d50
jmp 0x14d47
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14d02
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzbl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jge 0x14e02
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movzbl 0x10(%rax), %esi
callq 0x143e0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rdx
addq $0x18, %rdx
movq -0x38(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x40(%rbp), %r8
addq $0x18, %r8
leaq 0x20081(%rip), %rsi     # 0x34e6b
movb $0x0, %al
callq 0x114b0
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x14e90
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x22000
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x30(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x14e7a
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14e1f
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x14fb9
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x14fa9
movq -0x30(%rbp), %rax
movzbl 0x10(%rax), %eax
movq -0x38(%rbp), %rcx
movzbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jle 0x14f90
movq -0x20(%rbp), %rax
movzbl 0x11(%rax), %eax
cmpl $0x0, %eax
jne 0x14f74
movq -0x28(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x14f90
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x30(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x38(%rbp), %rax
movzbl 0x10(%rax), %edx
callq 0x220c0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x38(%rbp), %rdx
callq 0x14d50
movl $0x1, -0x4(%rbp)
jmp 0x14fc0
jmp 0x14fab
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x14f0c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lparser.c
// Function: cond
static int cond (LexState *ls) {
  /* cond -> exp */
  expdesc v;
  expr(ls, &v);  /* read condition */
  if (v.k == VNIL) v.k = VFALSE;  /* 'falses' are all equal here */
  luaK_goiftrue(ls->fs, &v);
  return v.f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12ef0
cmpl $0x1, -0x20(%rbp)
jne 0x14ff6
movl $0x3, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x23020
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq