LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_exp2RK
int luaK_exp2RK (FuncState *fs, expdesc *e) {
  luaK_exp2val(fs, e);
  switch (e->k) {
    case VTRUE:
    case VFALSE:
    case VNIL: {
      if (fs->nk <= MAXINDEXRK) {  /* constant fits in RK operand? */
        e->u.info = (e->k == VNIL) ? nilK(fs) : boolK(fs, (e->k == VTRUE));
        e->k = VK;
        return RKASK(e->u.info);
      }
      else break;
    }
    case VKNUM: {
      e->u.info = luaK_numberK(fs, e->u.nval);
      e->k = VK;
      /* go through */
    }
    case 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2f300
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
decl %eax
subl $0x3, %eax
jb 0x2f39e
jmp 0x2f381
movl 0xc(%rsp), %eax
subl $0x4, %eax
je 0x2f439
jmp 0x2f390
movl 0xc(%rsp), %eax
subl $0x5, %eax
je 0x2f410
jmp 0x2f45c
movq 0x18(%rsp), %rax
cmpl $0xff, 0x34(%rax)
jg 0x2f40e
movq 0x10(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x2f3c6
movq 0x18(%rsp), %rdi
callq 0x2f480
movl %eax, 0x8(%rsp)
jmp 0x2f3e4
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
cmpl $0x2, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x2f4e0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0x4, (%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x24(%rsp)
jmp 0x2f471
jmp 0x2f45e
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
callq 0x2ebd0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0x4, (%rax)
movq 0x10(%rsp), %rax
cmpl $0xff, 0x8(%rax)
jg 0x2f45a
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, 0x24(%rsp)
jmp 0x2f471
jmp 0x2f45e
jmp 0x2f45e
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2f220
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: nilK
static int nilK (FuncState *fs) {
  TValue k, v;
  setnilvalue(&v);
  /* cannot use nil as key; instead use table itself to represent nil */
  sethvalue(fs->ls->L, &k, fs->h);
  return addk(fs, &k, &v);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x0, 0x18(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x45, 0x8(%rax)
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x2e980
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/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;
  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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2f220
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2f060
movq 0x30(%rsp), %rax
movzbl 0x44(%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movl $0x6, (%rax)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x2e8e0
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2f350
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %edx
movl 0x18(%rsp), %ecx
movl %eax, %r8d
movl $0xc, %esi
callq 0x2e250
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2f060
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_goiftrue
void luaK_goiftrue (FuncState *fs, expdesc *e) {
  int pc;  /* pc of last jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VJMP: {
      invertjump(fs, e);
      pc = e->u.info;
      break;
    }
    case VK: case VKNUM: case VTRUE: {
      pc = NO_JUMP;  /* always true; do nothing */
      break;
    }
    default: {
      pc = jumponcond(fs, e, 0);
      break;
    }
  }
  luaK_concat(fs, &e->f, pc);  /* insert last jump in `f' list */
  luaK_patchtohere(fs, e->t);
  e->t = NO_JUMP;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2eea0
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rsp)
subl $0x2, %eax
je 0x2f772
jmp 0x2f73e
movl (%rsp), %eax
addl $-0x4, %eax
subl $0x2, %eax
jb 0x2f772
jmp 0x2f74b
movl (%rsp), %eax
subl $0xa, %eax
jne 0x2f77c
jmp 0x2f755
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2f7d0
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x2f791
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x2f791
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x2f830
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x14, %rsi
movl 0x4(%rsp), %edx
callq 0x2e340
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x2e470
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: jumponcond
static int jumponcond (FuncState *fs, expdesc *e, int cond) {
  if (e->k == VRELOCABLE) {
    Instruction ie = getcode(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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpl $0xb, (%rax)
jne 0x2f8bb
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
shrl $0x0, %eax
andl $0x3f, %eax
cmpl $0x14, %eax
jne 0x2f8b9
movq 0x18(%rsp), %rax
movl 0x28(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x28(%rax)
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %edx
shrl $0x17, %edx
andl $0x1ff, %edx            # imm = 0x1FF
cmpl $0x0, 0xc(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %r8d
movl $0x1b, %esi
xorl %ecx, %ecx
callq 0x30640
movl %eax, 0x24(%rsp)
jmp 0x2f8fe
jmp 0x2f8bb
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x30690
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2f060
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
movl 0xc(%rsp), %r8d
movl $0x1c, %esi
movl $0xff, %edx
callq 0x30640
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_goiffalse
void luaK_goiffalse (FuncState *fs, expdesc *e) {
  int pc;  /* pc of last jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VJMP: {
      pc = e->u.info;
      break;
    }
    case VNIL: case VFALSE: {
      pc = NO_JUMP;  /* always false; do nothing */
      break;
    }
    default: {
      pc = jumponcond(fs, e, 1);
      break;
    }
  }
  luaK_concat(fs, &e->t, pc);  /* insert last jump in `t' list */
  luaK_patchtohere(fs, e->f);
  e->f = NO_JUMP;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2eea0
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rsp)
subl $0x1, %eax
je 0x2f960
jmp 0x2f93e
movl (%rsp), %eax
subl $0x3, %eax
je 0x2f960
jmp 0x2f948
movl (%rsp), %eax
subl $0xa, %eax
jne 0x2f96a
jmp 0x2f952
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0x2f982
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x2f982
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x2f830
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
movl 0x4(%rsp), %edx
callq 0x2e340
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x14(%rax), %esi
callq 0x2e470
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_indexed
void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
  lua_assert(!hasjumps(t));
  t->u.ind.t = t->u.info;
  t->u.ind.idx = luaK_exp2RK(fs, k);
  t->u.ind.vt = (t->k == VUPVAL) ? VUPVAL
                                 : check_exp(vkisinreg(t->k), VLOCAL);
  t->k = VINDEXED;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0xa(%rax)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x2f350
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl (%rax), %edx
movl $0x7, %eax
movl $0x8, %ecx
cmpl $0x8, %edx
cmovel %ecx, %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, 0xb(%rax)
movq 0x8(%rsp), %rax
movl $0x9, (%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_prefix
void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) {
  expdesc e2;
  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
  switch (op) {
    case OPR_MINUS: {
      if (isnumeral(e))  /* minus constant? */
        e->u.nval = luai_numunm(NULL, e->u.nval);  /* fold it */
      else {
        luaK_exp2anyreg(fs, e);
        codearith(fs, OP_UNM, e, &e2, line);
      }
      break;
    }
    case OPR_NOT: codenot(fs, e); break;
    case OPR_LEN: {
      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
      codearith(fs, OP_LEN, e, &e2, line);
      break;
    }
    default: lua_assert(0);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
movl $0x5, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x2fa92
jmp 0x2fa75
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x2fafd
jmp 0x2fa80
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x2fb0e
jmp 0x2fb3d
movq 0x30(%rsp), %rdi
callq 0x2fb50
cmpl $0x0, %eax
je 0x2face
movq 0x30(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x2fafb
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2f220
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rdx
movl 0x2c(%rsp), %r8d
movl $0x13, %esi
leaq 0x10(%rsp), %rcx
callq 0x2fb90
jmp 0x2fb3f
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2fca0
jmp 0x2fb3f
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2f220
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rdx
movl 0x2c(%rsp), %r8d
movl $0x15, %esi
leaq 0x10(%rsp), %rcx
callq 0x2fb90
jmp 0x2fb3f
jmp 0x2fb3f
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: codearith
static void codearith (FuncState *fs, OpCode op,
                       expdesc *e1, expdesc *e2, int line) {
  if (constfolding(op, e1, e2))
    return;
  else {
    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
    int o1 = luaK_exp2RK(fs, e1);
    if (o1 > o2) {
      freeexp(fs, e1);
      freeexp(fs, e2);
    }
    else {
      freeexp(fs, e2);
      freeexp(fs, e1);
    }
    e1->u.info = luaK_codeABC(fs, op, 0, o1, o2);
    e1->k = VRELOCABLE;
    luaK_fixline(fs, line);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl 0x2c(%rsp), %edi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x306e0
cmpl $0x0, %eax
je 0x2fbc9
jmp 0x2fc93
cmpl $0x13, 0x2c(%rsp)
je 0x2fbec
cmpl $0x15, 0x2c(%rsp)
je 0x2fbec
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2f350
movl %eax, 0x8(%rsp)
jmp 0x2fbf4
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x2fbf4
movl 0x8(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2f350
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jle 0x2fc39
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2f060
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2f060
jmp 0x2fc57
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2f060
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2f060
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0xc(%rsp), %ecx
movl 0x10(%rsp), %r8d
xorl %edx, %edx
callq 0x2e250
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rax
movl $0xb, (%rax)
movq 0x30(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x30170
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: codenot
static void codenot (FuncState *fs, expdesc *e) {
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VNIL: case VFALSE: {
      e->k = VTRUE;
      break;
    }
    case VK: case VKNUM: case VTRUE: {
      e->k = VFALSE;
      break;
    }
    case VJMP: {
      invertjump(fs, e);
      break;
    }
    case VRELOCABLE:
    case VNONRELOC: {
      discharge2anyreg(fs, e);
      freeexp(fs, e);
      e->u.info = luaK_codeABC(fs, OP_NOT, 0, e->u.info, 0);
      e->k = VRELOCABLE;
      break;
    }
    default: {
      lua_assert(0);  /* cannot happen */
      break;
    }
  }
  /* interchange true and false lists */
  { int temp = e->f; e->f = e->t; e->t = temp; }
  removevalues(fs, e->f);
  removevalues(fs, e->t);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2eea0
movq 0x18(%rsp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0xa, %eax
ja 0x2fd68
movq 0x8(%rsp), %rax
leaq 0x7882(%rip), %rcx      # 0x37564
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rax
movl $0x2, (%rax)
jmp 0x2fd6a
movq 0x18(%rsp), %rax
movl $0x3, (%rax)
jmp 0x2fd6a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2f7d0
jmp 0x2fd6a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x30690
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2f060
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
movl $0x14, %esi
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x2e250
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl $0xb, (%rax)
jmp 0x2fd6a
jmp 0x2fd6a
movq 0x18(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x14(%rax)
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x14(%rax), %esi
callq 0x307a0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl 0x10(%rax), %esi
callq 0x307a0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_infix
void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
  switch (op) {
    case OPR_AND: {
      luaK_goiftrue(fs, v);
      break;
    }
    case OPR_OR: {
      luaK_goiffalse(fs, v);
      break;
    }
    case OPR_CONCAT: {
      luaK_exp2nextreg(fs, v);  /* operand must be on the `stack' */
      break;
    }
    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
    case OPR_MOD: case OPR_POW: {
      if (!isnumeral(v)) luaK_exp2RK(fs, v);
      break;
    }
    default: {
      luaK_exp2RK(fs, v);
      break;
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0xe, %rax
ja 0x2fe49
movq 0x8(%rsp), %rax
leaq 0x77a3(%rip), %rcx      # 0x37590
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2f710
jmp 0x2fe58
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2f910
jmp 0x2fe58
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2f000
jmp 0x2fe58
movq 0x10(%rsp), %rdi
callq 0x2fb50
cmpl $0x0, %eax
jne 0x2fe47
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2f350
jmp 0x2fe58
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2f350
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: codecomp
static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1,
                                                          expdesc *e2) {
  int o1 = luaK_exp2RK(fs, e1);
  int o2 = luaK_exp2RK(fs, e2);
  freeexp(fs, e2);
  freeexp(fs, e1);
  if (cond == 0 && op != OP_EQ) {
    int temp;  /* exchange args to replace by `<' or `<=' */
    temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */
    cond = 1;
  }
  e1->u.info = condjump(fs, op, cond, o1, o2);
  e1->k = VJMP;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2f350
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2f350
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2f060
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2f060
cmpl $0x0, 0x28(%rsp)
jne 0x3012d
cmpl $0x18, 0x2c(%rsp)
je 0x3012d
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
movl $0x1, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %r8d
callq 0x30640
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rax
movl $0xa, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/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 VKNUM: {
      luaK_codek(fs, reg, luaK_numberK(fs, e->u.nval));
      break;
    }
    case VRELOCABLE: {
      Instruction *pc = &getcode(fs, e);
      SETARG_A(*pc, 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 == VVOID || e->k == VJMP);
      return;  /* nothing to do... */
    }
  }
  e->u.info = reg;
  e->k = VNONRELOC;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2eea0
movq 0x28(%rsp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0xa, %eax
ja 0x30564
movq 0x10(%rsp), %rax
leaq 0x71b2(%rip), %rcx      # 0x37608
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
movl $0x1, %edx
callq 0x2e0e0
jmp 0x30566
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %edx
movq 0x28(%rsp), %rax
cmpl $0x2, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %ecx
movl $0x3, %esi
xorl %r8d, %r8d
callq 0x2e250
jmp 0x30566
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x28(%rsp), %rax
movl 0x8(%rax), %edx
callq 0x2e7d0
jmp 0x30566
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movsd 0x8(%rax), %xmm0
callq 0x2ebd0
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl %eax, %edx
callq 0x2e7d0
jmp 0x30566
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq 0x28(%rsp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %ecx
andl $0xffffc03f, %ecx       # imm = 0xFFFFC03F
movl 0x24(%rsp), %eax
shll $0x6, %eax
andl $0x3fc0, %eax           # imm = 0x3FC0
orl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x30566
movl 0x24(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0x30562
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %edx
movq 0x28(%rsp), %rax
movl 0x8(%rax), %ecx
xorl %r8d, %r8d
movl %r8d, %esi
callq 0x2e250
jmp 0x30566
jmp 0x3057d
movl 0x24(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movl $0x6, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: constfolding
static int constfolding (OpCode op, expdesc *e1, expdesc *e2) {
  lua_Number r;
  if (!isnumeral(e1) || !isnumeral(e2)) return 0;
  if ((op == OP_DIV || op == OP_MOD) && e2->u.nval == 0)
    return 0;  /* do not attempt to divide by 0 */
  r = luaO_arith(op - OP_ADD + LUA_OPADD, e1->u.nval, e2->u.nval);
  e1->u.nval = r;
  return 1;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2fb50
cmpl $0x0, %eax
je 0x30710
movq 0x10(%rsp), %rdi
callq 0x2fb50
cmpl $0x0, %eax
jne 0x3071a
movl $0x0, 0x24(%rsp)
jmp 0x30788
cmpl $0x10, 0x20(%rsp)
je 0x30728
cmpl $0x11, 0x20(%rsp)
jne 0x30747
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x30747
jp 0x30747
movl $0x0, 0x24(%rsp)
jmp 0x30788
movl 0x20(%rsp), %edi
subl $0xd, %edi
addl $0x0, %edi
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm1
callq 0x196e0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcorolib.c
// Function: luaB_coresume
static int luaB_coresume (lua_State *L) {
  lua_State *co = lua_tothread(L, 1);
  int r;
  luaL_argcheck(L, co, 1, "coroutine expected");
  r = auxresume(L, co, lua_gettop(L) - 1);
  if (r < 0) {
    lua_pushboolean(L, 0);
    lua_insert(L, -2);
    return 2;  /* return false + error message */
  }
  else {
    lua_pushboolean(L, 1);
    lua_insert(L, -(r + 1));
    return r + 1;  /* return true + `resume' returns */
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x9ce0
movq %rax, 0x20(%rsp)
movb $0x1, %al
cmpq $0x0, 0x20(%rsp)
movb %al, 0x1b(%rsp)
jne 0x308bb
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x6e06(%rip), %rdx      # 0x376b2
callq 0xc3a0
cmpl $0x0, %eax
setne %al
movb %al, 0x1b(%rsp)
movb 0x1b(%rsp), %al
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x8e20
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %eax, %edx
subl $0x1, %edx
callq 0x30b80
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jge 0x30921
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0xa330
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x90d0
movl $0x2, 0x34(%rsp)
jmp 0x30950
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0xa330
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %eax
addl $0x1, %eax
xorl %esi, %esi
subl %eax, %esi
callq 0x90d0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcorolib.c
// Function: luaB_costatus
static int luaB_costatus (lua_State *L) {
  lua_State *co = lua_tothread(L, 1);
  luaL_argcheck(L, co, 1, "coroutine expected");
  if (L == co) lua_pushliteral(L, "running");
  else {
    switch (lua_status(co)) {
      case LUA_YIELD:
        lua_pushliteral(L, "suspended");
        break;
      case LUA_OK: {
        lua_Debug ar;
        if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
          lua_pushliteral(L, "normal");  /* it is running */
        else if (lua_gettop(co) == 0)
            lua_pushliteral(L, "dead");
        else
          lua_pushliteral(L, "suspended");  /* initial state */
        break;
      }
      default:  /* some error occurred */
        lua_pushliteral(L, "dead");
        break;
    }
  }
  return 1;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rdi
movl $0x1, %esi
callq 0x9ce0
movq %rax, 0x88(%rsp)
movb $0x1, %al
cmpq $0x0, 0x88(%rsp)
movb %al, 0x7(%rsp)
jne 0x309ed
movq 0x90(%rsp), %rdi
movl $0x1, %esi
leaq 0x6cd4(%rip), %rdx      # 0x376b2
callq 0xc3a0
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
movq 0x90(%rsp), %rax
cmpq 0x88(%rsp), %rax
jne 0x30a21
movq 0x90(%rsp), %rdi
leaq 0x692d(%rip), %rsi      # 0x3733f
movl $0x7, %edx
callq 0x9f40
jmp 0x30afe
movq 0x88(%rsp), %rdi
callq 0xb5d0
movl %eax, %ecx
movl %ecx, (%rsp)
testl %eax, %eax
je 0x30a65
jmp 0x30a39
movl (%rsp), %eax
subl $0x1, %eax
jne 0x30ae3
jmp 0x30a47
movq 0x90(%rsp), %rdi
leaq 0x6ca7(%rip), %rsi      # 0x376fd
movl $0x9, %edx
callq 0x9f40
jmp 0x30afc
movq 0x88(%rsp), %rdi
xorl %esi, %esi
leaq 0x8(%rsp), %rdx
callq 0xe5a0
cmpl $0x0, %eax
jle 0x30a99
movq 0x90(%rsp), %rdi
leaq 0x6c7a(%rip), %rsi      # 0x37707
movl $0x6, %edx
callq 0x9f40
jmp 0x30ae1
movq 0x88(%rsp), %rdi
callq 0x8e20
cmpl $0x0, %eax
jne 0x30ac6
movq 0x90(%rsp), %rdi
leaq 0x6c54(%rip), %rsi      # 0x3770e
movl $0x4, %edx
callq 0x9f40
jmp 0x30adf
movq 0x90(%rsp), %rdi
leaq 0x6c28(%rip), %rsi      # 0x376fd
movl $0x9, %edx
callq 0x9f40
jmp 0x30ae1
jmp 0x30afc
movq 0x90(%rsp), %rdi
leaq 0x6c1c(%rip), %rsi      # 0x3770e
movl $0x4, %edx
callq 0x9f40
jmp 0x30afe
movl $0x1, %eax
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcorolib.c
// Function: luaB_auxwrap
static int luaB_auxwrap (lua_State *L) {
  lua_State *co = lua_tothread(L, lua_upvalueindex(1));
  int r = auxresume(L, co, lua_gettop(L));
  if (r < 0) {
    if (lua_isstring(L, -1)) {  /* error object is a string? */
      luaL_where(L, 1);  /* add extra info */
      lua_insert(L, -2);
      lua_concat(L, 2);
    }
    return lua_error(L);  /* propagate error */
  }
  return r;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x9ce0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x8e20
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl %eax, %edx
callq 0x30b80
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jge 0x30d88
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9480
cmpl $0x0, %eax
je 0x30d78
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0xc6c0
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x90d0
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0xb880
movq 0x28(%rsp), %rdi
callq 0xb7f0
movl %eax, 0x34(%rsp)
jmp 0x30d90
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldblib.c
// Function: db_gethook
static int db_gethook (lua_State *L) {
  int arg;
  lua_State *L1 = getthread(L, &arg);
  char buff[5];
  int mask = lua_gethookmask(L1);
  lua_Hook hook = lua_gethook(L1);
  if (hook != NULL && hook != hookf)  /* external hook? */
    lua_pushliteral(L, "external hook");
  else {
    gethooktable(L);
    lua_pushthread(L1); lua_xmove(L1, L, 1);
    lua_rawget(L, -2);   /* get hook */
    lua_remove(L, -2);  /* remove hook table */
  }
  lua_pushstring(L, unmakemask(mask, buff));
  lua_pushinteger(L, lua_gethookcount(L1));
  return 3;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x31c90
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0xe580
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
callq 0xe570
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x30fc8
leaq 0xd47(%rip), %rax       # 0x31cf0
cmpq %rax, 0x18(%rsp)
je 0x30fc8
movq 0x40(%rsp), %rdi
leaq 0x690e(%rip), %rsi      # 0x378ca
movl $0xd, %edx
callq 0x9f40
jmp 0x3101a
movq 0x40(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x68ff(%rip), %rdx      # 0x378d8
callq 0xdf60
movq 0x30(%rsp), %rdi
callq 0xa3d0
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl $0x1, %edx
callq 0x8c80
movq 0x40(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xa5e0
movq 0x40(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8f00
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %edi
leaq 0x2b(%rsp), %rsi
callq 0x31db0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x9fe0
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0xe590
movq 0x10(%rsp), %rdi
movslq %eax, %rsi
callq 0x9e70
movl $0x3, %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldblib.c
// Function: db_getlocal
static int db_getlocal (lua_State *L) {
  int arg;
  lua_State *L1 = getthread(L, &arg);
  lua_Debug ar;
  const char *name;
  int nvar = luaL_checkint(L, arg+2);  /* local-variable index */
  if (lua_isfunction(L, arg + 1)) {  /* function argument? */
    lua_pushvalue(L, arg + 1);  /* push function */
    lua_pushstring(L, lua_getlocal(L, NULL, nvar));  /* push local name */
    return 1;
  }
  else {  /* stack-level argument */
    if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
      return luaL_argerror(L, arg+1, "level out of range");
    name = lua_getlocal(L1, &ar, nvar);
    if (name) {
      lua_xmove(L1, L, 1);  /* push local value */
      lua_pushstring(L, name);  /* push name */
      lua_pushvalue(L, -2);  /* re-order */
      return 2;
    }
    else {
      lua_pushnil(L);  /* no name (nor value) */
      return 1;
    }
  }
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
leaq 0xb4(%rsp), %rsi
callq 0x31c90
movq %rax, 0xa8(%rsp)
movq 0xb8(%rsp), %rdi
movl 0xb4(%rsp), %esi
addl $0x2, %esi
callq 0xcf40
movl %eax, 0x1c(%rsp)
movq 0xb8(%rsp), %rdi
movl 0xb4(%rsp), %esi
addl $0x1, %esi
callq 0x9350
cmpl $0x6, %eax
jne 0x314f9
movq 0xb8(%rsp), %rdi
movl 0xb4(%rsp), %esi
addl $0x1, %esi
callq 0x92e0
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xb8(%rsp), %rdi
movl 0x1c(%rsp), %edx
xorl %eax, %eax
movl %eax, %esi
callq 0xe670
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x9fe0
movl $0x1, 0xc4(%rsp)
jmp 0x315e3
movq 0xa8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xb8(%rsp), %rdi
movl 0xb4(%rsp), %esi
addl $0x1, %esi
callq 0xcf40
movq 0x8(%rsp), %rdi
movl %eax, %esi
leaq 0x28(%rsp), %rdx
callq 0xe5a0
cmpl $0x0, %eax
jne 0x3155d
movq 0xb8(%rsp), %rdi
movl 0xb4(%rsp), %esi
addl $0x1, %esi
leaq 0x6431(%rip), %rdx      # 0x3797d
callq 0xc3a0
movl %eax, 0xc4(%rsp)
jmp 0x315e3
movq 0xa8(%rsp), %rdi
movl 0x1c(%rsp), %edx
leaq 0x28(%rsp), %rsi
callq 0xe670
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x315cb
movq 0xa8(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movl $0x1, %edx
callq 0x8c80
movq 0xb8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x9fe0
movq 0xb8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x92e0
movl $0x2, 0xc4(%rsp)
jmp 0x315e3
movq 0xb8(%rsp), %rdi
callq 0x9df0
movl $0x1, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldblib.c
// Function: db_setuservalue
static int db_setuservalue (lua_State *L) {
  if (lua_type(L, 1) == LUA_TLIGHTUSERDATA)
    luaL_argerror(L, 1, "full userdata expected, got light userdata");
  luaL_checktype(L, 1, LUA_TUSERDATA);
  if (!lua_isnoneornil(L, 2))
    luaL_checktype(L, 2, LUA_TTABLE);
  lua_settop(L, 2);
  lua_setuservalue(L, 1);
  return 1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x9350
cmpl $0x2, %eax
jne 0x317ed
movq (%rsp), %rdi
movl $0x1, %esi
leaq 0x61d7(%rip), %rdx      # 0x379bf
callq 0xc3a0
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x7, %edx
callq 0xcdc0
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x9350
cmpl $0x0, %eax
jle 0x31826
movq (%rsp), %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0xcdc0
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x8e50
movq (%rsp), %rdi
movl $0x1, %esi
callq 0xafc0
movl $0x1, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldblib.c
// Function: db_sethook
static int db_sethook (lua_State *L) {
  int arg, mask, count;
  lua_Hook func;
  lua_State *L1 = getthread(L, &arg);
  if (lua_isnoneornil(L, arg+1)) {
    lua_settop(L, arg+1);
    func = NULL; mask = 0; count = 0;  /* turn off hooks */
  }
  else {
    const char *smask = luaL_checkstring(L, arg+2);
    luaL_checktype(L, arg+1, LUA_TFUNCTION);
    count = luaL_optint(L, arg+3, 0);
    func = hookf; mask = makemask(smask, count);
  }
  if (gethooktable(L) == 0) {  /* creating hook table? */
    lua_pushstring(L, "k");
    lua_setfield(L, -2, "__mode");  /** hooktable.__mode = "k" */
    lua_pushvalue(L, -1);
    lua_setmetatable(L, -2);  /* setmetatable(hooktable) = hooktable */
  }
  lua_pushthread(L1); lua_xmove(L1, L, 1);
  lua_pushvalue(L, arg+1);
  lua_rawset(L, -3);  /* set new hook */
  lua_sethook(L1, func, mask, count);  /* set hooks */
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x31c90
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
addl $0x1, %esi
callq 0x9350
cmpl $0x0, %eax
jg 0x318af
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
addl $0x1, %esi
callq 0x8e50
movq $0x0, 0x18(%rsp)
movl $0x0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
jmp 0x31916
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
addl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xcd00
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
addl $0x1, %esi
movl $0x6, %edx
callq 0xcdc0
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
addl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xcfe0
movl %eax, 0x24(%rsp)
leaq 0x3f1(%rip), %rax       # 0x31cf0
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x32120
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x5fb1(%rip), %rdx      # 0x378d8
callq 0xdf60
cmpl $0x0, %eax
jne 0x31976
movq 0x30(%rsp), %rdi
leaq 0x4e28(%rip), %rsi      # 0x36765
callq 0x9fe0
movq 0x30(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x560a(%rip), %rdx      # 0x36f5d
callq 0xaad0
movq 0x30(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x92e0
movq 0x30(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xae30
movq 0x10(%rsp), %rdi
callq 0xa3d0
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl $0x1, %edx
callq 0x8c80
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
addl $0x1, %esi
callq 0x92e0
movq 0x30(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0xab90
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x28(%rsp), %edx
movl 0x24(%rsp), %ecx
callq 0xe4d0
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldblib.c
// Function: db_setlocal
static int db_setlocal (lua_State *L) {
  int arg;
  lua_State *L1 = getthread(L, &arg);
  lua_Debug ar;
  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
    return luaL_argerror(L, arg+1, "level out of range");
  luaL_checkany(L, arg+3);
  lua_settop(L, arg+3);
  lua_xmove(L, L1, 1);
  lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2)));
  return 1;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
leaq 0xa4(%rsp), %rsi
callq 0x31c90
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xa8(%rsp), %rdi
movl 0xa4(%rsp), %esi
addl $0x1, %esi
callq 0xcf40
movq 0x10(%rsp), %rdi
movl %eax, %esi
leaq 0x18(%rsp), %rdx
callq 0xe5a0
cmpl $0x0, %eax
jne 0x31a70
movq 0xa8(%rsp), %rdi
movl 0xa4(%rsp), %esi
addl $0x1, %esi
leaq 0x5f1e(%rip), %rdx      # 0x3797d
callq 0xc3a0
movl %eax, 0xb4(%rsp)
jmp 0x31b10
movq 0xa8(%rsp), %rdi
movl 0xa4(%rsp), %esi
addl $0x3, %esi
callq 0xce50
movq 0xa8(%rsp), %rdi
movl 0xa4(%rsp), %esi
addl $0x3, %esi
callq 0x8e50
movq 0xa8(%rsp), %rdi
movq 0x98(%rsp), %rsi
movl $0x1, %edx
callq 0x8c80
movq 0xa8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x98(%rsp), %rax
movq %rax, (%rsp)
movq 0xa8(%rsp), %rdi
movl 0xa4(%rsp), %esi
addl $0x2, %esi
callq 0xcf40
movq (%rsp), %rdi
movl %eax, %edx
leaq 0x18(%rsp), %rsi
callq 0xe8c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x9fe0
movl $0x1, 0xb4(%rsp)
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldblib.c
// Function: db_traceback
static int db_traceback (lua_State *L) {
  int arg;
  lua_State *L1 = getthread(L, &arg);
  const char *msg = lua_tostring(L, arg + 1);
  if (msg == NULL && !lua_isnoneornil(L, arg + 1))  /* non-string 'msg'? */
    lua_pushvalue(L, arg + 1);  /* return it untouched */
  else {
    int level = luaL_optint(L, arg + 2, (L == L1) ? 1 : 0);
    luaL_traceback(L, L1, msg, level);
  }
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x31c90
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x9a80
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x31c38
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
callq 0x9350
cmpl $0x0, %eax
jle 0x31c38
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
callq 0x92e0
jmp 0x31c7f
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
addl $0x2, %esi
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %r8
xorl %eax, %eax
movl $0x1, %ecx
cmpq %r8, %rdx
cmovel %ecx, %eax
movslq %eax, %rdx
callq 0xcfe0
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
callq 0xbfc0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldblib.c
// Function: getthread
static lua_State *getthread (lua_State *L, int *arg) {
  if (lua_isthread(L, 1)) {
    *arg = 1;
    return lua_tothread(L, 1);
  }
  else {
    *arg = 0;
    return L;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x9350
cmpl $0x8, %eax
jne 0x31cd1
movq (%rsp), %rax
movl $0x1, (%rax)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x9ce0
movq %rax, 0x10(%rsp)
jmp 0x31ce5
movq (%rsp), %rax
movl $0x0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldblib.c
// Function: hookf
static void hookf (lua_State *L, lua_Debug *ar) {
  static const char *const hooknames[] =
    {"call", "return", "line", "count", "tail call"};
  gethooktable(L);
  lua_pushthread(L);
  lua_rawget(L, -2);
  if (lua_isfunction(L, -1)) {
    lua_pushstring(L, hooknames[(int)ar->event]);
    if (ar->currentline >= 0)
      lua_pushinteger(L, ar->currentline);
    else lua_pushnil(L);
    lua_assert(lua_getinfo(L, "lS", ar));
    lua_call(L, 2, 0);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x5bc9(%rip), %rdx      # 0x378d8
callq 0xdf60
movq 0x10(%rsp), %rdi
callq 0xa3d0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xa5e0
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9350
cmpl $0x6, %eax
jne 0x31da0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq (%rax), %rcx
leaq 0xef3b(%rip), %rax      # 0x40c90
movq (%rax,%rcx,8), %rsi
callq 0x9fe0
movq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
jl 0x31d7e
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq 0x28(%rax), %rsi
callq 0x9e70
jmp 0x31d88
movq 0x10(%rsp), %rdi
callq 0x9df0
movq 0x10(%rsp), %rdi
movl $0x2, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
movl %ecx, %edx
callq 0xb0e0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldblib.c
// Function: treatstackoption
static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
  if (L == L1) {
    lua_pushvalue(L, -2);
    lua_remove(L, -3);
  }
  else
    lua_xmove(L1, L, 1);
  lua_setfield(L, -2, fname);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x31f4e
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x92e0
movq 0x10(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x8f00
jmp 0x31f62
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x8c80
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xaad0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldblib.c
// Function: auxupvalue
static int auxupvalue (lua_State *L, int get) {
  const char *name;
  int n = luaL_checkint(L, 2);
  luaL_checktype(L, 1, LUA_TFUNCTION);
  name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
  if (name == NULL) return 0;
  lua_pushstring(L, name);
  lua_insert(L, -(get+1));
  return get + 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0xcf40
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0xcdc0
cmpl $0x0, 0x24(%rsp)
je 0x31fd5
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %edx
movl $0x1, %esi
callq 0xba90
movq %rax, 0x8(%rsp)
jmp 0x31fed
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %edx
movl $0x1, %esi
callq 0xbce0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x32009
movl $0x0, 0x34(%rsp)
jmp 0x32038
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x9fe0
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %eax
addl $0x1, %eax
xorl %esi, %esi
subl %eax, %esi
callq 0x90d0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/ldblib.c
// Function: checkupval
static int checkupval (lua_State *L, int argf, int argnup) {
  lua_Debug ar;
  int nup = luaL_checkint(L, argnup);
  luaL_checktype(L, argf, LUA_TFUNCTION);
  lua_pushvalue(L, argf);
  lua_getinfo(L, ">u", &ar);
  luaL_argcheck(L, 1 <= nup && nup <= ar.nups, argnup, "invalid upvalue index");
  return nup;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movl %edx, 0x88(%rsp)
movq 0x90(%rsp), %rdi
movl 0x88(%rsp), %esi
callq 0xcf40
movl %eax, 0x4(%rsp)
movq 0x90(%rsp), %rdi
movl 0x8c(%rsp), %esi
movl $0x6, %edx
callq 0xcdc0
movq 0x90(%rsp), %rdi
movl 0x8c(%rsp), %esi
callq 0x92e0
movq 0x90(%rsp), %rdi
leaq 0x58e5(%rip), %rsi      # 0x379a6
leaq 0x8(%rsp), %rdx
callq 0xe960
movl $0x1, %eax
cmpl 0x4(%rsp), %eax
jg 0x320e9
movl 0x4(%rsp), %ecx
movzbl 0x3c(%rsp), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, 0x3(%rsp)
jle 0x3210e
movq 0x90(%rsp), %rdi
movl 0x88(%rsp), %esi
leaq 0x58aa(%rip), %rdx      # 0x379a9
callq 0xc3a0
cmpl $0x0, %eax
setne %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
movl 0x4(%rsp), %eax
addq $0x98, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/llex.c
// Function: luaX_init
void luaX_init (lua_State *L) {
  int i;
  for (i=0; i<NUM_RESERVED; i++) {
    TString *ts = luaS_new(L, luaX_tokens[i]);
    luaS_fix(ts);  /* reserved words are never collected */
    ts->tsv.extra = cast_byte(i+1);  /* reserved word */
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x16, 0xc(%rsp)
jge 0x32211
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rcx
leaq 0xeae7(%rip), %rax      # 0x40cc0
movq (%rax,%rcx,8), %rsi
callq 0x209f0
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl 0x9(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x9(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0xa(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x321c1
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/llex.c
// Function: luaX_token2str
const char *luaX_token2str (LexState *ls, int token) {
  if (token < FIRST_RESERVED) {  /* single-byte symbols? */
    lua_assert(token == cast(unsigned char, token));
    return (lisprint(token)) ? luaO_pushfstring(ls->L, LUA_QL("%c"), token) :
                              luaO_pushfstring(ls->L, "char(%d)", 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, LUA_QS, s);
    else  /* names, strings, and numerals */
      return s;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpl $0x101, 0x14(%rsp)      # imm = 0x101
jge 0x3229f
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x54d8(%rip), %rax      # 0x37720
movzbl (%rax,%rcx), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x32275
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rdi
movl 0x14(%rsp), %edx
leaq 0x5b74(%rip), %rsi      # 0x37ddc
movb $0x0, %al
callq 0x1a1b0
movq %rax, (%rsp)
jmp 0x32294
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rdi
movl 0x14(%rsp), %edx
leaq 0x5b58(%rip), %rsi      # 0x37de1
movb $0x0, %al
callq 0x1a1b0
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x322f2
movl 0x14(%rsp), %eax
subl $0x101, %eax            # imm = 0x101
movslq %eax, %rcx
leaq 0xea0e(%rip), %rax      # 0x40cc0
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpl $0x11e, 0x14(%rsp)      # imm = 0x11E
jge 0x322e8
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x3f40(%rip), %rsi      # 0x3621a
movb $0x0, %al
callq 0x1a1b0
movq %rax, 0x20(%rsp)
jmp 0x322f2
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/llex.c
// Function: lexerror
static l_noret lexerror (LexState *ls, const char *msg, int token) {
  char buff[LUA_IDSIZE];
  luaO_chunkid(buff, getstr(ls->source), LUA_IDSIZE);
  msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
  if (token)
    luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token));
  luaD_throw(ls->L, LUA_ERRSYNTAX);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x58(%rax), %rsi
addq $0x18, %rsi
movl $0x3c, %edx
callq 0x1a280
movq 0x60(%rsp), %rax
movq 0x38(%rax), %rdi
leaq 0x10(%rsp), %rdx
movq 0x60(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x58(%rsp), %r8
leaq 0x3622(%rip), %rsi      # 0x359a2
movb $0x0, %al
callq 0x1a1b0
movq %rax, 0x58(%rsp)
cmpl $0x0, 0x54(%rsp)
je 0x323d2
movq 0x60(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x33110
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x5a77(%rip), %rsi      # 0x37e42
movb $0x0, %al
callq 0x1a1b0
movq 0x60(%rsp), %rax
movq 0x38(%rax), %rdi
movl $0x3, %esi
callq 0xfe30
nopw %cs:(%rax,%rax)