LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0xb, (%rsi)
jne 0x1cb66
movq (%rbx), %rax
movq 0x18(%rax), %rax
movslq 0x8(%r14), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
andl $0x3f, %ecx
cmpl $0x14, %ecx
jne 0x1cb66
decl 0x28(%rbx)
xorl %esi, %esi
testl %ebp, %ebp
sete %sil
shrl $0x11, %eax
andl $-0x40, %eax
shll $0xe, %esi
orl %eax, %esi
orl $0x1b, %esi
movq %rbx, %rdi
jmp 0x1cba3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d3b7
cmpl $0x6, (%r14)
jne 0x1cb8c
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x1cb8c
movzbl 0x42(%rbx), %ecx
cmpl %ecx, %eax
jl 0x1cb8c
decb 0x44(%rbx)
movl 0x8(%r14), %eax
shll $0x17, %eax
shll $0xe, %ebp
orl %eax, %ebp
orl $0x3fdc, %ebp           # imm = 0x3FDC
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c076
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1be84
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1c590
movl (%rbx), %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl $0x1, %eax
je 0x1cbf0
cmpl $0x3, %eax
je 0x1cbf0
cmpl $0xa, %eax
jne 0x1cbde
movl 0x8(%rbx), %edx
jmp 0x1cbf0
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x1cb1f
movl %eax, %edx
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x1bed3
movl 0x14(%rbx), %edx
movl 0x28(%r14), %eax
movl %eax, 0x2c(%r14)
leaq 0x30(%r14), %rsi
movq %r14, %rdi
callq 0x1bed3
movl $0xffffffff, 0x14(%rbx) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
movq %rsi, %rbx
movb 0x8(%rsi), %al
movb %al, 0xa(%rsi)
movq %rdx, %rsi
callq 0x1c81a
movw %ax, 0x8(%rbx)
cmpl $0x8, (%rbx)
sete %al
addb $0x7, %al
movb %al, 0xb(%rbx)
movl $0x9, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
movq $-0x1, 0x18(%rsp)
movl $0x5, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x2, %esi
je 0x1cce9
cmpl $0x1, %esi
je 0x1ccb6
testl %esi, %esi
jne 0x1cd0c
cmpl $0x5, (%rbx)
jne 0x1cc9c
cmpl $-0x1, 0x10(%rbx)
jne 0x1cc9c
cmpl $-0x1, 0x14(%rbx)
je 0x1cd93
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c79e
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl $0x13, %esi
jmp 0x1cd01
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c590
movl (%rbx), %eax
decl %eax
cmpl $0xa, %eax
ja 0x1cdc7
leaq 0x55af(%rip), %rcx      # 0x22284
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, (%rbx)
jmp 0x1cdc7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c79e
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl $0x15, %esi
movq %rbx, %rdx
movl %ebp, %r8d
callq 0x1cdee
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x2, (%rbx)
jmp 0x1cdc7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d3b7
cmpl $0x6, (%rbx)
jne 0x1cd46
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0x1cd46
movzbl 0x42(%r14), %ecx
cmpl %ecx, %eax
jl 0x1cd46
decb 0x44(%r14)
movl 0x8(%rbx), %esi
shll $0x17, %esi
orl $0x14, %esi
movq %r14, %rdi
callq 0x1c076
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
jmp 0x1cdc7
movq (%r14), %rcx
movslq 0x8(%rbx), %rdx
leaq (,%rdx,4), %rax
addq 0x18(%rcx), %rax
testq %rdx, %rdx
jle 0x1cd8f
movl -0x4(%rax), %ecx
movl %ecx, %edx
andl $0x3f, %edx
leaq 0x4497(%rip), %rsi      # 0x21220
cmpb $0x0, (%rdx,%rsi)
js 0x1cda8
movl (%rax), %ecx
jmp 0x1cdac
movsd 0x8(%rbx), %xmm0
xorps 0x4201(%rip), %xmm0     # 0x20fa0
movlps %xmm0, 0x8(%rbx)
jmp 0x1cd0c
addq $-0x4, %rax
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(%rbx), %esi
movl 0x14(%rbx), %eax
movl %esi, 0x14(%rbx)
movl %eax, 0x10(%rbx)
movq %r14, %rdi
callq 0x1d3f2
movl 0x10(%rbx), %esi
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1d3f2
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x5, (%rdx)
jne 0x1ce5a
cmpl $-0x1, 0x10(%rbx)
jne 0x1ce5a
cmpl $-0x1, 0x14(%rbx)
jne 0x1ce5a
cmpl $0x5, (%r12)
jne 0x1ce5a
cmpl $-0x1, 0x10(%r12)
jne 0x1ce5a
cmpl $-0x1, 0x14(%r12)
jne 0x1ce5a
movl %r15d, %eax
andl $-0x2, %eax
movsd 0x8(%r12), %xmm1
cmpl $0x10, %eax
jne 0x1cf29
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x1cf29
jp 0x1cf29
xorl %r13d, %r13d
cmpl $0x13, %r15d
je 0x1ce77
cmpl $0x15, %r15d
je 0x1ce77
movq %r14, %rdi
movq %r12, %rsi
callq 0x1c81a
movl %eax, %r13d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c81a
cmpl %r13d, %eax
jle 0x1ceb0
cmpl $0x6, (%rbx)
jne 0x1cea2
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0x1cea2
movzbl 0x42(%r14), %edx
cmpl %edx, %ecx
jl 0x1cea2
decb 0x44(%r14)
cmpl $0x6, (%r12)
jne 0x1ceea
movl 0x8(%r12), %ecx
jmp 0x1ced7
cmpl $0x6, (%r12)
jne 0x1cecf
movl 0x8(%r12), %ecx
btl $0x8, %ecx
jb 0x1cecf
movzbl 0x42(%r14), %edx
cmpl %edx, %ecx
jl 0x1cecf
decb 0x44(%r14)
cmpl $0x6, (%rbx)
jne 0x1ceea
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0x1ceea
movzbl 0x42(%r14), %edx
cmpl %edx, %ecx
jl 0x1ceea
decb 0x44(%r14)
shll $0x17, %eax
shll $0xe, %r13d
orl %eax, %r13d
orl %r15d, %r13d
movq %r14, %rdi
movl %r13d, %esi
callq 0x1c076
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
movq (%r14), %rax
movq 0x28(%rax), %rax
movslq 0x28(%r14), %rcx
movl %ebp, -0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl $-0xd, %r15d
movsd 0x8(%rbx), %xmm0
movl %r15d, %edi
callq 0x10911
movsd %xmm0, 0x8(%rbx)
jmp 0x1cf1a
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
movq %rcx, %rsi
callq 0x1c81a
movl %eax, %r12d
movq %r14, %rdi
movq %r13, %rsi
callq 0x1c81a
cmpl $0x6, (%r13)
jne 0x1d11d
movl 0x8(%r13), %ecx
btl $0x8, %ecx
jb 0x1d11d
movzbl 0x42(%r14), %edx
cmpl %edx, %ecx
jl 0x1d11d
decb 0x44(%r14)
cmpl $0x6, (%rbx)
jne 0x1d138
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0x1d138
movzbl 0x42(%r14), %edx
cmpl %edx, %ecx
jl 0x1d138
decb 0x44(%r14)
testl %r15d, %r15d
sete %cl
cmpl $0x18, %ebp
setne %dl
shll $0x6, %r15d
testb %cl, %dl
movl %r12d, %ecx
cmovnel %eax, %ecx
cmovnel %r12d, %eax
movl $0x40, %edx
cmovel %r15d, %edx
shll $0x17, %ecx
orl %edx, %ecx
shll $0xe, %eax
orl %ebp, %eax
orl %ecx, %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x1c076
movq %r14, %rdi
callq 0x1be84
movl %eax, 0x8(%rbx)
movl $0xa, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1c590
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0xa, %ecx
ja 0x1d34e
leaq 0x5078(%rip), %rdx      # 0x22328
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 0x1c076
jmp 0x1d345
movl 0x8(%rbx), %esi
cmpl %ebp, %esi
je 0x1d345
movl %ebp, %eax
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
jmp 0x1d2d3
movq (%r14), %rax
movq 0x18(%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 0x1d345
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x1bdb0
jmp 0x1d345
movl 0x8(%rbx), %edx
movq %r14, %rdi
movl %ebp, %esi
jmp 0x1d340
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x1c42b
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x1c137
movl %ebp, 0x8(%rbx)
movl $0x6, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7de5
testq %rax, %rax
je 0x1d4e3
movq %rax, %r14
movq %rbx, %rdi
callq 0x7674
leal -0x1(%rax), %edx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x1d507
leaq 0x4ed3(%rip), %rdx      # 0x223bd
movq %rbx, %rdi
movl $0x1, %esi
callq 0x905e
movq %rbx, %rdi
callq 0x7674
leal -0x1(%rax), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1d659
movl %eax, %r14d
movq %rbx, %rdi
testl %eax, %eax
js 0x1d529
movl $0x1, %esi
callq 0x80e5
leal 0x1(%r14), %ebp
notl %r14d
jmp 0x1d53b
xorl %esi, %esi
callq 0x80e5
movl $0x2, %ebp
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
movq %rbx, %rdi
movl %r14d, %esi
callq 0x789f
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7de5
movq %rax, %r14
testq %rax, %rax
jne 0x1d59a
leaq 0x4e30(%rip), %rdx      # 0x223bd
movq %rbx, %rdi
movl $0x1, %esi
callq 0x905e
cmpq %rbx, %r14
je 0x1d5be
movq %r14, %rdi
callq 0x8946
testl %eax, %eax
je 0x1d5cc
cmpl $0x1, %eax
je 0x1d5f9
leaq 0x4e62(%rip), %rsi      # 0x22419
movl $0x4, %edx
jmp 0x1d605
leaq 0x4a9a(%rip), %rsi      # 0x2205f
movl $0x7, %edx
jmp 0x1d605
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0xa684
testl %eax, %eax
jle 0x1d5ed
leaq 0x4e2c(%rip), %rsi      # 0x22412
movl $0x6, %edx
jmp 0x1d605
movq %r14, %rdi
callq 0x7674
testl %eax, %eax
je 0x1d5b0
leaq 0x4e08(%rip), %rsi      # 0x22408
movl $0x9, %edx
movq %rbx, %rdi
callq 0x7ecb
movl $0x1, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x7de5
movq %rax, %r14
movq %rbx, %rdi
callq 0x7674
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x1d659
testl %eax, %eax
js 0x1d770
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7a10
testl %eax, %eax
je 0x1d7a8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9286
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x789f
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8ac0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8a83
nop
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
callq 0x1e25a
movq %rax, %r14
movq %rax, %rdi
callq 0xa67b
movl %eax, %ebp
movq %r14, %rdi
callq 0xa676
testq %rax, %rax
sete %cl
leaq 0xa5b(%rip), %rdx       # 0x1e2a0
cmpq %rdx, %rax
sete %al
orb %cl, %al
jne 0x1d865
leaq 0x4d74(%rip), %rsi      # 0x225ca
movl $0xd, %edx
movq %rbx, %rdi
callq 0x7ecb
jmp 0x1d8ab
leaq 0x4d6c(%rip), %rdx      # 0x225d8
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xa2b6
movq %r14, %rdi
callq 0x8113
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x75df
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x821d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x77ed
xorl %eax, %eax
testb $0x1, %bpl
je 0x1d8bd
movb $0x63, 0x7(%rsp)
movl $0x1, %eax
testb $0x2, %bpl
je 0x1d8cc
movl %eax, %ecx
incl %eax
movb $0x72, 0x7(%rsp,%rcx)
testb $0x4, %bpl
je 0x1d8db
movl %eax, %ecx
incl %eax
movb $0x6c, 0x7(%rsp,%rcx)
movl %eax, %eax
movb $0x0, 0x7(%rsp,%rax)
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0x7f1a
movq %r14, %rdi
callq 0xa680
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x7e95
movl $0x3, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %r15
movq %r15, %rsi
callq 0x1e25a
movq %rax, %r14
movl (%r15), %r12d
leal 0x2(%r12), %esi
movq %rbx, %rdi
callq 0x980b
movq %rax, %r15
incl %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x7992
movq %rbx, %rdi
cmpl $0x6, %eax
jne 0x1dd00
movl %r12d, %esi
callq 0x7972
movq %rbx, %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0xa6de
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7f1a
movl $0x1, %eax
jmp 0x1dd74
movl %r12d, %esi
callq 0x980b
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0xa684
testl %eax, %eax
je 0x1dd62
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0xa6de
testq %rax, %rax
je 0x1dd83
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x75df
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7f1a
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7972
movl $0x2, %eax
jmp 0x1dd74
leaq 0x4914(%rip), %rdx      # 0x2267d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x905e
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x7e6c
jmp 0x1dcf9
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7992
cmpl $0x2, %eax
jne 0x1deca
leaq 0x4802(%rip), %rdx      # 0x226bf
movq %rbx, %rdi
movl $0x1, %esi
callq 0x905e
movq %rbx, %rdi
movl $0x1, %esi
movl $0x7, %edx
callq 0x9720
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7992
testl %eax, %eax
jle 0x1deff
movq %rbx, %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0x9720
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7688
movq %rbx, %rdi
movl $0x1, %esi
callq 0x86a9
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %r15
movq %r15, %rsi
callq 0x1e25a
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7992
testl %eax, %eax
jle 0x1dff0
leal 0x2(%r15), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9690
movq %rax, %r12
movq %rbx, %rdi
movl %ebp, %esi
movl $0x6, %edx
callq 0x9720
addl $0x3, %r15d
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x98a0
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movl $0x63, %esi
callq 0x6190
xorl %r13d, %r13d
testq %rax, %rax
setne %r13b
movq %r12, %rdi
movl $0x72, %esi
callq 0x6190
leal 0x2(%r13), %r15d
testq %rax, %rax
cmovel %r13d, %r15d
movq %r12, %rdi
movl $0x6c, %esi
callq 0x6190
leal 0x4(%r15), %ecx
testq %rax, %rax
cmovel %r15d, %ecx
movq 0x8(%rsp), %r15
leal 0x8(%rcx), %r12d
testl %r15d, %r15d
cmovlel %ecx, %r12d
leaq 0x2b2(%rip), %r13       # 0x1e2a0
jmp 0x1e003
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7688
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
leaq 0x45ce(%rip), %rdx      # 0x225d8
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xa2b6
testl %eax, %eax
jne 0x1e058
leaq 0x3589(%rip), %rsi      # 0x215ab
movq %rbx, %rdi
callq 0x7f1a
leaq 0x3c1c(%rip), %rdx      # 0x21c4d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x844e
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7972
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x85fb
movq %r14, %rdi
callq 0x8113
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x75df
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7972
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x84b4
movq %r14, %rdi
movq %r13, %rsi
movl %r12d, %edx
movl %r15d, %ecx
callq 0xa640
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %r15
movq %r15, %rsi
callq 0x1e25a
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x980b
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0xa684
testl %eax, %eax
je 0x1e145
leal 0x3(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9754
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7688
movl $0x1, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x75df
addl $0x2, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x980b
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0xa836
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7f1a
jmp 0x1e158
leaq 0x4531(%rip), %rdx      # 0x2267d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x905e
movl %eax, %ebp
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r15
movq %r15, %rsi
callq 0x1e25a
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7cea
movq %rax, %r12
testq %rax, %rax
je 0x1e230
addl $0x2, %r15d
xorl %edx, %edx
cmpq %rbx, %r14
sete %dl
movq %rbx, %rdi
movl %r15d, %esi
callq 0x98a0
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %eax, %ecx
callq 0x8dd4
jmp 0x1e248
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7992
testl %eax, %eax
jle 0x1e207
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7972
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %esi
callq 0x7992
cmpl $0x8, %eax
jne 0x1e28e
movl $0x1, (%r14)
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7de5
movl $0x0, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4327(%rip), %rdx      # 0x225d8
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xa2b6
movq %rbx, %rdi
callq 0x8113
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x821d
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7992
cmpl $0x6, %eax
jne 0x1e30e
movslq (%r14), %rax
leaq 0x4400(%rip), %rcx      # 0x226ec
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x7f1a
movslq 0x28(%r14), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
js 0x1e316
callq 0x7e95
jmp 0x1e31b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x7e6c
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8715
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpq %rsi, %rdi
je 0x1e357
movq %rsi, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x75df
jmp 0x1e371
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7972
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x77ed
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x844e
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x2, %esi
callq 0x980b
movq %rax, %r15
movq %r14, %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x9720
movq %r14, %rdi
movl $0x1, %esi
movl %r15d, %edx
testl %ebx, %ebx
je 0x1e3c9
callq 0x8bac
jmp 0x1e3ce
callq 0x8c8e
testq %rax, %rax
je 0x1e3ef
movq %r14, %rdi
movq %rax, %rsi
callq 0x7f1a
leal 0x1(%rbx), %ebp
notl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x789f
jmp 0x1e3f1
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %edx, %esi
callq 0x980b
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
movl $0x6, %edx
callq 0x9720
movq %r14, %rdi
movl %ebp, %esi
callq 0x7972
leaq 0x426a(%rip), %rsi      # 0x226a6
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xa879
testl %r15d, %r15d
jle 0x1e458
movzbl 0x3c(%rsp), %eax
cmpl %eax, %r15d
jle 0x1e469
leaq 0x424a(%rip), %rdx      # 0x226a9
movq %r14, %rdi
movl %ebx, %esi
callq 0x905e
movl %r15d, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, %bpl
xorl %r14d, %r14d
leaq 0xe82d(%rip), %r15      # 0x2ccc0
movq (%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x14d1a
orb $0x20, 0x9(%rax)
movb %bpl, 0xa(%rax)
addq $0x8, %r14
incb %bpl
cmpq $0xb0, %r14
jne 0x1e493
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl %esi, %edx
cmpl $0x100, %esi            # imm = 0x100
jg 0x1e4ea
movslq %edx, %rax
leaq 0x3f4a(%rip), %rcx      # 0x22420
testb $0x4, 0x1(%rax,%rcx)
movq 0x38(%rdi), %rdi
jne 0x1e518
leaq 0x4329(%rip), %rsi      # 0x22811
jmp 0x1e51f
leal -0x101(%rdx), %eax
leaq 0xe7c9(%rip), %rcx      # 0x2ccc0
movq (%rcx,%rax,8), %rax
cmpl $0x11d, %edx            # imm = 0x11D
ja 0x1e526
movq 0x38(%rdi), %rdi
leaq 0x2a3c(%rip), %rsi      # 0x20f4a
movq %rax, %rdx
xorl %eax, %eax
jmp 0x10eda
leaq 0x42ed(%rip), %rsi      # 0x2280c
xorl %eax, %eax
jmp 0x10eda
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x58(%rdi), %rsi
addq $0x18, %rsi
movq %rsp, %r15
movl $0x3c, %edx
movq %r15, %rdi
callq 0x10f5e
movq 0x38(%rbx), %rdi
movl 0x4(%rbx), %ecx
leaq 0x2318(%rip), %rsi      # 0x20882
movq %r15, %rdx
movq %r14, %r8
xorl %eax, %eax
callq 0x10eda
testl %r12d, %r12d
je 0x1e5d4
movq %rax, %r14
movq 0x38(%rbx), %r15
leal -0x11f(%r12), %eax
movq %rbx, %rdi
cmpl $0x2, %eax
ja 0x1e5b5
xorl %esi, %esi
callq 0x1f1a8
movq 0x38(%rbx), %rdi
movq 0x48(%rbx), %rax
movq (%rax), %rdx
leaq 0x299e(%rip), %rsi      # 0x20f4a
xorl %eax, %eax
callq 0x10eda
jmp 0x1e5bd
movl %r12d, %esi
callq 0x1e4c2
leaq 0x42ae(%rip), %rsi      # 0x22872
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x10eda
movq 0x38(%rbx), %rdi
movl $0x3, %esi
callq 0xb2c0
// File: /workspace/github_c_makefile_star2_O3/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/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->fs->h, L->top - 1);
  if (ttisnil(o)) {  /* not in use yet? (see 'addK') */
    /* 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 = rawtsvalue(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 0x14b50
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 0x30(%r15), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rbx), %rdx
addq $-0x10, %rdx
movq %rbx, %rdi
callq 0x1703b
cmpl $0x0, 0x8(%rax)
je 0x1e637
movq 0x10(%rax), %r14
jmp 0x1e654
movl $0x1, %ecx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
movq 0x18(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jle 0x1e654
movq %rbx, %rdi
callq 0xd766
addq $-0x10, 0x10(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/llex.c
// Function: luaX_setinput
void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source,
                    int firstchar) {
  ls->decpoint = '.';
  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_new(L, LUA_ENV);  /* create env name */
  luaS_fix(ls->envn);  /* never collect this name */
  luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movb $0x2e, 0x68(%rsi)
movq %rdi, 0x38(%rsi)
movl %r8d, (%rsi)
movl $0x11e, 0x20(%rsi)      # imm = 0x11E
movq %rdx, 0x40(%rsi)
movq $0x0, 0x30(%rsi)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x4(%rsi)
movq %rcx, 0x58(%rsi)
leaq 0x21ca(%rip), %rsi      # 0x20867
callq 0x14d1a
movq %rax, 0x60(%rbx)
orb $0x20, 0x9(%rax)
movq 0x38(%rbx), %rdi
movq 0x48(%rbx), %rax
movq (%rax), %rsi
movq 0x10(%rax), %rdx
movl $0x20, %ecx
callq 0xfb80
movq 0x48(%rbx), %rcx
movq %rax, (%rcx)
movq $0x20, 0x10(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/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)
    luaX_syntaxerror(ls, "chunk has too many lines");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
movq 0x40(%rdi), %rdi
subq $0x1, (%rdi)
jae 0x1f22e
callq 0x1aa74
jmp 0x1f23d
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
cmpl $0xd, %eax
je 0x1f249
cmpl $0xa, %eax
jne 0x1f26f
cmpl %ebp, %eax
je 0x1f26f
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x1f25e
callq 0x1aa74
jmp 0x1f26d
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
cmpl $0x7ffffffc, %eax       # imm = 0x7FFFFFFC
jge 0x1f286
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3627(%rip), %rsi      # 0x228b4
movq %rbx, %rdi
callq 0x1e527
// File: /workspace/github_c_makefile_star2_O3/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/llex.c
// Function: read_long_string
static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
  save_and_next(ls);  /* skip 2nd `[' */
  if (currIsNewline(ls))  /* string starts with a newline? */
    inclinenumber(ls);  /* skip it */
  for (;;) {
    switch (ls->current) {
      case EOZ:
        lexerror(ls, (seminfo) ? "unfinished long string" :
                                 "unfinished long comment", TK_EOS);
        break;  /* to avoid warnings */
      case ']': {
        if (skip_sep(ls) == sep) {
          save_and_next(ls);  /* skip 2nd `]' */
          goto endloop;
        }
        break;
      }
      case '\n': case '\r': {
        save(ls, '\n');
        inclinenumber(ls);
        if (!seminfo) luaZ_resetbuffer(ls->buff);  /* avoid wasting space */
        break;
      }
      default: {
        if (seminfo) save_and_next(ls);
        else next(ls);
      }
    }
  } endloop:
  if (seminfo)
    seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
                                     luaZ_bufflen(ls->buff) - 2*(2 + sep));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
callq 0x1f1a8
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x1f340
callq 0x1aa74
jmp 0x1f34f
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
cmpl $0xd, %eax
je 0x1f35c
cmpl $0xa, %eax
jne 0x1f3cc
movq %r14, %rdi
callq 0x1f215
jmp 0x1f3cc
cmpl $0xa, %esi
jne 0x1f393
movq %r14, %rdi
movl $0xa, %esi
callq 0x1f1a8
movq %r14, %rdi
callq 0x1f215
testq %rbx, %rbx
jne 0x1f3cc
movq 0x48(%r14), %rax
movq $0x0, 0x8(%rax)
jmp 0x1f3cc
cmpl $-0x1, %esi
je 0x1f44f
testq %rbx, %rbx
je 0x1f3a9
movq %r14, %rdi
callq 0x1f1a8
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x1f3ba
callq 0x1aa74
jmp 0x1f3c9
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
movl (%r14), %esi
cmpl $0xc, %esi
jle 0x1f366
cmpl $0xd, %esi
je 0x1f36b
cmpl $0x5d, %esi
jne 0x1f39c
movq %r14, %rdi
callq 0x1f295
cmpl %r15d, %eax
jne 0x1f3cc
movl (%r14), %esi
movq %r14, %rdi
callq 0x1f1a8
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x1f407
callq 0x1aa74
jmp 0x1f416
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x1f449
movq 0x48(%r14), %rax
movl %r15d, %ecx
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rcx, %rsi
addq $0x2, %rsi
leal 0x4(,%r15,2), %eax
subq %rax, %rdx
movq %r14, %rdi
callq 0x1e5e2
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
testq %rbx, %rbx
leaq 0x348b(%rip), %rax      # 0x228e4
leaq 0x346d(%rip), %rsi      # 0x228cd
cmoveq %rax, %rsi
movq %r14, %rdi
movl $0x11e, %edx            # imm = 0x11E
callq 0x1e530
// File: /workspace/github_c_makefile_star2_O3/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/llex.c
// Function: check_next
static int check_next (LexState *ls, const char *set) {
  if (ls->current == '\0' || !strchr(set, ls->current))
    return 0;
  save_and_next(ls);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl (%rdi), %r14d
xorl %ebp, %ebp
testl %r14d, %r14d
je 0x1f4c4
movq %rdi, %rbx
movq %rsi, %rdi
movl %r14d, %esi
callq 0x6190
testq %rax, %rax
je 0x1f4c4
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1f1a8
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x1f4ae
callq 0x1aa74
jmp 0x1f4bd
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/llex.c
// Function: escerror
static void escerror (LexState *ls, int *c, int n, const char *msg) {
  int i;
  luaZ_resetbuffer(ls->buff);  /* prepare error message */
  save(ls, '\\');
  for (i = 0; i < n && c[i] != EOZ; i++)
    save(ls, c[i]);
  lexerror(ls, msg, TK_STRING);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq 0x48(%rdi), %rax
movq $0x0, 0x8(%rax)
movl $0x5c, %esi
callq 0x1f1a8
testl %ebp, %ebp
jle 0x1f51a
movl %ebp, %r12d
xorl %r13d, %r13d
movl (%r15,%r13,4), %esi
cmpl $-0x1, %esi
je 0x1f51a
movq %r14, %rdi
callq 0x1f1a8
incq %r13
cmpq %r13, %r12
jne 0x1f501
movq %r14, %rdi
movq %rbx, %rsi
movl $0x121, %edx            # imm = 0x121
callq 0x1e530
// File: /workspace/github_c_makefile_star2_O3/ulisses[P]ftp-client-server/./geradorErro.h
// Function: popula
void popula(int pErro, int pPerda) {
        int rErro, rPerda;

        inicializa();
        nrActual=0;
        ocupados=0;
        perdidos=0;

        while(ocupados!=pErro) {
                rErro = myrand(0,MAX);
                if(indexx[rErro] == VAZIO) {
                        indexx[rErro] = ERRO;
                        ocupados++;
                }
        }
        while(perdidos!=pPerda) {
                rPerda = myrand(0,MAX);
                if(indexx[rPerda] == VAZIO) {
                        indexx[rPerda] = PERDIDO;
                        perdidos++;
                }
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %r15d
leaq 0x3b18(%rip), %rdi      # 0x5140
xorl %r12d, %r12d
movl $0x320, %edx            # imm = 0x320
xorl %esi, %esi
callq 0x10a0
leaq 0x3e22(%rip), %r14      # 0x5460
movl $0x190, %edx            # imm = 0x190
movq %r14, %rdi
movl $0xff, %esi
callq 0x10a0
movl %r12d, 0x3add(%rip)     # 0x5134
movl %r12d, 0x3ad2(%rip)     # 0x5130
movl %r12d, 0x3ad3(%rip)     # 0x5138
testl %r15d, %r15d
je 0x16c4
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10e0
callq 0x11f0
cltq
imulq $0x288df0cb, %rax, %rcx # imm = 0x288DF0CB
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x24, %rcx
addl %edx, %ecx
imull $0x65, %ecx, %ecx
subl %ecx, %eax
movslq %eax, %rcx
cmpl $-0x1, (%r14,%rcx,4)
movl 0x3a8a(%rip), %eax      # 0x5130
jne 0x16b8
movl $0x1, (%r14,%rcx,4)
incl %eax
movl %eax, 0x3a78(%rip)      # 0x5130
cmpl %r15d, %eax
jne 0x166a
movl 0x3a74(%rip), %r12d     # 0x5138
cmpl %ebx, %r12d
je 0x171b
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10e0
callq 0x11f0
cltq
imulq $0x288df0cb, %rax, %rcx # imm = 0x288DF0CB
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x24, %rcx
addl %edx, %ecx
imull $0x65, %ecx, %ecx
subl %ecx, %eax
movslq %eax, %rcx
cmpl $-0x1, (%r14,%rcx,4)
movl 0x3a33(%rip), %eax      # 0x5138
jne 0x1717
movl $0x2, (%r14,%rcx,4)
incl %eax
movl %eax, 0x3a21(%rip)      # 0x5138
cmpl %ebx, %eax
jne 0x16c9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ulisses[P]ftp-client-server/./geradorErro.h
// Function: insereErro
char *insereErro(int pErro, int pPerda, char *msg) {
        char *ret = (char *) malloc(sizeof(char)*strlen(msg));

        if((perdidos == 0 && ocupados==0) || nrActual == MAX)
                popula(pErro, pPerda);
        if(indexx[nrActual] == ERRO) { //preencher com erro
                        buff[nrActual] = altera(msg);
                        ret = strcpy(ret, buff[nrActual]);
        }
        if(indexx[nrActual] == PERDIDO) { //preencher vazio
                        buff[nrActual] = NULL;
                        ret = NULL;
        }
        if(indexx[nrActual] == VAZIO) { //preencher normal
                        buff[nrActual] = msg;
                        ret = strcpy(ret, buff[nrActual]);
        }
        nrActual++;

        return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movl %edi, %r12d
movq %rdx, %rdi
callq 0x1070
movq %rax, %rdi
callq 0x1120
movq %rax, %rbx
movl 0x39dc(%rip), %eax      # 0x5130
orl 0x39de(%rip), %eax      # 0x5138
sete %al
movl 0x39d0(%rip), %r13d     # 0x5134
cmpl $0x64, %r13d
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1784
movl %r12d, %edi
movl %r15d, %esi
callq 0x1611
movl 0x39b0(%rip), %r13d     # 0x5134
movslq %r13d, %r15
leaq 0x3cd2(%rip), %r12      # 0x5460
movl (%r12,%r15,4), %eax
cmpl $0x1, %eax
jne 0x17be
incb (%r14)
movl 0x3993(%rip), %r13d     # 0x5134
movslq %r13d, %r15
leaq 0x3995(%rip), %rax      # 0x5140
movq %r14, (%rax,%r15,8)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1050
movl (%r12,%r15,4), %eax
cmpl $-0x1, %eax
je 0x17db
cmpl $0x2, %eax
jne 0x17f1
leaq 0x3971(%rip), %rax      # 0x5140
movq $0x0, (%rax,%r15,8)
xorl %ebx, %ebx
jmp 0x17f1
leaq 0x395e(%rip), %rax      # 0x5140
movq %r14, (%rax,%r15,8)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1050
incl %r13d
movl %r13d, 0x3939(%rip)     # 0x5134
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq