LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1c7f3
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_O1/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 0x1cce4
cmpl $0x1, %esi
je 0x1ccb1
testl %esi, %esi
jne 0x1cd07
cmpl $0x5, (%rbx)
jne 0x1cc97
cmpl $-0x1, 0x10(%rbx)
jne 0x1cc97
cmpl $-0x1, 0x14(%rbx)
je 0x1cdd0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c777
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl $0x13, %esi
jmp 0x1ccfc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c572
movl (%rbx), %eax
decl %eax
cmpl $0xa, %eax
ja 0x1cda9
leaq 0x55b4(%rip), %rcx      # 0x22284
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, (%rbx)
jmp 0x1cda9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c777
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl $0x15, %esi
movq %rbx, %rdx
movl %ebp, %r8d
callq 0x1cde5
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x2, (%rbx)
jmp 0x1cda9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d3bc
cmpl $0x6, (%rbx)
jne 0x1cd41
movl 0x8(%rbx), %eax
btl $0x8, %eax
jb 0x1cd41
movzbl 0x42(%r14), %ecx
cmpl %ecx, %eax
jl 0x1cd41
decb 0x44(%r14)
movl 0x8(%rbx), %esi
shll $0x17, %esi
orl $0x14, %esi
movq %r14, %rdi
callq 0x1c050
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
jmp 0x1cda9
movslq 0x8(%rbx), %rcx
movq (%r14), %rdx
leaq (,%rcx,4), %rax
addq 0x18(%rdx), %rax
testq %rcx, %rcx
jle 0x1cd8c
movl -0x4(%rax), %ecx
andl $0x3f, %ecx
leaq 0x449e(%rip), %rdx      # 0x21220
cmpb $0x0, (%rcx,%rdx)
jns 0x1cd8c
addq $-0x4, %rax
movl (%rax), %ecx
movl %ecx, %edx
andl $0xffffc03f, %edx       # imm = 0xFFFFC03F
xorl %esi, %esi
testl $0x3fc0, %ecx           # imm = 0x3FC0
sete %sil
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax)
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %eax
movl %esi, 0x14(%rbx)
movl %eax, 0x10(%rbx)
movq %r14, %rdi
callq 0x1d3f7
movl 0x10(%rbx), %esi
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1d3f7
movsd 0x8(%rbx), %xmm0
xorps 0x41c4(%rip), %xmm0     # 0x20fa0
movlps %xmm0, 0x8(%rbx)
jmp 0x1cd07
// File: /workspace/github_c_makefile_star2_O1/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 0x1ce2b
cmpl $-0x1, 0x10(%rbx)
jne 0x1ce2b
cmpl $-0x1, 0x14(%rbx)
jne 0x1ce2b
cmpl $0x5, (%r12)
jne 0x1ce2b
cmpl $-0x1, 0x10(%r12)
jne 0x1ce2b
cmpl $-0x1, 0x14(%r12)
je 0x1cefa
xorl %r13d, %r13d
cmpl $0x13, %r15d
je 0x1ce48
cmpl $0x15, %r15d
je 0x1ce48
movq %r14, %rdi
movq %r12, %rsi
callq 0x1c7f3
movl %eax, %r13d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c7f3
cmpl %r13d, %eax
jle 0x1ce81
cmpl $0x6, (%rbx)
jne 0x1ce73
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0x1ce73
movzbl 0x42(%r14), %edx
cmpl %edx, %ecx
jl 0x1ce73
decb 0x44(%r14)
cmpl $0x6, (%r12)
jne 0x1cebb
movl 0x8(%r12), %ecx
jmp 0x1cea8
cmpl $0x6, (%r12)
jne 0x1cea0
movl 0x8(%r12), %ecx
btl $0x8, %ecx
jb 0x1cea0
movzbl 0x42(%r14), %edx
cmpl %edx, %ecx
jl 0x1cea0
decb 0x44(%r14)
cmpl $0x6, (%rbx)
jne 0x1cebb
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0x1cebb
movzbl 0x42(%r14), %edx
cmpl %edx, %ecx
jl 0x1cebb
decb 0x44(%r14)
shll $0x17, %eax
shll $0xe, %r13d
orl %eax, %r13d
orl %r15d, %r13d
movq %r14, %rdi
movl %r13d, %esi
callq 0x1c050
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
movl %r15d, %eax
andl $-0x2, %eax
cmpl $0x10, %eax
jne 0x1cf1c
movsd 0x8(%r12), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1cf1c
jnp 0x1ce2b
addl $-0xd, %r15d
movsd 0x8(%rbx), %xmm0
movsd 0x8(%r12), %xmm1
movl %r15d, %edi
callq 0x107e1
movsd %xmm0, 0x8(%rbx)
jmp 0x1ceeb
// File: /workspace/github_c_makefile_star2_O1/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 0x1c7f3
movl %eax, %r12d
movq %r14, %rdi
movq %r13, %rsi
callq 0x1c7f3
cmpl $0x6, (%r13)
jne 0x1d114
movl 0x8(%r13), %ecx
btl $0x8, %ecx
jb 0x1d114
movzbl 0x42(%r14), %edx
cmpl %edx, %ecx
jl 0x1d114
decb 0x44(%r14)
cmpl $0x6, (%rbx)
jne 0x1d12f
movl 0x8(%rbx), %ecx
btl $0x8, %ecx
jb 0x1d12f
movzbl 0x42(%r14), %edx
cmpl %edx, %ecx
jl 0x1d12f
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 0x1c050
movq %r14, %rdi
callq 0x1be61
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_O1/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 0x1c572
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0xa, %ecx
ja 0x1d34a
leaq 0x507c(%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 0x1c050
jmp 0x1d341
movl 0x8(%rbx), %esi
cmpl %ebp, %esi
je 0x1d341
movl %ebp, %eax
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
jmp 0x1d2cf
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 0x1d341
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x1bd80
jmp 0x1d341
movl 0x8(%rbx), %edx
movq %r14, %rdi
movl %ebp, %esi
jmp 0x1d33c
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x1c40d
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x1c109
movl %ebp, 0x8(%rbx)
movl $0x6, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7cd7
movq %rax, %r14
testq %rax, %rax
jne 0x1d4e4
leaq 0x4ee6(%rip), %rdx      # 0x223bd
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8f3e
movq %rbx, %rdi
callq 0x7683
leal -0x1(%rax), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d64a
testl %eax, %eax
js 0x1d517
movl %eax, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7fe1
leal 0x1(%r14), %ebp
notl %r14d
jmp 0x1d52c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7fe1
movl $0x2, %ebp
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
movq %rbx, %rdi
movl %r14d, %esi
callq 0x779a
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7cd7
movq %rax, %r14
testq %rax, %rax
jne 0x1d58b
leaq 0x4e3f(%rip), %rdx      # 0x223bd
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8f3e
cmpq %rbx, %r14
je 0x1d5af
movq %r14, %rdi
callq 0x8823
testl %eax, %eax
je 0x1d5bd
cmpl $0x1, %eax
je 0x1d5ea
leaq 0x4e71(%rip), %rsi      # 0x22419
movl $0x4, %edx
jmp 0x1d5f6
leaq 0x4aa9(%rip), %rsi      # 0x2205f
movl $0x7, %edx
jmp 0x1d5f6
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0xa530
testl %eax, %eax
jle 0x1d5de
leaq 0x4e3b(%rip), %rsi      # 0x22412
movl $0x6, %edx
jmp 0x1d5f6
movq %r14, %rdi
callq 0x7683
testl %eax, %eax
je 0x1d5a1
leaq 0x4e17(%rip), %rsi      # 0x22408
movl $0x9, %edx
movq %rbx, %rdi
callq 0x7dc7
movl $0x1, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7cd7
movq %rax, %r14
movq %rbx, %rdi
callq 0x7683
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x1d64a
testl %eax, %eax
js 0x1d761
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7907
testl %eax, %eax
je 0x1d799
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9166
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x779a
movq %rbx, %rdi
movl $0x2, %esi
callq 0x899d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8960
// File: /workspace/github_c_makefile_star2_O1/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 0x1e24a
movq %rax, %r14
movq %rax, %rdi
callq 0xa527
movl %eax, %ebp
movq %r14, %rdi
callq 0xa522
testq %rax, %rax
sete %cl
leaq 0xa5b(%rip), %rdx       # 0x1e290
cmpq %rdx, %rax
sete %al
orb %cl, %al
jne 0x1d855
leaq 0x4d84(%rip), %rsi      # 0x225ca
movl $0xd, %edx
movq %rbx, %rdi
callq 0x7dc7
jmp 0x1d89b
leaq 0x4d7c(%rip), %rdx      # 0x225d8
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xa162
movq %r14, %rdi
callq 0x800f
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x75ee
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8119
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x76e8
xorl %eax, %eax
testb $0x1, %bpl
je 0x1d8ad
movb $0x63, 0x7(%rsp)
movl $0x1, %eax
testb $0x2, %bpl
je 0x1d8bc
movl %eax, %ecx
incl %eax
movb $0x72, 0x7(%rsp,%rcx)
testb $0x4, %bpl
je 0x1d8cb
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 0x7e16
movq %r14, %rdi
callq 0xa52c
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x7d87
movl $0x3, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e24a
movq %rax, %r14
movl (%r15), %r12d
leal 0x2(%r12), %esi
movq %rbx, %rdi
callq 0x96d4
movq %rax, %r15
incl %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x7889
movq %rbx, %rdi
cmpl $0x6, %eax
jne 0x1dcf0
movl %r12d, %esi
callq 0x7869
movq %rbx, %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0xa58a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7e16
movl $0x1, %eax
jmp 0x1dd64
movl %r12d, %esi
callq 0x96d4
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0xa530
testl %eax, %eax
je 0x1dd52
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0xa58a
testq %rax, %rax
je 0x1dd73
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x75ee
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7e16
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7869
movl $0x2, %eax
jmp 0x1dd64
leaq 0x4924(%rip), %rdx      # 0x2267d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x8f3e
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x7d5e
jmp 0x1dce9
// File: /workspace/github_c_makefile_star2_O1/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 0x7889
cmpl $0x2, %eax
jne 0x1deba
leaq 0x4812(%rip), %rdx      # 0x226bf
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8f3e
movq %rbx, %rdi
movl $0x1, %esi
movl $0x7, %edx
callq 0x95e9
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7889
testl %eax, %eax
jle 0x1deef
movq %rbx, %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0x95e9
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7697
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8585
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e24a
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7889
testl %eax, %eax
jle 0x1dfe0
leal 0x2(%r15), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9559
movq %rax, %r12
movq %rbx, %rdi
movl %ebp, %esi
movl $0x6, %edx
callq 0x95e9
addl $0x3, %r15d
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x9769
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       # 0x1e290
jmp 0x1dff3
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7697
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
leaq 0x45de(%rip), %rdx      # 0x225d8
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xa162
testl %eax, %eax
jne 0x1e048
leaq 0x3589(%rip), %rsi      # 0x2159b
movq %rbx, %rdi
callq 0x7e16
leaq 0x3c34(%rip), %rdx      # 0x21c55
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x833f
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7869
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x84d7
movq %r14, %rdi
callq 0x800f
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x75ee
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7869
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x83a5
movq %r14, %rdi
movq %r13, %rsi
movl %r12d, %edx
movl %r15d, %ecx
callq 0xa4ec
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_O1/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 0x1e24a
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x96d4
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0xa530
testl %eax, %eax
je 0x1e135
leal 0x3(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x961d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7697
movl $0x1, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x75ee
addl $0x2, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x96d4
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0xa6ed
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7e16
jmp 0x1e148
leaq 0x4541(%rip), %rdx      # 0x2267d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8f3e
movl %eax, %ebp
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e24a
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7bdc
movq %rax, %r12
testq %rax, %rax
je 0x1e220
addl $0x2, %r15d
xorl %edx, %edx
cmpq %rbx, %r14
sete %dl
movq %rbx, %rdi
movl %r15d, %esi
callq 0x9769
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %eax, %ecx
callq 0x8cb4
jmp 0x1e238
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7889
testl %eax, %eax
jle 0x1e1f7
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7869
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7889
cmpl $0x8, %eax
jne 0x1e27e
movl $0x1, (%r14)
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7cd7
movl $0x0, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4337(%rip), %rdx      # 0x225d8
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xa162
movq %rbx, %rdi
callq 0x800f
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8119
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7889
cmpl $0x6, %eax
jne 0x1e2fe
movslq (%r14), %rax
leaq 0x4410(%rip), %rcx      # 0x226ec
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x7e16
movslq 0x28(%r14), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
js 0x1e306
callq 0x7d87
jmp 0x1e30b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x7d5e
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x85f1
// File: /workspace/github_c_makefile_star2_O1/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 0x1e347
movq %rsi, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x75ee
jmp 0x1e361
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7869
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x76e8
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x833f
// File: /workspace/github_c_makefile_star2_O1/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 0x96d4
movq %rax, %r15
movq %r14, %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x95e9
movq %r14, %rdi
movl $0x1, %esi
movl %r15d, %edx
testl %ebx, %ebx
je 0x1e3b9
callq 0x8a89
jmp 0x1e3be
callq 0x8b6b
testq %rax, %rax
je 0x1e3df
movq %r14, %rdi
movq %rax, %rsi
callq 0x7e16
leal 0x1(%rbx), %ebp
notl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x779a
jmp 0x1e3e1
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x96d4
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
movl $0x6, %edx
callq 0x95e9
movq %r14, %rdi
movl %ebp, %esi
callq 0x7869
leaq 0x427a(%rip), %rsi      # 0x226a6
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xa730
testl %r15d, %r15d
jle 0x1e448
movzbl 0x3c(%rsp), %eax
cmpl %eax, %r15d
jle 0x1e459
leaq 0x425a(%rip), %rdx      # 0x226a9
movq %r14, %rdi
movl %ebx, %esi
callq 0x8f3e
movl %r15d, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xe83d(%rip), %r15      # 0x2ccc0
movq (%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x14c07
orb $0x20, 0x9(%rax)
movb %bpl, 0xa(%rax)
addq $0x8, %r14
incb %bpl
cmpq $0xb0, %r14
jne 0x1e483
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e4da
movslq %edx, %rax
leaq 0x3f5a(%rip), %rcx      # 0x22420
testb $0x4, 0x1(%rax,%rcx)
movq 0x38(%rdi), %rdi
jne 0x1e508
leaq 0x4339(%rip), %rsi      # 0x22811
jmp 0x1e50f
leal -0x101(%rdx), %eax
leaq 0xe7d9(%rip), %rcx      # 0x2ccc0
movq (%rcx,%rax,8), %rax
cmpl $0x11d, %edx            # imm = 0x11D
jg 0x1e516
movq 0x38(%rdi), %rdi
leaq 0x2a4c(%rip), %rsi      # 0x20f4a
movq %rax, %rdx
xorl %eax, %eax
jmp 0x10d8e
leaq 0x42fd(%rip), %rsi      # 0x2280c
xorl %eax, %eax
jmp 0x10d8e
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10e12
movq 0x38(%rbx), %rdi
movl 0x4(%rbx), %ecx
leaq 0x22fc(%rip), %rsi      # 0x20856
movq %r15, %rdx
movq %r14, %r8
xorl %eax, %eax
callq 0x10d8e
testl %r12d, %r12d
je 0x1e5c4
movq %rax, %r14
movq 0x38(%rbx), %r15
leal -0x11f(%r12), %eax
movq %rbx, %rdi
cmpl $0x2, %eax
ja 0x1e5a5
xorl %esi, %esi
callq 0x1f159
movq 0x38(%rbx), %rdi
movq 0x48(%rbx), %rax
movq (%rax), %rdx
leaq 0x29ae(%rip), %rsi      # 0x20f4a
xorl %eax, %eax
callq 0x10d8e
jmp 0x1e5ad
movl %r12d, %esi
callq 0x1e4b2
leaq 0x42be(%rip), %rsi      # 0x22872
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x10d8e
movq 0x38(%rbx), %rdi
movl $0x3, %esi
callq 0xb1b4
// File: /workspace/github_c_makefile_star2_O1/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 0x14a3f
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 0x16f5c
cmpl $0x0, 0x8(%rax)
je 0x1e627
movq 0x10(%rax), %r14
jmp 0x1e644
movl $0x1, %ecx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
movq 0x18(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jle 0x1e644
movq %rbx, %rdi
callq 0xd66d
addq $-0x10, 0x10(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x21ae(%rip), %rsi      # 0x2083b
callq 0x14c07
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 0xfa40
movq 0x48(%rbx), %rcx
movq %rax, (%rcx)
movq $0x20, 0x10(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f1dc
callq 0x1aa60
jmp 0x1f1eb
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
cmpl $0xd, %eax
je 0x1f1f7
cmpl $0xa, %eax
jne 0x1f21d
cmpl %ebp, %eax
je 0x1f21d
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x1f20c
callq 0x1aa60
jmp 0x1f21b
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 0x1f234
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3679(%rip), %rsi      # 0x228b4
movq %rbx, %rdi
callq 0x1e517
// File: /workspace/github_c_makefile_star2_O1/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 0x1f159
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x1f2ee
callq 0x1aa60
jmp 0x1f2fd
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
cmpl $0xd, %eax
je 0x1f30a
cmpl $0xa, %eax
jne 0x1f37a
movq %r14, %rdi
callq 0x1f1c3
jmp 0x1f37a
cmpl $0xa, %esi
jne 0x1f341
movq %r14, %rdi
movl $0xa, %esi
callq 0x1f159
movq %r14, %rdi
callq 0x1f1c3
testq %rbx, %rbx
jne 0x1f37a
movq 0x48(%r14), %rax
movq $0x0, 0x8(%rax)
jmp 0x1f37a
cmpl $-0x1, %esi
je 0x1f3fd
testq %rbx, %rbx
je 0x1f357
movq %r14, %rdi
callq 0x1f159
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x1f368
callq 0x1aa60
jmp 0x1f377
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 0x1f314
cmpl $0xd, %esi
je 0x1f319
cmpl $0x5d, %esi
jne 0x1f34a
movq %r14, %rdi
callq 0x1f243
cmpl %r15d, %eax
jne 0x1f37a
movl (%r14), %esi
movq %r14, %rdi
callq 0x1f159
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x1f3b5
callq 0x1aa60
jmp 0x1f3c4
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x1f3f7
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 0x1e5d2
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
testq %rbx, %rbx
leaq 0x34dd(%rip), %rax      # 0x228e4
leaq 0x34bf(%rip), %rsi      # 0x228cd
cmoveq %rax, %rsi
movq %r14, %rdi
movl $0x11e, %edx            # imm = 0x11E
callq 0x1e520
// File: /workspace/github_c_makefile_star2_O1/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 0x1f472
movq %rdi, %rbx
movq %rsi, %rdi
movl %r14d, %esi
callq 0x6190
testq %rax, %rax
je 0x1f472
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1f159
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x1f45c
callq 0x1aa60
jmp 0x1f46b
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_O1/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 0x1f159
testl %ebp, %ebp
jle 0x1f4c8
movl %ebp, %r12d
xorl %r13d, %r13d
movl (%r15,%r13,4), %esi
cmpl $-0x1, %esi
je 0x1f4c8
movq %r14, %rdi
callq 0x1f159
incq %r13
cmpq %r13, %r12
jne 0x1f4af
movq %r14, %rdi
movq %rbx, %rsi
movl $0x121, %edx            # imm = 0x121
callq 0x1e520
// File: /workspace/github_c_makefile_star2_O1/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/llex.c
// Function: buffreplace
static void buffreplace (LexState *ls, char from, char to) {
  size_t n = luaZ_bufflen(ls->buff);
  char *p = luaZ_buffer(ls->buff);
  while (n--)
    if (p[n] == from) p[n] = to;
}

// Assembly:
movq 0x48(%rdi), %rcx
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0x1f4f8
movq (%rcx), %rcx
cmpb %sil, -0x1(%rcx,%rax)
jne 0x1f4f3
movb %dl, -0x1(%rcx,%rax)
decq %rax
jne 0x1f4e8
retq
// File: /workspace/github_c_makefile_star2_O1/ulisses[P]ftp-client-server/./checksum.h
// Function: addCksum
char *addCksum(unsigned int chksum, char *msg) {
        char *msgCk = (char *)malloc(sizeof(char)*strlen(msg)+4);

        sprintf(msgCk,"%x",(int)chksum);
        msg = strcat(msg,msgCk);

        return msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movq %rsi, %rdi
callq 0x1070
leaq 0x4(%rax), %rdi
callq 0x1120
movq %rax, %r15
leaq 0x1b09(%rip), %rsi      # 0x3020
movq %rax, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x11a0
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/ulisses[P]ftp-client-server/./checksum.h
// Function: checksum
int checksum(char *msg) {
        int  sum, i, n = strlen(msg);

        for(sum = 0, i = 0; i < n; i+=2) {
                sum += msg[i]*256 + msg[i+1];
        }

    sum = (sum >> 16) + (sum & 0xFFFF);
    sum += sum >> 16;

    return ((unsigned short) ~sum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1070
testl %eax, %eax
jle 0x1571
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
xorl %esi, %esi
movsbl (%rbx,%rdx), %edi
shll $0x8, %edi
movsbl 0x1(%rbx,%rdx), %ecx
addl %esi, %ecx
addl %edi, %ecx
addq $0x2, %rdx
movl %ecx, %esi
cmpq %rax, %rdx
jb 0x1554
jmp 0x1573
xorl %ecx, %ecx
movl %ecx, %eax
sarl $0x10, %eax
movl $0xffff, %edx           # imm = 0xFFFF
andl %edx, %ecx
addl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
addl %ecx, %eax
notl %eax
andl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ulisses[P]ftp-client-server/./geradorErro.h
// Function: myrand
int myrand(int a, int b) {
        int r, ret = 0;

        srand( (unsigned int) time(NULL));

        r = rand();

        if(a<b) {
                b++;
                ret = (r % (b-a)) + a;
        }

        return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebx
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10e0
callq 0x11f0
subl %ebx, %r14d
jle 0x15ca
incl %r14d
cltd
idivl %r14d
movl %edx, %r15d
addl %ebx, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1703
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
cltq
cmpl $-0x1, (%r14,%rax,4)
jne 0x16b3
movl $0x1, (%r14,%rax,4)
incl 0x3a7d(%rip)            # 0x5130
cmpl %r15d, 0x3a76(%rip)     # 0x5130
jne 0x166e
jmp 0x1703
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
cltq
cmpl $-0x1, (%r14,%rax,4)
jne 0x1703
movl $0x2, (%r14,%rax,4)
incl 0x3a35(%rip)            # 0x5138
cmpl %ebx, 0x3a2f(%rip)      # 0x5138
jne 0x16be
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
movl %edi, %r12d
movq %rdx, %rdi
callq 0x1070
movq %rax, %rdi
callq 0x1120
movq %rax, %r14
movl 0x39ef(%rip), %eax      # 0x5130
orl 0x39f1(%rip), %eax      # 0x5138
je 0x1752
cmpl $0x64, 0x39e4(%rip)     # 0x5134
jne 0x175d
movl %r12d, %edi
movl %r15d, %esi
callq 0x1611
movslq 0x39d0(%rip), %rax      # 0x5134
leaq 0x3cf5(%rip), %r12      # 0x5460
cmpl $0x1, (%r12,%rax,4)
jne 0x1791
incb (%rbx)
movslq 0x39b9(%rip), %rax      # 0x5134
leaq 0x39be(%rip), %rcx      # 0x5140
movq %rbx, (%rcx,%rax,8)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1050
movslq 0x399c(%rip), %r15      # 0x5134
movl (%r12,%r15,4), %eax
cmpl $0x2, %eax
jne 0x17b3
leaq 0x3998(%rip), %rcx      # 0x5140
movq $0x0, (%rcx,%r15,8)
xorl %r14d, %r14d
cmpl $-0x1, %eax
jne 0x17ce
leaq 0x3981(%rip), %rax      # 0x5140
movq %rbx, (%rax,%r15,8)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1050
incl %r15d
movl %r15d, 0x395c(%rip)     # 0x5134
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ulisses[P]ftp-client-server/./datagrama.h
// Function: initDatagrama
Datagrama *initDatagrama(){
	Datagrama *novo = (Datagrama *)malloc(sizeof(struct segmento));
	novo->ack = novo->seq = novo->win_size = novo->flags = novo->len = novo->cksum = 0;
	strcpy(novo->data, "c");
	return novo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xe0, %edi
callq 0x1120
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movw $0x63, 0x18(%rax)
popq %rbp
retq