LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
orq $-0x1, 0x18(%rsp)
movl $0x5, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
cmpl $0x2, %esi
je 0x1acba
cmpl $0x1, %esi
je 0x1ac8a
testl %esi, %esi
jne 0x1acea
movq %rbx, %rdi
callq 0x1ad5f
testl %eax, %eax
je 0x1acc9
movsd 0x8(%rbx), %xmm0
xorps 0x42ec(%rip), %xmm0     # 0x1ef70
movlps %xmm0, 0x8(%rbx)
jmp 0x1acea
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a669
movl (%rbx), %eax
decl %eax
cmpl $0xa, %eax
ja 0x1ad38
leaq 0x55cb(%rip), %rcx      # 0x20274
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, (%rbx)
jmp 0x1ad38
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a85b
pushq $0x15
jmp 0x1acd6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a85b
pushq $0x13
popq %rsi
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
movl %ebp, %r8d
callq 0x1ad77
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x2, (%rbx)
jmp 0x1ad38
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b2d4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a754
movl 0x8(%rbx), %esi
shll $0x17, %esi
orl $0x14, %esi
movq %r14, %rdi
callq 0x1a257
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
jmp 0x1ad38
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ab19
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %eax
movl %esi, 0x14(%rbx)
movl %eax, 0x10(%rbx)
movq %r14, %rdi
callq 0x1b305
movl 0x10(%rbx), %esi
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1b305
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdx, %rdi
callq 0x1ad5f
testl %eax, %eax
je 0x1add3
movq %r12, %rdi
callq 0x1ad5f
testl %eax, %eax
je 0x1add3
movl %r15d, %eax
andl $-0x2, %eax
movsd 0x8(%r12), %xmm1
cmpl $0x10, %eax
jne 0x1ae5f
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x1ae5f
jp 0x1ae5f
xorl %r13d, %r13d
cmpl $0x13, %r15d
movl %ebp, 0x4(%rsp)
je 0x1adf4
cmpl $0x15, %r15d
je 0x1adf4
movq %r14, %rdi
movq %r12, %rsi
callq 0x1a8d7
movl %eax, %r13d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a8d7
movl %eax, %ebp
cmpl %r13d, %eax
movq %r12, %rsi
cmovgq %rbx, %rsi
cmovleq %rbx, %r12
movq %r14, %rdi
callq 0x1a754
movq %r14, %rdi
movq %r12, %rsi
callq 0x1a754
movq %r14, %rdi
movl %r15d, %esi
xorl %edx, %edx
movl %ebp, %ecx
movl %r13d, %r8d
callq 0x1a05b
movl %eax, 0x8(%rbx)
movl $0xb, (%rbx)
movq (%r14), %rax
movq 0x28(%rax), %rax
movslq 0x28(%r14), %rcx
movl 0x4(%rsp), %edx
movl %edx, -0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl $-0xd, %r15d
movsd 0x8(%rbx), %xmm0
movl %r15d, %edi
callq 0xfa52
movsd %xmm0, 0x8(%rbx)
jmp 0x1ae50
// File: /workspace/github_c_makefile_star2_O2/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lcode.c
// Function: luaK_infix
void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
  switch (op) {
    case OPR_AND: {
      luaK_goiftrue(fs, v);
      break;
    }
    case OPR_OR: {
      luaK_goiffalse(fs, v);
      break;
    }
    case OPR_CONCAT: {
      luaK_exp2nextreg(fs, v);  /* operand must be on the `stack' */
      break;
    }
    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
    case OPR_MOD: case OPR_POW: {
      if (!isnumeral(v)) luaK_exp2RK(fs, v);
      break;
    }
    default: {
      luaK_exp2RK(fs, v);
      break;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0xe, %esi
ja 0x1aeac
movl %esi, %eax
leaq 0x5411(%rip), %rcx      # 0x202a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x1ad5f
testl %eax, %eax
je 0x1aeac
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a8d7
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a719
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1aab7
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1abb6
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, 0x4(%rsp)
movq %rdi, %r14
movq %rcx, %rsi
callq 0x1a8d7
movl %eax, %r13d
movq %r14, %rdi
movq %r12, %rsi
callq 0x1a8d7
movl %eax, %ebp
movq %r14, %rdi
movq %r12, %rsi
callq 0x1a754
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a754
testl %r15d, %r15d
sete %al
movl 0x4(%rsp), %esi
cmpl $0x18, %esi
setne %cl
testb %al, %cl
movl %r13d, %ecx
cmovnel %ebp, %ecx
cmovnel %r13d, %ebp
pushq $0x1
popq %rdx
cmovel %r15d, %edx
movq %r14, %rdi
movl %ebp, %r8d
callq 0x1b2c2
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_O2/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 0x1a669
movl (%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0xa, %ecx
ja 0x1b26c
leaq 0x5146(%rip), %rdx      # 0x20318
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %ecx, %ecx
cmpl $0x2, %eax
sete %cl
pushq $0x3
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
xorl %r8d, %r8d
callq 0x1a05b
jmp 0x1b263
movl 0x8(%rbx), %esi
cmpl %ebp, %esi
je 0x1b263
movl %ebp, %eax
shll $0x6, %eax
shll $0x17, %esi
orl %eax, %esi
movq %r14, %rdi
callq 0x1a257
jmp 0x1b263
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 0x1b263
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x19fa4
jmp 0x1b263
movl 0x8(%rbx), %edx
movq %r14, %rdi
movl %ebp, %esi
jmp 0x1b25e
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x1a512
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x1a311
movl %ebp, 0x8(%rbx)
movl $0x6, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7a5f
movq %rax, %r14
testq %rax, %rax
jne 0x1b3c2
leaq 0x4ff6(%rip), %rdx      # 0x203ad
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x8c84
movq %rbx, %rdi
callq 0x7423
leal -0x1(%rax), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b513
testl %eax, %eax
js 0x1b3f3
movl %eax, %r14d
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x7d3d
leal 0x1(%r14), %ebp
notl %r14d
jmp 0x1b404
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7d3d
pushq $0x2
popq %rbp
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x7537
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7a5f
movq %rax, %r14
testq %rax, %rax
jne 0x1b45d
leaq 0x4f5b(%rip), %rdx      # 0x203ad
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x8c84
cmpq %rbx, %r14
je 0x1b47e
movq %r14, %rdi
callq 0x858a
testl %eax, %eax
je 0x1b489
cmpl $0x1, %eax
je 0x1b4b3
leaq 0x4f8f(%rip), %rsi      # 0x20409
pushq $0x4
jmp 0x1b4bc
leaq 0x4bca(%rip), %rsi      # 0x2004f
pushq $0x7
jmp 0x1b4bc
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0xa176
testl %eax, %eax
jle 0x1b4a7
leaq 0x4f5f(%rip), %rsi      # 0x20402
pushq $0x6
jmp 0x1b4bc
movq %r14, %rdi
callq 0x7423
testl %eax, %eax
je 0x1b473
leaq 0x4f3e(%rip), %rsi      # 0x203f8
pushq $0x9
popq %rdx
movq %rbx, %rdi
callq 0x7b27
pushq $0x1
popq %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7a5f
movq %rax, %r14
movq %rbx, %rdi
callq 0x7423
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x1b513
testl %eax, %eax
js 0x1b621
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x76a0
testl %eax, %eax
je 0x1b651
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x8ea0
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x7537
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x8700
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x86c3
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %rsi
callq 0x1c118
movq %rax, %r14
movq %rax, %rdi
callq 0xa16d
movl %eax, %ebp
movq %r14, %rdi
callq 0xa168
testq %rax, %rax
sete %cl
leaq 0x959(%rip), %rdx       # 0x1c157
cmpq %rdx, %rax
sete %al
orb %cl, %al
jne 0x1b81c
leaq 0x4dab(%rip), %rsi      # 0x205ba
pushq $0xd
popq %rdx
movq %rbx, %rdi
callq 0x7b27
jmp 0x1b860
leaq 0x4da5(%rip), %rdx      # 0x205c8
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x9df5
movq %r14, %rdi
callq 0x7d6b
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x738d
pushq $-0x2
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7e73
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7485
xorl %eax, %eax
testb $0x1, %bpl
je 0x1b870
pushq $0x1
popq %rax
movb $0x63, 0xf(%rsp)
testb $0x2, %bpl
je 0x1b87f
movl %eax, %ecx
incl %eax
movb $0x72, 0xf(%rsp,%rcx)
testb $0x4, %bpl
je 0x1b88e
movl %eax, %ecx
incl %eax
movb $0x6c, 0xf(%rsp,%rcx)
movl %eax, %eax
movb $0x0, 0xf(%rsp,%rax)
leaq 0xf(%rsp), %rsi
movq %rbx, %rdi
callq 0x7b76
movq %r14, %rdi
callq 0xa172
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x7af1
pushq $0x3
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c118
movq %rax, %r14
movl (%r15), %r12d
leal 0x2(%r12), %esi
movq %rbx, %rdi
callq 0x93db
movq %rax, %r15
incl %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x7624
movq %rbx, %rdi
cmpl $0x6, %eax
jne 0x1bbf7
movl %r12d, %esi
callq 0x7604
movq %rbx, %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0xa1bc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7b76
pushq $0x1
jmp 0x1bc50
movl %r12d, %esi
callq 0x93db
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0xa176
testl %eax, %eax
je 0x1bc60
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0xa1bc
testq %rax, %rax
je 0x1bc74
movq %rax, %r15
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x738d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7b76
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x7604
pushq $0x2
popq %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4a06(%rip), %rdx      # 0x2066d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x8c84
jmp 0x1bc51
movq %rbx, %rdi
callq 0x7acb
jmp 0x1bbf3
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x7624
cmpl $0x2, %eax
jne 0x1bdaf
leaq 0x490b(%rip), %rdx      # 0x206af
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x8c84
pushq $0x1
popq %rsi
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0x92e7
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7624
testl %eax, %eax
jle 0x1bdda
pushq $0x2
popq %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x92e7
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x7437
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x82f6
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c118
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7624
testl %eax, %eax
jle 0x1bec3
leal 0x2(%r15), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x9264
movq %rax, %r12
pushq $0x6
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x92e7
addl $0x3, %r15d
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x9456
movq %rax, 0x8(%rsp)
pushq $0x63
popq %rsi
movq %r12, %rdi
callq 0x6190
xorl %r13d, %r13d
testq %rax, %rax
setne %r13b
pushq $0x72
popq %rsi
movq %r12, %rdi
callq 0x6190
leal 0x2(%r13), %r15d
testq %rax, %rax
cmovel %r13d, %r15d
pushq $0x6c
popq %rsi
movq %r12, %rdi
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 0x296(%rip), %r13       # 0x1c157
jmp 0x1bed6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7437
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
leaq 0x46eb(%rip), %rdx      # 0x205c8
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x9df5
testl %eax, %eax
jne 0x1bf25
leaq 0x3686(%rip), %rsi      # 0x1f57b
movq %rbx, %rdi
callq 0x7b76
leaq 0x3d31(%rip), %rdx      # 0x1fc35
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x809d
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x7604
movq %rbx, %rdi
pushq $-0x2
popq %rsi
callq 0x824a
movq %r14, %rdi
callq 0x7d6b
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x738d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7604
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x8103
movq %r14, %rdi
movq %r13, %rsi
movl %r12d, %edx
movl %r15d, %ecx
callq 0xa134
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_O2/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 0x1c118
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x93db
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0xa176
testl %eax, %eax
je 0x1c009
leal 0x3(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9331
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7437
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x738d
addl $0x2, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x93db
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0xa311
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7b76
jmp 0x1c01c
leaq 0x465d(%rip), %rdx      # 0x2066d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8c84
movl %eax, %ebp
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c118
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x7967
movq %rax, %r12
testq %rax, %rax
je 0x1c0f0
addl $0x2, %r15d
xorl %edx, %edx
cmpq %rbx, %r14
sete %dl
movq %rbx, %rdi
movl %r15d, %esi
callq 0x9456
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %eax, %ecx
callq 0x8a28
jmp 0x1c108
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7624
testl %eax, %eax
jle 0x1c0c7
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7604
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x7624
cmpl $0x8, %eax
jne 0x1c148
movl $0x1, (%r14)
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a5f
andl $0x0, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4460(%rip), %rdx      # 0x205c8
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x9df5
movq %rbx, %rdi
callq 0x7d6b
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x7e73
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x7624
cmpl $0x6, %eax
jne 0x1c1c1
movslq (%r14), %rax
leaq 0x453d(%rip), %rcx      # 0x206dc
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x7b76
movslq 0x28(%r14), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
js 0x1c1c9
callq 0x7af1
jmp 0x1c1ce
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x7acb
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x835f
// File: /workspace/github_c_makefile_star2_O2/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 0x1c27a
pushq $0x1
popq %rdx
movq %rsi, %rdi
movq %r14, %rsi
callq 0x738d
jmp 0x1c290
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x7604
pushq $-0x3
popq %rsi
movq %r14, %rdi
callq 0x7485
pushq $-0x2
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x809d
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2
popq %rsi
callq 0x93db
movq %rax, %r15
pushq $0x1
popq %rsi
pushq $0x6
popq %rdx
movq %r14, %rdi
callq 0x92e7
pushq $0x1
popq %rsi
movq %r14, %rdi
movl %r15d, %edx
testl %ebx, %ebx
je 0x1c2de
callq 0x87ec
jmp 0x1c2e3
callq 0x88cb
testq %rax, %rax
je 0x1c304
movq %r14, %rdi
movq %rax, %rsi
callq 0x7b76
leal 0x1(%rbx), %ebp
notl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x7537
jmp 0x1c306
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x93db
movq %rax, %r15
pushq $0x6
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x92e7
movq %r14, %rdi
movl %ebp, %esi
callq 0x7604
leaq 0x4347(%rip), %rsi      # 0x20696
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xa351
testl %r15d, %r15d
jle 0x1c36b
movzbl 0x3c(%rsp), %eax
cmpl %eax, %r15d
jle 0x1c37c
leaq 0x4327(%rip), %rdx      # 0x20699
movq %r14, %rdi
movl %ebx, %esi
callq 0x8c84
movl %r15d, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x10919(%rip), %r15     # 0x2ccc0
cmpq $0xb0, %r14
je 0x1c3cd
movq (%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x138fd
orb $0x20, 0x9(%rax)
movb %bpl, 0xa(%rax)
addq $0x8, %r14
incb %bpl
jmp 0x1c3a7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c400
movslq %edx, %rax
leaq 0x4024(%rip), %rcx      # 0x20410
testb $0x4, 0x1(%rax,%rcx)
movq 0x38(%rdi), %rdi
jne 0x1c42e
leaq 0x4403(%rip), %rsi      # 0x20801
jmp 0x1c435
leal -0x101(%rdx), %eax
leaq 0x108b3(%rip), %rcx     # 0x2ccc0
movq (%rcx,%rax,8), %rax
cmpl $0x11d, %edx            # imm = 0x11D
ja 0x1c43c
movq 0x38(%rdi), %rdi
leaq 0x2af6(%rip), %rsi      # 0x1ef1a
movq %rax, %rdx
xorl %eax, %eax
jmp 0xff79
leaq 0x43c7(%rip), %rsi      # 0x207fc
xorl %eax, %eax
jmp 0xff79
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x3c
popq %rdx
movq %r15, %rdi
callq 0xfffd
movq 0x38(%rbx), %rdi
movl 0x4(%rbx), %ecx
leaq 0x23d8(%rip), %rsi      # 0x1e856
movq %r15, %rdx
movq %r14, %r8
xorl %eax, %eax
callq 0xff79
testl %r12d, %r12d
je 0x1c4e8
movq %rax, %r14
movq 0x38(%rbx), %r15
leal -0x11f(%r12), %eax
movq %rbx, %rdi
cmpl $0x2, %eax
ja 0x1c4c9
xorl %esi, %esi
callq 0x1d011
movq 0x38(%rbx), %rdi
movq 0x48(%rbx), %rax
movq (%rax), %rdx
leaq 0x2a5a(%rip), %rsi      # 0x1ef1a
xorl %eax, %eax
callq 0xff79
jmp 0x1c4d1
movl %r12d, %esi
callq 0x1c3d8
leaq 0x438a(%rip), %rsi      # 0x20862
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xff79
movq 0x38(%rbx), %rdi
pushq $0x3
popq %rsi
callq 0xad18
// File: /workspace/github_c_makefile_star2_O2/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 0x13766
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 0x159e4
cmpl $0x0, 0x8(%rax)
je 0x1c549
movq 0x10(%rax), %r14
jmp 0x1c564
pushq $0x1
popq %rcx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
movq 0x18(%rbx), %rax
cmpq $0x0, 0x18(%rax)
jle 0x1c564
movq %rbx, %rdi
callq 0xcd44
addq $-0x10, 0x10(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x30(%rsi)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x4(%rsi)
movq %rcx, 0x58(%rsi)
leaq 0x2291(%rip), %rsi      # 0x1e83b
callq 0x138fd
movq %rax, 0x60(%rbx)
orb $0x20, 0x9(%rax)
movq 0x38(%rbx), %rdi
movq 0x48(%rbx), %rax
movq (%rax), %rsi
movq 0x10(%rax), %rdx
pushq $0x20
popq %rcx
callq 0xed73
movq 0x48(%rbx), %rcx
movq %rax, (%rcx)
movq $0x20, 0x10(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1d097
callq 0x18db8
jmp 0x1d0a6
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
cmpl $0xd, %eax
je 0x1d0b2
cmpl $0xa, %eax
jne 0x1d0d8
cmpl %ebp, %eax
je 0x1d0d8
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x1d0c7
callq 0x18db8
jmp 0x1d0d6
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 0x1d0ef
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x37ae(%rip), %rsi      # 0x208a4
movq %rbx, %rdi
callq 0x1c43d
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
callq 0x1d011
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x1d1b1
callq 0x18db8
jmp 0x1d1c0
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
cmpl $0xd, %eax
je 0x1d1cd
cmpl $0xa, %eax
jne 0x1d1d5
movq %r14, %rdi
callq 0x1d07e
pushq $0xa
popq %rbp
movl (%r14), %esi
cmpl $0xa, %esi
je 0x1d211
cmpl $0xd, %esi
je 0x1d211
cmpl $0x5d, %esi
je 0x1d233
cmpl $-0x1, %esi
je 0x1d2bf
testq %rbx, %rbx
je 0x1d200
movq %r14, %rdi
callq 0x1d011
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x1d242
callq 0x18db8
jmp 0x1d251
movq %r14, %rdi
movl %ebp, %esi
callq 0x1d011
movq %r14, %rdi
callq 0x1d07e
testq %rbx, %rbx
jne 0x1d1d8
movq 0x48(%r14), %rax
andq $0x0, 0x8(%rax)
jmp 0x1d1d8
movq %r14, %rdi
callq 0x1d0fe
cmpl %r15d, %eax
jne 0x1d1d8
jmp 0x1d256
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
jmp 0x1d1d8
movl (%r14), %esi
movq %r14, %rdi
callq 0x1d011
movq 0x40(%r14), %rdi
subq $0x1, (%rdi)
jae 0x1d272
callq 0x18db8
jmp 0x1d281
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x1d2b4
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 0x1c4f4
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testq %rbx, %rbx
leaq 0x360b(%rip), %rax      # 0x208d4
leaq 0x35ed(%rip), %rsi      # 0x208bd
cmoveq %rax, %rsi
movq %r14, %rdi
movl $0x11e, %edx            # imm = 0x11E
callq 0x1c446
// File: /workspace/github_c_makefile_star2_O2/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 0x1d332
movq %rdi, %rbx
movq %rsi, %rdi
movl %r14d, %esi
callq 0x6190
testq %rax, %rax
je 0x1d332
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1d011
movq 0x40(%rbx), %rdi
subq $0x1, (%rdi)
jae 0x1d31e
callq 0x18db8
jmp 0x1d32d
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movzbl (%rax), %eax
movl %eax, (%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
movq 0x48(%rdi), %rax
andq $0x0, 0x8(%rax)
pushq $0x5c
popq %rsi
callq 0x1d011
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r13, %r15
je 0x1d384
movl (%r12,%r13,4), %esi
cmpl $-0x1, %esi
je 0x1d384
movq %r14, %rdi
callq 0x1d011
incq %r13
jmp 0x1d369
movq %r14, %rdi
movq %rbx, %rsi
movl $0x121, %edx            # imm = 0x121
callq 0x1c446
// File: /workspace/github_c_makefile_star2_O2/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 (%rcx), %rax
movq 0x8(%rcx), %rcx
movq %rcx, %rdi
subq $0x1, %rcx
jb 0x1d3b5
cmpb %sil, -0x1(%rax,%rdi)
jne 0x1d39f
movb %dl, -0x1(%rax,%rdi)
jmp 0x1d39f
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1110
movq %rax, %r15
leaq 0x1cdd(%rip), %rsi      # 0x3004
movq %rax, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1190
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1180
// File: /workspace/github_c_makefile_star2_O2/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
cltq
xorl %edx, %edx
xorl %ecx, %ecx
cmpq %rax, %rdx
jge 0x1378
movsbl (%rbx,%rdx), %esi
shll $0x8, %esi
movsbl 0x1(%rbx,%rdx), %edi
addl %edi, %ecx
addl %esi, %ecx
addq $0x2, %rdx
jmp 0x135d
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_O2/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 0x10f0
movl %eax, %edi
callq 0x10d0
callq 0x11e0
subl %ebx, %r14d
jle 0x13cf
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_O2/ulisses[P]ftp-client-server/./geradorErro.h
// Function: inicializa
void inicializa() {
        int i;

        for(i=0; i< MAX; i++) {
                buff[i]=NULL;
        }

        for(i = 0; i < MAX; i++)
                indexx[i] = VAZIO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x3d4b(%rip), %rcx      # 0x5140
cmpq $0x320, %rax            # imm = 0x320
je 0x1408
andq $0x0, (%rax,%rcx)
addq $0x8, %rax
jmp 0x13f5
xorl %eax, %eax
leaq 0x404f(%rip), %rcx      # 0x5460
cmpq $0x190, %rax            # imm = 0x190
je 0x1423
orl $-0x1, (%rax,%rcx)
addq $0x4, %rax
jmp 0x1411
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14d
callq 0x13e8
andl $0x0, 0x3cf3(%rip)      # 0x5134
andl $0x0, 0x3ce8(%rip)      # 0x5130
andl $0x0, 0x3ce9(%rip)      # 0x5138
xorl %eax, %eax
pushq $0x64
popq %r15
leaq 0x4004(%rip), %r12      # 0x5460
cmpl %r14d, %eax
je 0x148d
xorl %edi, %edi
movl %r15d, %esi
callq 0x1398
movslq %eax, %rcx
cmpl $-0x1, (%r12,%rcx,4)
movl 0x3cb7(%rip), %eax      # 0x5130
jne 0x145c
movl $0x1, (%r12,%rcx,4)
incl %eax
movl %eax, 0x3ca5(%rip)      # 0x5130
jmp 0x145c
pushq $0x64
popq %r14
cmpl %ebx, 0x3ca1(%rip)      # 0x5138
je 0x14bc
xorl %edi, %edi
movl %r14d, %esi
callq 0x1398
cltq
cmpl $-0x1, (%r12,%rax,4)
jne 0x1491
movl $0x2, (%r12,%rax,4)
incl 0x3c7e(%rip)            # 0x5138
jmp 0x1491
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1110
movq %rax, %rbx
movl 0x3c3b(%rip), %eax      # 0x5130
orl 0x3c3d(%rip), %eax      # 0x5138
sete %al
movl 0x3c2f(%rip), %r13d     # 0x5134
cmpl $0x64, %r13d
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1525
movl %r12d, %edi
movl %r15d, %esi
callq 0x1425
movl 0x3c0f(%rip), %r13d     # 0x5134
movslq %r13d, %r15
leaq 0x3f31(%rip), %r12      # 0x5460
movl (%r12,%r15,4), %eax
leaq 0x3c06(%rip), %rcx      # 0x5140
cmpl $0x1, %eax
jne 0x1566
incb (%r14)
movl 0x3beb(%rip), %r13d     # 0x5134
movslq %r13d, %r15
movq %r14, (%rcx,%r15,8)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1050
leaq 0x3bde(%rip), %rcx      # 0x5140
movl (%r12,%r15,4), %eax
cmpl $-0x1, %eax
je 0x1579
cmpl $0x2, %eax
jne 0x1588
andq $0x0, (%rcx,%r15,8)
xorl %ebx, %ebx
jmp 0x1588
movq %r14, (%rcx,%r15,8)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1050
incl %r13d
movl %r13d, 0x3ba2(%rip)     # 0x5134
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1110
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movw $0x63, 0x18(%rax)
popq %rbp
retq