LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_exp2RK
int luaK_exp2RK (FuncState *fs, expdesc *e) {
  luaK_exp2val(fs, e);
  switch (e->k) {  /* move constants to 'k' */
    case VTRUE: e->u.info = boolK(fs, 1); goto vk;
    case VFALSE: e->u.info = boolK(fs, 0); goto vk;
    case VNIL: e->u.info = nilK(fs); goto vk;
    case VKINT: e->u.info = luaK_intK(fs, e->u.ival); goto vk;
    case VKFLT: e->u.info = luaK_numberK(fs, e->u.nval); goto vk;
    case VK:
     vk:
      e->k = VK;
      if (e->u.info <= MAXINDEXRK)  /* constant fits in 'argC'? */
        return RKASK(e->u.info);
      else break;
    default: break;
  }
  /* not a constant in the right range: put it in a register */
  return luaK_exp2anyreg(fs, e);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x15f02
movl (%rbx), %eax
decl %eax
cmpl $0x5, %eax
ja 0x15fed
leaq 0xc597(%rip), %rcx      # 0x224d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x18(%rsp), %rdx
movl $0x0, 0x8(%rdx)
movq 0x10(%r14), %rax
movq 0x50(%rax), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x45, 0x8(%rsi)
jmp 0x15fcb
movsd 0x8(%rbx), %xmm0
leaq 0x8(%rsp), %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
jmp 0x15fa1
movl $0x1, %eax
leaq 0x8(%rsp), %rdx
movl %eax, (%rdx)
movl %eax, 0x8(%rdx)
jmp 0x15fa1
leaq 0x8(%rsp), %rdx
movl $0x0, (%rdx)
movl $0x1, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
jmp 0x15fce
movq 0x8(%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x2, 0x8(%rsi)
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movl $0x13, 0x8(%rdx)
movq %r14, %rdi
callq 0x15a4f
movl %eax, 0x8(%rbx)
movl $0x4, (%rbx)
movl 0x8(%rbx), %eax
cmpl $0xff, %eax
jg 0x15fed
orl $0x100, %eax            # imm = 0x100
jmp 0x15ff8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15e97
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_storevar
void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
  switch (var->k) {
    case VLOCAL: {
      freeexp(fs, ex);
      exp2reg(fs, ex, var->u.info);  /* compute 'ex' into proper place */
      return;
    }
    case VUPVAL: {
      int e = luaK_exp2anyreg(fs, ex);
      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0);
      break;
    }
    case VINDEXED: {
      OpCode op = (var->u.ind.vt == VLOCAL) ? OP_SETTABLE : OP_SETTABUP;
      int e = luaK_exp2RK(fs, ex);
      luaK_codeABC(fs, op, var->u.ind.t, var->u.ind.idx, e);
      break;
    }
    default: lua_assert(0);  /* invalid var kind to store */
  }
  freeexp(fs, ex);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %eax
cmpl $0xa, %eax
je 0x16077
cmpl $0x9, %eax
je 0x1605b
cmpl $0x8, %eax
jne 0x160b5
cmpl $0x7, (%r14)
jne 0x16041
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x16041
movzbl 0x3a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x16041
decb 0x3c(%rbx)
movl 0x8(%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x15d73
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15e97
movl 0x8(%r15), %esi
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
orl $0x9, %esi
jmp 0x160ad
xorl %r12d, %r12d
cmpb $0x8, 0xb(%r15)
sete %r12b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15f13
movl %eax, %esi
movzbl 0xa(%r15), %eax
shll $0x6, %eax
leal (%rax,%r12,2), %eax
movl 0x8(%r15), %ecx
shll $0x17, %ecx
orl %eax, %ecx
shll $0xe, %esi
orl %ecx, %esi
orl $0x8, %esi
movq %rbx, %rdi
callq 0x158de
cmpl $0x7, (%r14)
jne 0x160d0
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x160d0
movzbl 0x3a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x160d0
decb 0x3c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_self
void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
  int ereg;
  luaK_exp2anyreg(fs, e);
  ereg = e->u.info;  /* register where 'e' was placed */
  freeexp(fs, e);
  e->u.info = fs->freereg;  /* base register for op_self */
  e->k = VNONRELOC;  /* self expression has a fixed register */
  luaK_reserveregs(fs, 2);  /* function and 'self' produced by op_self */
  luaK_codeABC(fs, OP_SELF, e->u.info, ereg, luaK_exp2RK(fs, key));
  freeexp(fs, key);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x15e97
movl (%r15), %eax
movl 0x8(%r15), %ebp
xorl $0x7, %eax
movl %ebp, %ecx
andl $0x100, %ecx            # imm = 0x100
orl %eax, %ecx
jne 0x16112
movzbl 0x3a(%rbx), %eax
cmpl %eax, %ebp
jl 0x16112
decb 0x3c(%rbx)
movzbl 0x3c(%rbx), %eax
movl %eax, 0x8(%r15)
movl $0x7, (%r15)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x159e5
addb $0x2, 0x3c(%rbx)
movl 0x8(%r15), %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15f13
shll $0x6, %r15d
shll $0x17, %ebp
orl %r15d, %ebp
shll $0xe, %eax
orl %eax, %ebp
orl $0xc, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x158de
cmpl $0x7, (%r14)
jne 0x16178
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x16178
movzbl 0x3a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x16178
decb 0x3c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_goiftrue
void luaK_goiftrue (FuncState *fs, expdesc *e) {
  int pc;  /* pc of new jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VJMP: {  /* condition? */
      negatecondition(fs, e);  /* jump when it is false */
      pc = e->u.info;  /* save jump position */
      break;
    }
    case VK: case VKFLT: case VKINT: case VTRUE: {
      pc = NO_JUMP;  /* always true; do nothing */
      break;
    }
    default: {
      pc = jumponcond(fs, e, 0);  /* jump when false */
      break;
    }
  }
  luaK_concat(fs, &e->f, pc);  /* insert new jump in false list */
  luaK_patchtohere(fs, e->t);  /* true list jumps to here (to go through) */
  e->t = NO_JUMP;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x15c92
movl (%rbx), %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leal -0x4(%rax), %ecx
cmpl $0x3, %ecx
jb 0x1620b
cmpl $0x2, %eax
je 0x1620b
cmpl $0xb, %eax
jne 0x161fc
movslq 0x8(%rbx), %rcx
movq (%r14), %rdx
leaq (,%rcx,4), %rax
addq 0x38(%rdx), %rax
testq %rcx, %rcx
jle 0x161da
movl -0x4(%rax), %ecx
andl $0x3f, %ecx
leaq 0xb6e0(%rip), %rdx      # 0x218b0
cmpb $0x0, (%rcx,%rdx)
jns 0x161da
addq $-0x4, %rax
movl (%rax), %ecx
movl %ecx, %edx
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
xorl %esi, %esi
testl $0x3fc0, %ecx           # imm = 0x3FC0
sete %sil
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax)
movl 0x8(%rbx), %edx
jmp 0x1620b
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1623d
movl %eax, %edx
leaq 0x14(%rbx), %rsi
movq %r14, %rdi
callq 0x156f5
movl 0x10(%rbx), %edx
movl 0x20(%r14), %eax
movl %eax, 0x24(%r14)
leaq 0x28(%r14), %rsi
movq %r14, %rdi
callq 0x156f5
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: jumponcond
static int jumponcond (FuncState *fs, expdesc *e, int cond) {
  if (e->k == VRELOCABLE) {
    Instruction ie = getinstruction(fs, e);
    if (GET_OPCODE(ie) == OP_NOT) {
      fs->pc--;  /* remove previous OP_NOT */
      return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);
    }
    /* else go through */
  }
  discharge2anyreg(fs, e);
  freeexp(fs, e);
  return condjump(fs, OP_TESTSET, NO_REG, e->u.info, cond);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0xc, (%rsi)
jne 0x162a6
movq (%rbx), %rax
movq 0x38(%rax), %rax
movslq 0x8(%r14), %rcx
movl (%rax,%rcx,4), %ecx
movl %ecx, %r15d
andl $0x3f, %r15d
cmpl $0x1b, %r15d
jne 0x16295
decl 0x20(%rbx)
xorl %esi, %esi
testl %ebp, %ebp
sete %sil
shrl $0x11, %ecx
andl $-0x40, %ecx
shll $0xe, %esi
orl %ecx, %esi
orl $0x22, %esi
movq %rbx, %rdi
callq 0x158de
movq %rbx, %rdi
callq 0x1577c
cmpl $0x1b, %r15d
jne 0x162a6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16be8
cmpl $0x7, (%r14)
jne 0x162cc
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x162cc
movzbl 0x3a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x162cc
decb 0x3c(%rbx)
movl 0x8(%r14), %eax
shll $0x17, %eax
shll $0xe, %ebp
orl %eax, %ebp
orl $0x3fe3, %ebp           # imm = 0x3FE3
movq %rbx, %rdi
movl %ebp, %esi
callq 0x158de
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1577c
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_goiffalse
void luaK_goiffalse (FuncState *fs, expdesc *e) {
  int pc;  /* pc of new jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VJMP: {
      pc = e->u.info;  /* already jump if true */
      break;
    }
    case VNIL: case VFALSE: {
      pc = NO_JUMP;  /* always false; do nothing */
      break;
    }
    default: {
      pc = jumponcond(fs, e, 1);  /* jump if true */
      break;
    }
  }
  luaK_concat(fs, &e->t, pc);  /* insert new jump in 't' list */
  luaK_patchtohere(fs, e->f);  /* false list jumps to here (to go through) */
  e->f = NO_JUMP;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x15c92
movl (%rbx), %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl $0x1, %eax
je 0x16336
cmpl $0x3, %eax
je 0x16336
cmpl $0xb, %eax
jne 0x16324
movl 0x8(%rbx), %edx
jmp 0x16336
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x1623d
movl %eax, %edx
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x156f5
movl 0x14(%rbx), %edx
movl 0x20(%r14), %eax
movl %eax, 0x24(%r14)
leaq 0x28(%r14), %rsi
movq %r14, %rdi
callq 0x156f5
movl $0xffffffff, 0x14(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_indexed
void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
  lua_assert(!hasjumps(t) && (vkisinreg(t->k) || t->k == VUPVAL));
  t->u.ind.t = t->u.info;  /* register or upvalue index */
  t->u.ind.idx = luaK_exp2RK(fs, k);  /* R/K index for key */
  t->u.ind.vt = (t->k == VUPVAL) ? VUPVAL : VLOCAL;
  t->k = VINDEXED;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movb 0x8(%rsi), %al
movb %al, 0xa(%rsi)
movq %rdx, %rsi
callq 0x15f13
movw %ax, 0x8(%rbx)
cmpl $0x9, (%rbx)
sete %al
orb $0x8, %al
movb %al, 0xb(%rbx)
movl $0xa, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_prefix
void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) {
  static expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP};  /* fake 2nd operand */
  switch (op) {
    case OPR_MINUS: case OPR_BNOT:
      if (constfolding(fs, op + LUA_OPUNM, e, &ef))
        break;
      /* FALLTHROUGH */
    case OPR_LEN:
      codeunexpval(fs, cast(OpCode, op + OP_UNM), e, line);
      break;
    case OPR_NOT: codenot(fs, e); break;
    default: lua_assert(0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x2, %esi
jb 0x163b6
je 0x1642f
cmpl $0x3, %r15d
je 0x163d0
jmp 0x16424
leal 0xc(%r15), %esi
leaq 0x18eff(%rip), %rcx     # 0x2f2c0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1652f
testl %eax, %eax
jne 0x16424
addl $0x19, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15e97
cmpl $0x7, (%r14)
jne 0x163fa
movl 0x8(%r14), %ecx
btl $0x8, %ecx
jb 0x163fa
movzbl 0x3a(%rbx), %edx
cmpl %edx, %ecx
jl 0x163fa
decb 0x3c(%rbx)
shll $0x17, %eax
orl %r15d, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x158de
movl %eax, 0x8(%r14)
movl $0xc, (%r14)
movq (%rbx), %rax
movq 0x48(%rax), %rax
movslq 0x20(%rbx), %rcx
movl %ebp, -0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15c92
movl (%r14), %eax
decl %eax
cmpl $0xb, %eax
ja 0x16501
leaq 0xc099(%rip), %rcx      # 0x224e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, (%r14)
jmp 0x16501
movl $0x2, (%r14)
jmp 0x16501
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16be8
cmpl $0x7, (%r14)
jne 0x16496
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x16496
movzbl 0x3a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x16496
decb 0x3c(%rbx)
movl 0x8(%r14), %esi
shll $0x17, %esi
orl $0x1b, %esi
movq %rbx, %rdi
callq 0x158de
movl %eax, 0x8(%r14)
movl $0xc, (%r14)
jmp 0x16501
movslq 0x8(%r14), %rcx
movq (%rbx), %rdx
leaq (,%rcx,4), %rax
addq 0x38(%rdx), %rax
testq %rcx, %rcx
jle 0x164e4
movl -0x4(%rax), %ecx
andl $0x3f, %ecx
leaq 0xb3d6(%rip), %rdx      # 0x218b0
cmpb $0x0, (%rcx,%rdx)
jns 0x164e4
addq $-0x4, %rax
movl (%rax), %ecx
movl %ecx, %edx
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
xorl %esi, %esi
testl $0x3fc0, %ecx           # imm = 0x3FC0
sete %sil
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax)
movl 0x10(%r14), %esi
movl 0x14(%r14), %eax
movl %esi, 0x14(%r14)
movl %eax, 0x10(%r14)
movq %rbx, %rdi
callq 0x16c23
movl 0x10(%r14), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x16c23
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: constfolding
static int constfolding (FuncState *fs, int op, expdesc *e1, expdesc *e2) {
  TValue v1, v2, res;
  if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2))
    return 0;  /* non-numeric operands or not safe to fold */
  luaO_arith(fs->ls->L, op, &v1, &v2, &res);  /* does operation */
  if (ttisinteger(&res)) {
    e1->k = VKINT;
    e1->u.ival = ivalue(&res);
  }
  else {  /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */
    lua_Number n = fltvalue(&res);
    if (luai_numisnan(n) || n == 0)
      return 0;
    e1->k = VKFLT;
    e1->u.nval = n;
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl 0x10(%rdx), %eax
xorl %ebx, %ebx
cmpl 0x14(%rdx), %eax
jne 0x166be
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl (%rdx), %eax
cmpl $0x6, %eax
je 0x16568
cmpl $0x5, %eax
jne 0x166be
movl $0x3, %eax
jmp 0x1656d
movl $0x13, %eax
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movl 0x10(%rcx), %eax
cmpl 0x14(%rcx), %eax
jne 0x166be
movl (%rcx), %eax
cmpl $0x6, %eax
je 0x165a0
cmpl $0x5, %eax
jne 0x166be
movl $0x3, %eax
jmp 0x165a5
movl $0x13, %eax
movsd 0x8(%rcx), %xmm0
movsd %xmm0, (%rsp)
movl %eax, 0x8(%rsp)
movl $0x1, %r12d
cmpl $0xd, %ebp
ja 0x1665f
movl $0x2f80, %eax           # imm = 0x2F80
btl %ebp, %eax
jae 0x165df
cmpl $0x13, 0x28(%rsp)
jne 0x165fb
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x16613
movl $0x68, %eax
btl %ebp, %eax
jae 0x1665f
cmpl $0x13, 0x8(%rsp)
movq (%rsp), %rax
je 0x16645
movq %rax, %xmm0
jmp 0x1664d
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
xorl %r12d, %r12d
xorl %edx, %edx
callq 0x10e26
testl %eax, %eax
je 0x1665f
cmpl $0x13, 0x8(%rsp)
jne 0x1662b
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x1, %r12d
jmp 0x1665f
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x10e26
xorl %r12d, %r12d
testl %eax, %eax
setne %r12b
jmp 0x1665f
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movq %xmm1, %r12
andl $0x1, %r12d
testl %r12d, %r12d
je 0x166be
movq 0x10(%r15), %rax
movq 0x38(%rax), %rdi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
leaq 0x10(%rsp), %r15
movl %ebp, %esi
movq %r15, %r8
callq 0xb519
cmpl $0x13, 0x8(%r15)
jne 0x1669c
movl $0x6, (%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%r14)
jmp 0x166b9
movsd 0x10(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
je 0x166be
movl $0x5, (%r14)
movsd %xmm0, 0x8(%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: codebinexpval
static void codebinexpval (FuncState *fs, OpCode op,
                           expdesc *e1, expdesc *e2, int line) {
  int rk1 = luaK_exp2RK(fs, e1);  /* both operands are "RK" */
  int rk2 = luaK_exp2RK(fs, e2);
  freeexps(fs, e1, e2);
  e1->u.info = luaK_codeABC(fs, op, 0, rk1, rk2);  /* generate opcode */
  e1->k = VRELOCABLE;  /* all those operations are relocatable */
  luaK_fixline(fs, line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, 0x4(%rsp)
movq %rcx, %r12
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rsi
callq 0x15f13
movl %eax, %r13d
movq %r14, %rdi
movq %r12, %rsi
callq 0x15f13
movl %eax, %ebx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x16c6e
shll $0x17, %r13d
orl %ebp, %r13d
shll $0xe, %ebx
orl %r13d, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x158de
movl %eax, 0x8(%r15)
movl $0xc, (%r15)
movq (%r14), %rax
movq 0x48(%rax), %rax
movslq 0x20(%r14), %rcx
movl 0x4(%rsp), %edx
movl %edx, -0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: luaK_setlist
void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;
  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
  lua_assert(tostore != 0 && tostore <= LFIELDS_PER_FLUSH);
  if (c <= MAXARG_C)
    luaK_codeABC(fs, OP_SETLIST, base, b, c);
  else if (c <= MAXARG_Ax) {
    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
    codeextraarg(fs, c);
  }
  else
    luaX_syntaxerror(fs->ls, "constructor too long");
  fs->freereg = base + 1;  /* free registers with list values */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rdx), %eax
cltq
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rsi
sarq $0x24, %rsi
shrq $0x3f, %rax
leal (%rsi,%rax), %ebp
incl %ebp
movl %ecx, %edi
shll $0x17, %edi
movl %ebx, %eax
shll $0x6, %eax
xorl %esi, %esi
cmpl $-0x1, %ecx
cmovnel %edi, %esi
cmpl $0x63ce, %edx           # imm = 0x63CE
jg 0x169d5
shll $0xe, %ebp
orl %eax, %esi
orl %ebp, %esi
orl $0x2b, %esi
jmp 0x169ec
orl %esi, %eax
orl $0x2b, %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x158de
shll $0x6, %ebp
orl $0x2e, %ebp
movl %ebp, %esi
movq %r14, %rdi
callq 0x158de
incb %bl
movb %bl, 0x3c(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: patchtestreg
static int patchtestreg (FuncState *fs, int node, int reg) {
  Instruction *i = getjumpcontrol(fs, node);
  if (GET_OPCODE(*i) != OP_TESTSET)
    return 0;  /* cannot patch other instructions */
  if (reg != NO_REG && reg != GETARG_B(*i))
    SETARG_A(*i, reg);
  else {
     /* no register to put value or register already has the value;
        change instruction to simple test */
    *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));
  }
  return 1;
}

// Assembly:
movq (%rdi), %rax
movslq %esi, %rsi
leaq (,%rsi,4), %rcx
addq 0x38(%rax), %rcx
testl %esi, %esi
jle 0x16a2c
movl -0x4(%rcx), %eax
andl $0x3f, %eax
leaq 0xae8e(%rip), %rsi      # 0x218b0
cmpb $0x0, (%rax,%rsi)
jns 0x16a2c
addq $-0x4, %rcx
movl (%rcx), %esi
movl %esi, %edi
andl $0x3f, %edi
xorl %eax, %eax
cmpl $0x23, %edi
jne 0x16a70
cmpl $0xff, %edx
je 0x16a59
movl %esi, %eax
shrl $0x17, %eax
cmpl %edx, %eax
je 0x16a59
andl $0xffffc023, %esi       # imm = 0xFFFFC023
movzbl %dl, %eax
shll $0x6, %eax
jmp 0x16a67
movl %esi, %eax
shrl $0x11, %eax
andl $-0x40, %eax
andl $0x7fc022, %esi         # imm = 0x7FC022
orl %eax, %esi
movl %esi, (%rcx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: discharge2reg
static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VNIL: {
      luaK_nil(fs, reg, 1);
      break;
    }
    case VFALSE: case VTRUE: {
      luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
      break;
    }
    case VK: {
      luaK_codek(fs, reg, e->u.info);
      break;
    }
    case VKFLT: {
      luaK_codek(fs, reg, luaK_numberK(fs, e->u.nval));
      break;
    }
    case VKINT: {
      luaK_codek(fs, reg, luaK_intK(fs, e->u.ival));
      break;
    }
    case VRELOCABLE: {
      Instruction *pc = &getinstruction(fs, e);
      SETARG_A(*pc, reg);  /* instruction will put result in 'reg' */
      break;
    }
    case VNONRELOC: {
      if (reg != e->u.info)
        luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0);
      break;
    }
    default: {
      lua_assert(e->k == VJMP);
      return;  /* nothing to do... */
    }
  }
  e->u.info = reg;
  e->k = VNONRELOC;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x15c92
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0xb, %ecx
ja 0x16b72
leaq 0xbad1(%rip), %rdx      # 0x2256c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %ebp, %ecx
shll $0x6, %ecx
cmpl $0x2, %eax
movl $0x800000, %eax         # imm = 0x800000
movl $0x2, %esi
cmovel %eax, %esi
orl %ecx, %esi
orl $0x3, %esi
movq %r14, %rdi
callq 0x158de
jmp 0x16b69
movq 0x8(%rbx), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movl $0x2, 0x8(%rsi)
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
movl $0x13, 0x8(%rdx)
movq %r14, %rdi
jmp 0x16b58
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x15614
jmp 0x16b69
movl 0x8(%rbx), %esi
cmpl %ebp, %esi
je 0x16b69
movl %ebp, %eax
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
jmp 0x16abe
movq (%r14), %rax
movq 0x38(%rax), %rax
movslq 0x8(%rbx), %rcx
movl $0xffffc03f, %edx       # imm = 0xFFFFC03F
andl (%rax,%rcx,4), %edx
movzbl %bpl, %esi
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax,%rcx,4)
jmp 0x16b69
movl 0x8(%rbx), %edx
movq %r14, %rdi
movl %ebp, %esi
jmp 0x16b64
movsd 0x8(%rbx), %xmm0
movq %rsp, %rdx
movsd %xmm0, (%rdx)
movl $0x3, 0x8(%rdx)
movq %r14, %rdi
movq %rdx, %rsi
callq 0x15a4f
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x15997
movl %ebp, 0x8(%rbx)
movl $0x7, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: need_value
static int need_value (FuncState *fs, int list) {
  for (; list != NO_JUMP; list = getjump(fs, list)) {
    Instruction i = *getjumpcontrol(fs, list);
    if (GET_OPCODE(i) != OP_TESTSET) return 1;
  }
  return 0;  /* not found */
}

// Assembly:
xorl %eax, %eax
cmpl $-0x1, %esi
je 0x16be1
movq (%rdi), %rcx
movq 0x38(%rcx), %rcx
leaq 0xad20(%rip), %rdx      # 0x218b0
movslq %esi, %r8
leaq (%rcx,%r8,4), %rdi
testl %r8d, %r8d
jle 0x16bab
movl -0x4(%rdi), %r8d
andl $0x3f, %r8d
cmpb $0x0, (%r8,%rdx)
js 0x16bb0
movq %rdi, %r8
jmp 0x16bb4
leaq -0x4(%rdi), %r8
movl (%r8), %r8d
andl $0x3f, %r8d
cmpl $0x23, %r8d
jne 0x16be2
movl (%rdi), %edi
shrl $0xe, %edi
leal -0x1ffff(%rdi), %r8d
cmpl $-0x1, %r8d
leal -0x1fffe(%rsi,%rdi), %esi
cmovel %r8d, %esi
cmpl $-0x1, %esi
jne 0x16b90
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lcode.c
// Function: freeexps
static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) {
  int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1;
  int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1;
  if (r1 > r2) {
    freereg(fs, r1);
    freereg(fs, r2);
  }
  else {
    freereg(fs, r2);
    freereg(fs, r1);
  }
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x7, (%rsi)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jne 0x16c80
movl 0x8(%rsi), %ecx
cmpl $0x7, (%rdx)
jne 0x16c88
movl 0x8(%rdx), %eax
cmpl %eax, %ecx
jle 0x16cac
btl $0x8, %ecx
jb 0x16c9d
movzbl 0x3a(%rdi), %edx
cmpl %edx, %ecx
jl 0x16c9d
decb 0x3c(%rdi)
btl $0x8, %eax
jb 0x16cab
movzbl 0x3a(%rdi), %ecx
cmpl %ecx, %eax
jge 0x16ccb
retq
btl $0x8, %eax
jb 0x16cbd
movzbl 0x3a(%rdi), %edx
cmpl %edx, %eax
jl 0x16cbd
decb 0x3c(%rdi)
btl $0x8, %ecx
jb 0x16cab
movzbl 0x3a(%rdi), %eax
cmpl %eax, %ecx
jl 0x16cab
decb 0x3c(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: luaX_init
void luaX_init (lua_State *L) {
  int i;
  TString *e = luaS_newliteral(L, LUA_ENV);  /* create env name */
  luaC_fix(L, obj2gco(e));  /* never collect this name */
  for (i=0; i<NUM_RESERVED; i++) {
    TString *ts = luaS_new(L, luaX_tokens[i]);
    luaC_fix(L, obj2gco(ts));  /* reserved words are never collected */
    ts->extra = cast_byte(i+1);  /* reserved word */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xa6a3(%rip), %rsi      # 0x21385
movl $0x4, %edx
callq 0xf2f1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9f16
movb $0x1, %bpl
xorl %r15d, %r15d
leaq 0x174ec(%rip), %r12     # 0x2e1f0
movq (%r15,%r12), %rsi
movq %rbx, %rdi
callq 0xf52a
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9f16
movb %bpl, 0xa(%r14)
addq $0x8, %r15
incb %bpl
cmpq $0xb0, %r15
jne 0x16d04
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: luaX_token2str
const char *luaX_token2str (LexState *ls, int token) {
  if (token < FIRST_RESERVED) {  /* single-byte symbols? */
    lua_assert(token == cast_uchar(token));
    return luaO_pushfstring(ls->L, "'%c'", token);
  }
  else {
    const char *s = luaX_tokens[token - FIRST_RESERVED];
    if (token < TK_EOS)  /* fixed format (symbols and reserved words)? */
      return luaO_pushfstring(ls->L, "'%s'", s);
    else  /* names, strings, and numerals */
      return s;
  }
}

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
movq 0x40(%rdi), %rdi
subq $0x1, (%rdi)
jae 0x1798a
callq 0x13ad0
jmp 0x17999
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
cmpl $0xd, %eax
je 0x179a5
cmpl $0xa, %eax
jne 0x179cb
cmpl %ebp, %eax
je 0x179cb
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x179ba
callq 0x13ad0
jmp 0x179c9
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
movl 0x4(%rbx), %eax
incl %eax
movl %eax, 0x4(%rbx)
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x179e1
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xaf0a(%rip), %rsi      # 0x228f2
movq %rbx, %rdi
xorl %edx, %edx
callq 0x16d8f
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: skip_sep
static int skip_sep (LexState *ls) {
  int count = 0;
  int s = ls->current;
  lua_assert(s == '[' || s == ']');
  save_and_next(ls);
  while (ls->current == '=') {
    save_and_next(ls);
    count++;
  }
  return (ls->current == s) ? count : (-count) - 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl (%rdi), %ebx
movl %ebx, %esi
callq 0x17907
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x17a13
callq 0x13ad0
jmp 0x17a22
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
xorl %ebp, %ebp
cmpl $0x3d, %eax
jne 0x17a65
xorl %ebp, %ebp
movq %r14, %rdi
movl $0x3d, %esi
callq 0x17907
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x17a4c
callq 0x13ad0
jmp 0x17a5b
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
incl %ebp
cmpl $0x3d, %eax
je 0x17a2e
xorl %ecx, %ecx
cmpl %ebx, %eax
setne %cl
negl %ecx
xorl %ebp, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: check_next1
static int check_next1 (LexState *ls, int c) {
  if (ls->current == c) {
    next(ls);
    return 1;
  }
  else return 0;
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ebp
movl %ebp, %esi
callq 0x17907
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x17c4b
callq 0x13ad0
jmp 0x17c5a
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
cmpl $0x30, %ebp
jne 0x17c87
leaq 0xad62(%rip), %rsi      # 0x229cb
movq %r14, %rdi
callq 0x17dfc
testl %eax, %eax
leaq 0xad4e(%rip), %rax      # 0x229c8
leaq 0xad4d(%rip), %r15      # 0x229ce
cmoveq %rax, %r15
jmp 0x17c8e
leaq 0xad3a(%rip), %r15      # 0x229c8
leaq 0xa96b(%rip), %r13      # 0x22600
leaq 0xad35(%rip), %r12      # 0x229d1
movq %r14, %rdi
movq %r15, %rsi
callq 0x17dfc
testl %eax, %eax
je 0x17cb6
movq %r14, %rdi
movq %r12, %rsi
callq 0x17dfc
movslq (%r14), %rsi
testb $0x10, 0x1(%rsi,%r13)
jne 0x17cd0
movq %r14, %rdi
cmpl $0x2e, %esi
jne 0x17cfd
movl $0x2e, %esi
jmp 0x17cd3
movq %r14, %rdi
callq 0x17907
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x17ce9
callq 0x13ad0
jmp 0x17cf8
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
jmp 0x17c9c
xorl %esi, %esi
callq 0x17907
movq 0x48(%r14), %rax
movq (%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb811
testq %rax, %rax
je 0x17d42
xorl %eax, %eax
cmpl $0x13, 0x10(%rsp)
sete %al
movsd 0x8(%rsp), %xmm0
orl $0x122, %eax            # imm = 0x122
movsd %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xac8b(%rip), %rsi      # 0x229d4
movq %r14, %rdi
movl $0x122, %edx            # imm = 0x122
callq 0x16d8f
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/llex.c
// Function: esccheck
static void esccheck (LexState *ls, int c, const char *msg) {
  if (!c) {
    if (ls->current != EOZ)
      save_and_next(ls);  /* add current to buffer for error message */
    lexerror(ls, msg, TK_STRING);
  }
}

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

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movl (%rdi), %esi
movsbl (%rax), %ecx
cmpl %ecx, %esi
je 0x17e16
movsbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %esi
jne 0x17e45
movq %rbx, %rdi
callq 0x17907
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x17e2f
callq 0x13ad0
jmp 0x17e3e
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
movl $0x1, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaopen_base
LUAMOD_API int luaopen_base (lua_State *L) {
  /* open lib into global table */
  lua_pushglobaltable(L);
  luaL_setfuncs(L, base_funcs, 0);
  /* set global _G */
  lua_pushvalue(L, -1);
  lua_setfield(L, -2, "_G");
  /* set global _VERSION */
  lua_pushliteral(L, LUA_VERSION);
  lua_setfield(L, -2, "_VERSION");
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, %edx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x684b
leaq 0x164be(%rip), %rsi     # 0x2e320
movq %rbx, %rdi
xorl %edx, %edx
callq 0x150f3
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5f5b
leaq 0xa616(%rip), %rdx      # 0x22496
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
leaq 0xab5c(%rip), %rsi      # 0x229f0
movq %rbx, %rdi
callq 0x645b
leaq 0xab55(%rip), %rdx      # 0x229f8
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_assert
static int luaB_assert (lua_State *L) {
  if (lua_toboolean(L, 1))  /* condition is true? */
    return lua_gettop(L);  /* return all arguments */
  else {  /* error */
    luaL_checkany(L, 1);  /* there must be a condition */
    lua_remove(L, 1);  /* remove it */
    lua_pushliteral(L, "assertion failed!");  /* default message */
    lua_settop(L, 1);  /* leave only message (default if no other one) */
    return luaB_error(L);  /* call 'error' */
  }
}

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xab76(%rip), %rdx      # 0x22aa7
leaq 0x16578(%rip), %rcx     # 0x2e4b0
movl $0x1, %esi
callq 0x1444b
cltq
leaq 0xac95(%rip), %rcx      # 0x22be0
movl (%rcx,%rax,4), %ebp
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x146c5
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x706d
movl %eax, %r14d
cmpl $0x9, %ebp
je 0x17fa9
cmpl $0x5, %ebp
je 0x17fa9
cmpl $0x3, %ebp
jne 0x17fb6
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x706d
cvtsi2sd %r14d, %xmm1
cvtsi2sd %eax, %xmm0
mulsd 0xaa4d(%rip), %xmm0     # 0x229e8
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x63d1
jmp 0x17fc1
movq %rbx, %rdi
movl %r14d, %esi
callq 0x660e
jmp 0x17fc1
movslq %r14d, %rsi
movq %rbx, %rdi
callq 0x63e6
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_dofile
static int luaB_dofile (lua_State *L) {
  const char *fname = luaL_optstring(L, 1, NULL);
  lua_settop(L, 1);
  if (luaL_loadfile(L, fname) != LUA_OK)
    return lua_error(L);
  lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);
  return dofilecont(L, 0, 0);
}

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

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x145a3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6935
testl %eax, %eax
je 0x180e9
leaq 0xa9fe(%rip), %rdx      # 0x22ad8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14eb2
jmp 0x180f1
movq %rbx, %rdi
callq 0x63bd
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_ipairs
static int luaB_ipairs (lua_State *L) {
#if defined(LUA_COMPAT_IPAIRS)
  return pairsmeta(L, "__ipairs", 1, ipairsaux);
#else
  luaL_checkany(L, 1);
  lua_pushcfunction(L, ipairsaux);  /* iteration function */
  lua_pushvalue(L, 1);  /* state */
  lua_pushinteger(L, 0);  /* initial value */
  return 3;
#endif
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdx
movl $0x1, %esi
callq 0x6249
movq %rax, %r15
leaq 0xa923(%rip), %rdx      # 0x22ae4
movq %rbx, %rdi
movl $0x3, %esi
xorl %ecx, %ecx
callq 0x144dc
movq %rax, %r14
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5f7f
movl %eax, %ebp
testq %r15, %r15
je 0x18210
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x144dc
movq (%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rcx
movq %r14, %r8
callq 0x14e35
jmp 0x1825f
leaq 0xa8d0(%rip), %rdx      # 0x22ae7
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x144dc
movq %rax, %r15
movq %rbx, %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x1456f
movq %rbx, %rdi
movl $0x5, %esi
callq 0x5d51
leaq 0x856(%rip), %rsi       # 0x18aa5
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %rcx
movq %r14, %r8
callq 0x6f8e
xorl %edx, %edx
cmpl $-0x1, %ebp
setne %dl
shll $0x2, %edx
movq %rbx, %rdi
movl %eax, %esi
callq 0x18a33
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq