LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: generic_reader
static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
  (void)(ud);  /* not used */
  luaL_checkstack(L, 2, "too many nested functions");
  lua_pushvalue(L, 1);  /* get function */
  lua_call(L, 0, 1);  /* call it */
  if (lua_isnil(L, -1)) {
    lua_pop(L, 1);  /* pop result */
    *size = 0;
    return NULL;
  }
  else if (!lua_isstring(L, -1))
    luaL_error(L, "reader function must return a string");
  lua_replace(L, RESERVEDSLOT);  /* save string in reserved slot */
  return lua_tolstring(L, RESERVEDSLOT, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0xef3b(%rip), %rdx      # 0x3625f
callq 0x1f930
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6190
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x8140
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x61f0
cmpl $0x0, %eax
jne 0x27385
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x273e3
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6360
cmpl $0x0, %eax
jne 0x273aa
movq -0x10(%rbp), %rdi
leaq 0xeed6(%rip), %rsi      # 0x36279
movb $0x0, %al
callq 0x1fbf0
jmp 0x273ac
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x5, %edx
callq 0x60d0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x5, %esi
callq 0x67d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: pairsmeta
static int pairsmeta (lua_State *L, const char *method, int iszero,
                      lua_CFunction iter) {
  if (luaL_getmetafield(L, 1, method) == LUA_TNIL) {  /* no metamethod? */
    luaL_checktype(L, 1, LUA_TTABLE);  /* argument must be a table */
    lua_pushcfunction(L, iter);  /* will return generator, */
    lua_pushvalue(L, 1);  /* state, */
    if (iszero) lua_pushinteger(L, 0);  /* and initial value */
    else lua_pushnil(L);
  }
  else {
    lua_pushvalue(L, 1);  /* argument 'self' to metamethod */
    lua_call(L, 1, 3);  /* get 3 values from metamethod */
  }
  return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
callq 0x21190
cmpl $0x0, %eax
jne 0x2746e
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x203e0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x6ea0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6190
cmpl $0x0, -0x14(%rbp)
je 0x27463
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6be0
jmp 0x2746c
movq -0x8(%rbp), %rdi
callq 0x6b60
jmp 0x27497
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6190
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x3, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x8140
movl $0x3, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: finishpcall
static int finishpcall (lua_State *L, int status, lua_KContext extra) {
  if (status != LUA_OK && status != LUA_YIELD) {  /* error? */
    lua_pushboolean(L, 0);  /* first result (false) */
    lua_pushvalue(L, -2);  /* error message */
    return 2;  /* return false, msg */
  }
  else
    return lua_gettop(L) - (int)extra;  /* return all results */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x274f1
cmpl $0x1, -0x14(%rbp)
je 0x274f1
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x6fc0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6190
movl $0x2, -0x4(%rbp)
jmp 0x27503
movq -0x10(%rbp), %rdi
callq 0x5d90
movq -0x20(%rbp), %rcx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: b_str2int
static const char *b_str2int (const char *s, int base, lua_Integer *pn) {
  lua_Unsigned n = 0;
  int neg = 0;
  s += strspn(s, SPACECHARS);  /* skip initial spaces */
  if (*s == '-') { s++; neg = 1; }  /* handle signal */
  else if (*s == '+') s++;
  if (!isalnum((unsigned char)*s))  /* no digit? */
    return NULL;
  do {
    int digit = (isdigit((unsigned char)*s)) ? *s - '0'
                   : (toupper((unsigned char)*s) - 'A') + 10;
    if (digit >= base) return NULL;  /* invalid numeral */
    n = n * base + digit;
    s++;
  } while (isalnum((unsigned char)*s));
  s += strspn(s, SPACECHARS);  /* skip trailing spaces */
  *pn = (lua_Integer)((neg) ? (0u - n) : n);
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xee0e(%rip), %rsi      # 0x3634b
callq 0x51e0
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x2756b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0x27585
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x27583
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x27585
callq 0x5500
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x275b0
movq $0x0, -0x8(%rbp)
jmp 0x2769b
jmp 0x275b2
callq 0x5500
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x275e1
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x34(%rbp)
jmp 0x275f6
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x50c0
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x27611
movq $0x0, -0x8(%rbp)
jmp 0x2769b
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq %rcx, %rax
movslq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
callq 0x5500
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x275b2
movq -0x10(%rbp), %rdi
leaq 0xecea(%rip), %rsi      # 0x3634b
callq 0x51e0
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x27680
xorl %eax, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x27688
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lcorolib.c
// Function: luaB_cocreate
static int luaB_cocreate (lua_State *L) {
  lua_State *NL;
  luaL_checktype(L, 1, LUA_TFUNCTION);
  NL = lua_newthread(L);
  lua_pushvalue(L, 1);  /* move function to top */
  lua_xmove(L, NL, 1);  /* move function from L to NL */
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x203e0
movq -0x8(%rbp), %rdi
callq 0x15ac0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6190
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x5c20
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lcorolib.c
// Function: luaB_coresume
static int luaB_coresume (lua_State *L) {
  lua_State *co = getco(L);
  int r;
  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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x279f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5d90
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %edx
subl $0x1, %edx
callq 0x27a50
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x277d4
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x6fc0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5e60
movl $0x2, -0x4(%rbp)
jmp 0x27803
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6fc0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
xorl %esi, %esi
subl %eax, %esi
movl $0x1, %edx
callq 0x5e60
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lcorolib.c
// Function: luaB_costatus
static int luaB_costatus (lua_State *L) {
  lua_State *co = getco(L);
  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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x279f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x2787b
movq -0x8(%rbp), %rdi
leaq 0xe9cf(%rip), %rsi      # 0x36240
callq 0x6ce0
jmp 0x27920
movq -0x10(%rbp), %rdi
callq 0x85b0
movl %eax, %ecx
movl %ecx, -0x94(%rbp)
testl %eax, %eax
je 0x278b1
jmp 0x27892
movl -0x94(%rbp), %eax
subl $0x1, %eax
jne 0x2790e
jmp 0x2789f
movq -0x8(%rbp), %rdi
leaq 0xeb4b(%rip), %rsi      # 0x363f5
callq 0x6ce0
jmp 0x2791e
movq -0x10(%rbp), %rdi
xorl %esi, %esi
leaq -0x90(%rbp), %rdx
callq 0x9070
cmpl $0x0, %eax
jle 0x278da
movq -0x8(%rbp), %rdi
leaq 0xeb2c(%rip), %rsi      # 0x363ff
callq 0x6ce0
jmp 0x2790c
movq -0x10(%rbp), %rdi
callq 0x5d90
cmpl $0x0, %eax
jne 0x278fa
movq -0x8(%rbp), %rdi
leaq 0xeb13(%rip), %rsi      # 0x36406
callq 0x6ce0
jmp 0x2790a
movq -0x8(%rbp), %rdi
leaq 0xeaf0(%rip), %rsi      # 0x363f5
callq 0x6ce0
jmp 0x2790c
jmp 0x2791e
movq -0x8(%rbp), %rdi
leaq 0xeaed(%rip), %rsi      # 0x36406
callq 0x6ce0
jmp 0x27920
movl $0x1, %eax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lcorolib.c
// Function: auxresume
static int auxresume (lua_State *L, lua_State *co, int narg) {
  int status;
  if (!lua_checkstack(co, narg)) {
    lua_pushliteral(L, "too many arguments to resume");
    return -1;  /* error flag */
  }
  if (lua_status(co) == LUA_OK && lua_gettop(co) == 0) {
    lua_pushliteral(L, "cannot resume dead coroutine");
    return -1;  /* error flag */
  }
  lua_xmove(L, co, narg);
  status = lua_resume(co, L, narg);
  if (status == LUA_OK || status == LUA_YIELD) {
    int nres = lua_gettop(co);
    if (!lua_checkstack(L, nres + 1)) {
      lua_pop(co, nres);  /* remove results anyway */
      lua_pushliteral(L, "too many results to resume");
      return -1;  /* error flag */
    }
    lua_xmove(co, L, nres);  /* move yielded values */
    return nres;
  }
  else {
    lua_xmove(co, L, 1);  /* move error message */
    return -1;  /* error flag */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5b00
cmpl $0x0, %eax
jne 0x27a90
movq -0x10(%rbp), %rdi
leaq 0xe93e(%rip), %rsi      # 0x363bd
callq 0x6ce0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27b72
movq -0x18(%rbp), %rdi
callq 0x85b0
cmpl $0x0, %eax
jne 0x27ac8
movq -0x18(%rbp), %rdi
callq 0x5d90
cmpl $0x0, %eax
jne 0x27ac8
movq -0x10(%rbp), %rdi
leaq 0xcb67(%rip), %rsi      # 0x3461e
callq 0x6ce0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27b72
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x5c20
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xbcd0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x27af7
cmpl $0x1, -0x20(%rbp)
jne 0x27b59
movq -0x18(%rbp), %rdi
callq 0x5d90
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
addl $0x1, %esi
callq 0x5b00
cmpl $0x0, %eax
jne 0x27b41
movq -0x18(%rbp), %rdi
xorl %esi, %esi
subl -0x24(%rbp), %esi
subl $0x1, %esi
callq 0x5dc0
movq -0x10(%rbp), %rdi
leaq 0xe8a7(%rip), %rsi      # 0x363da
callq 0x6ce0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27b72
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x5c20
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x27b72
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x5c20
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/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_type(L, -1) == LUA_TSTRING) {  /* 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x6a50
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5d90
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %edx
callq 0x27a50
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x27c1f
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x61f0
cmpl $0x4, %eax
jne 0x27c11
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1fdc0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5e60
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x8820
movq -0x10(%rbp), %rdi
callq 0x8790
movl %eax, -0x4(%rbp)
jmp 0x27c25
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: db_debug
static int db_debug (lua_State *L) {
  for (;;) {
    char buffer[250];
    lua_writestringerror("%s", "lua_debug> ");
    if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
        strcmp(buffer, "cont\n") == 0)
      return 0;
    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
        lua_pcall(L, 0, 0, 0))
      lua_writestringerror("%s\n", lua_tostring(L, -1));
    lua_settop(L, 0);  /* remove eventual returns */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq 0x1b35a(%rip), %rax     # 0x42ff0
movq (%rax), %rdi
leaq 0xf9b0(%rip), %rsi      # 0x37650
leaq 0xe7ea(%rip), %rdx      # 0x36491
movb $0x0, %al
callq 0x52a0
movq 0x1b33b(%rip), %rax     # 0x42ff0
movq (%rax), %rdi
callq 0x5340
leaq -0x110(%rbp), %rdi
movq 0x1b305(%rip), %rax     # 0x42fd0
movq (%rax), %rdx
movl $0xfa, %esi
callq 0x5240
cmpq $0x0, %rax
je 0x27cf6
leaq -0x110(%rbp), %rdi
leaq 0xe7b1(%rip), %rsi      # 0x3649d
callq 0x5270
cmpl $0x0, %eax
jne 0x27d01
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x5150
movq -0x120(%rbp), %rdi
movq -0x118(%rbp), %rsi
movq %rax, %rdx
leaq 0xe765(%rip), %rcx      # 0x364a3
xorl %eax, %eax
movl %eax, %r8d
callq 0x21090
cmpl $0x0, %eax
jne 0x27d69
movq -0x8(%rbp), %rdi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %esi
movl %ecx, %edx
movq %r9, %r8
callq 0x8210
cmpl $0x0, %eax
je 0x27db3
movq 0x1b280(%rip), %rax     # 0x42ff0
movq (%rax), %rax
movq %rax, -0x128(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x67d0
movq -0x128(%rbp), %rdi
movq %rax, %rdx
leaq 0xd873(%rip), %rsi      # 0x35610
movb $0x0, %al
callq 0x52a0
movq 0x1b245(%rip), %rax     # 0x42ff0
movq (%rax), %rdi
callq 0x5340
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5dc0
jmp 0x27c8f
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: db_getuservalue
static int db_getuservalue (lua_State *L) {
  if (lua_type(L, 1) != LUA_TUSERDATA)
    lua_pushnil(L);
  else
    lua_getuservalue(L, 1);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
cmpl $0x7, %eax
je 0x27dfa
movq -0x8(%rbp), %rdi
callq 0x6b60
jmp 0x27e08
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x7760
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/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)  /* no hook? */
    lua_pushnil(L);
  else if (hook != hookf)  /* external hook? */
    lua_pushliteral(L, "external hook");
  else {  /* hook table must exist */
    lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY);
    checkstack(L, L1, 1);
    lua_pushthread(L1); lua_xmove(L1, L, 1);
    lua_rawget(L, -2);   /* 1st result = hooktable[L1] */
    lua_remove(L, -2);  /* remove hook table */
  }
  lua_pushstring(L, unmakemask(mask, buff));  /* 2nd result = mask */
  lua_pushinteger(L, lua_gethookcount(L1));  /* 3rd result = count */
  return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x28a70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9030
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9010
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x27e6b
movq -0x8(%rbp), %rdi
callq 0x6b60
jmp 0x27efd
leaq 0xc5e(%rip), %rax       # 0x28ad0
cmpq %rax, -0x30(%rbp)
je 0x27e8a
movq -0x8(%rbp), %rdi
leaq 0xe631(%rip), %rsi      # 0x364b4
callq 0x6ce0
jmp 0x27efb
movq -0x8(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0xe6f6(%rip), %rdx      # 0x36590
callq 0x7540
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x28b70
movq -0x18(%rbp), %rdi
callq 0x7050
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1, %edx
callq 0x5c20
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7440
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5e60
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
jmp 0x27efd
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %edi
leaq -0x1d(%rbp), %rsi
callq 0x28bc0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x6ce0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9050
movq -0x38(%rbp), %rdi
movslq %eax, %rsi
callq 0x6be0
movl $0x3, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/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 = (int)luaL_checkinteger(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;  /* return only name (there is no value) */
  }
  else {  /* stack-level argument */
    int level = (int)luaL_checkinteger(L, arg + 1);
    if (!lua_getstack(L1, level, &ar))  /* out of range? */
      return luaL_argerror(L, arg+1, "level out of range");
    checkstack(L, L1, 1);
    name = lua_getlocal(L1, &ar, nvar);
    if (name) {
      lua_xmove(L1, L, 1);  /* move local value */
      lua_pushstring(L, name);  /* push name */
      lua_rotate(L, -2, 1);  /* re-order */
      return 2;
    }
    else {
      lua_pushnil(L);  /* no name (nor value) */
      return 1;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x28a70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x2, %esi
callq 0x20550
movl %eax, -0xac(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x61f0
cmpl $0x6, %eax
jne 0x28321
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x6190
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
movl -0xac(%rbp), %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x9120
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x6ce0
movl $0x1, -0x4(%rbp)
jmp 0x283f6
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x20550
movl %eax, -0xb0(%rbp)
movq -0x20(%rbp), %rdi
movl -0xb0(%rbp), %esi
leaq -0xa0(%rbp), %rdx
callq 0x9070
cmpl $0x0, %eax
jne 0x2836f
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
leaq 0xe1ec(%rip), %rdx      # 0x3654e
callq 0x1fab0
movl %eax, -0x4(%rbp)
jmp 0x283f6
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x28b70
movq -0x20(%rbp), %rdi
movl -0xac(%rbp), %edx
leaq -0xa0(%rbp), %rsi
callq 0x9120
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
je 0x283e6
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x5c20
movq -0x10(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x6ce0
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5e60
movl $0x2, -0x4(%rbp)
jmp 0x283f6
movq -0x10(%rbp), %rdi
callq 0x6b60
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: db_getmetatable
static int db_getmetatable (lua_State *L) {
  luaL_checkany(L, 1);
  if (!lua_getmetatable(L, 1)) {
    lua_pushnil(L);  /* no metatable */
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x20470
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x7680
cmpl $0x0, %eax
jne 0x28476
movq -0x8(%rbp), %rdi
callq 0x6b60
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: db_upvaluejoin
static int db_upvaluejoin (lua_State *L) {
  int n1 = checkupval(L, 1, 2);
  int n2 = checkupval(L, 3, 4);
  luaL_argcheck(L, !lua_iscfunction(L, 1), 1, "Lua function expected");
  luaL_argcheck(L, !lua_iscfunction(L, 3), 3, "Lua function expected");
  lua_upvaluejoin(L, 1, n1, 3, n2);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x28e30
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
movl $0x4, %edx
callq 0x28e30
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6270
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x28520
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xe04f(%rip), %rdx      # 0x36561
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x6270
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
je 0x2855b
movq -0x8(%rbp), %rdi
movl $0x3, %esi
leaq 0xe014(%rip), %rdx      # 0x36561
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %r8d
movl $0x1, %esi
movl $0x3, %ecx
callq 0x8e80
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: db_setuservalue
static int db_setuservalue (lua_State *L) {
  luaL_checktype(L, 1, LUA_TUSERDATA);
  luaL_checkany(L, 2);
  lua_settop(L, 2);
  lua_setuservalue(L, 1);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x7, %edx
callq 0x203e0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x20470
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x5dc0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x8070
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: db_setlocal
static int db_setlocal (lua_State *L) {
  int arg;
  const char *name;
  lua_State *L1 = getthread(L, &arg);
  lua_Debug ar;
  int level = (int)luaL_checkinteger(L, arg + 1);
  int nvar = (int)luaL_checkinteger(L, arg + 2);
  if (!lua_getstack(L1, level, &ar))  /* out of range? */
    return luaL_argerror(L, arg+1, "level out of range");
  luaL_checkany(L, arg+3);
  lua_settop(L, arg+3);
  checkstack(L, L1, 1);
  lua_xmove(L, L1, 1);
  name = lua_setlocal(L1, &ar, nvar);
  if (name == NULL)
    lua_pop(L1, 1);  /* pop value (if not popped by 'lua_setlocal') */
  lua_pushstring(L, name);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x28a70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x20550
movl %eax, -0xac(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x2, %esi
callq 0x20550
movl %eax, -0xb0(%rbp)
movq -0x28(%rbp), %rdi
movl -0xac(%rbp), %esi
leaq -0xa8(%rbp), %rdx
callq 0x9070
cmpl $0x0, %eax
jne 0x28873
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
leaq 0xdce8(%rip), %rdx      # 0x3654e
callq 0x1fab0
movl %eax, -0x4(%rbp)
jmp 0x288f8
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x3, %esi
callq 0x20470
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x3, %esi
callq 0x5dc0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x28b70
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x5c20
movq -0x28(%rbp), %rdi
movl -0xb0(%rbp), %edx
leaq -0xa8(%rbp), %rsi
callq 0x9390
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x288e4
movq -0x28(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6ce0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: db_setmetatable
static int db_setmetatable (lua_State *L) {
  int t = lua_type(L, 2);
  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
                    "nil or table expected");
  lua_settop(L, 2);
  lua_setmetatable(L, 1);
  return 1;  /* return 1st argument */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x61f0
movl %eax, -0xc(%rbp)
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
je 0x28961
movb $0x1, %al
cmpl $0x5, -0xc(%rbp)
movb %al, -0xd(%rbp)
je 0x28961
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0xd9ac(%rip), %rdx      # 0x362ff
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x5dc0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x7ef0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/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 = (int)luaL_optinteger(L, arg + 2, (L == L1) ? 1 : 0);
    luaL_traceback(L, L1, msg, level);
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x28a70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x67d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x28a20
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x61f0
cmpl $0x0, %eax
jle 0x28a20
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x6190
jmp 0x28a5e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %r8
xorl %eax, %eax
movl $0x1, %ecx
cmpq %r8, %rdx
cmovel %ecx, %eax
movslq %eax, %rdx
callq 0x205e0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x1f680
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/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;  /* function will operate over current thread */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
cmpl $0x8, %eax
jne 0x28ab1
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6a50
movq %rax, -0x8(%rbp)
jmp 0x28ac3
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: hookf
static void hookf (lua_State *L, lua_Debug *ar) {
  static const char *const hooknames[] =
    {"call", "return", "line", "count", "tail call"};
  lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY);
  lua_pushthread(L);
  if (lua_rawget(L, -2) == LUA_TFUNCTION) {  /* is there a hook function? */
    lua_pushstring(L, hooknames[(int)ar->event]);  /* push event name */
    if (ar->currentline >= 0)
      lua_pushinteger(L, ar->currentline);  /* push current line */
    else lua_pushnil(L);
    lua_assert(lua_getinfo(L, "lS", ar));
    lua_call(L, 2, 0);  /* call hook function */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0xdaa0(%rip), %rdx      # 0x36590
callq 0x7540
movq -0x8(%rbp), %rdi
callq 0x7050
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7440
cmpl $0x6, %eax
jne 0x28b6a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
leaq 0x19b3d(%rip), %rax     # 0x42660
movq (%rax,%rcx,8), %rsi
callq 0x6ce0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jl 0x28b49
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x28(%rax), %rsi
callq 0x6be0
jmp 0x28b52
movq -0x8(%rbp), %rdi
callq 0x6b60
movq -0x8(%rbp), %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x8140
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: unmakemask
static char *unmakemask (int mask, char *smask) {
  int i = 0;
  if (mask & LUA_MASKCALL) smask[i++] = 'c';
  if (mask & LUA_MASKRET) smask[i++] = 'r';
  if (mask & LUA_MASKLINE) smask[i++] = 'l';
  smask[i] = '\0';
  return smask;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x28bf3
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x63, (%rax,%rcx)
movl -0x4(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x28c14
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x72, (%rax,%rcx)
movl -0x4(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x28c35
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x6c, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: treatstackoption
static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
  if (L == L1)
    lua_rotate(L, -2, 1);  /* exchange object and table */
  else
    lua_xmove(L1, L, 1);  /* move object to the "main" stack */
  lua_setfield(L, -2, fname);  /* put object into table */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x28d43
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5e60
jmp 0x28d55
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1, %edx
callq 0x5c20
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7ae0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: auxupvalue
static int auxupvalue (lua_State *L, int get) {
  const char *name;
  int n = (int)luaL_checkinteger(L, 2);  /* upvalue index */
  luaL_checktype(L, 1, LUA_TFUNCTION);  /* closure */
  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));  /* no-op if get is false */
  return get + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x20550
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x203e0
cmpl $0x0, -0x14(%rbp)
je 0x28dc0
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %edx
movl $0x1, %esi
callq 0x8a20
movq %rax, -0x30(%rbp)
jmp 0x28dd5
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %edx
movl $0x1, %esi
callq 0x8c30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x28ded
movl $0x0, -0x4(%rbp)
jmp 0x28e1b
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6ce0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
xorl %esi, %esi
subl %eax, %esi
movl $0x1, %edx
callq 0x5e60
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: checkupval
static int checkupval (lua_State *L, int argf, int argnup) {
  int nup = (int)luaL_checkinteger(L, argnup);  /* upvalue index */
  luaL_checktype(L, argf, LUA_TFUNCTION);  /* closure */
  luaL_argcheck(L, (lua_getupvalue(L, argf, nup) != NULL), argnup,
                   "invalid upvalue index");
  return nup;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x20550
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x6, %edx
callq 0x203e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x8a20
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x15(%rbp)
jne 0x28e9b
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
leaq 0xd6ea(%rip), %rdx      # 0x36577
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/ldblib.c
// Function: makemask
static int makemask (const char *smask, int count) {
  int mask = 0;
  if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
  if (strchr(smask, 'r')) mask |= LUA_MASKRET;
  if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
  if (count > 0) mask |= LUA_MASKCOUNT;
  return mask;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x63, %esi
callq 0x5170
cmpq $0x0, %rax
je 0x28ee3
movl -0x10(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x72, %esi
callq 0x5170
cmpq $0x0, %rax
je 0x28f00
movl -0x10(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x6c, %esi
callq 0x5170
cmpq $0x0, %rax
je 0x28f1d
movl -0x10(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x28f2c
movl -0x10(%rbp), %eax
orl $0x8, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: luaopen_io
LUAMOD_API int luaopen_io (lua_State *L) {
  luaL_newlib(L, iolib);  /* new module */
  createmeta(L);
  /* create (and set) default files */
  createstdfile(L, stdin, IO_INPUT, "stdin");
  createstdfile(L, stdout, IO_OUTPUT, "stdout");
  createstdfile(L, stderr, NULL, "stderr");
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movsd 0xd428(%rip), %xmm0     # 0x36380
movl $0x88, %esi
callq 0x218a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xb, %edx
callq 0x75e0
movq -0x8(%rbp), %rdi
leaq 0x19713(%rip), %rsi     # 0x42690
xorl %edx, %edx
callq 0x214b0
movq -0x8(%rbp), %rdi
callq 0x29000
movq -0x8(%rbp), %rdi
movq 0x1a038(%rip), %rax     # 0x42fd0
movq (%rax), %rsi
leaq 0xd696(%rip), %rdx      # 0x36638
leaq 0xc756(%rip), %rcx      # 0x356ff
callq 0x29070
movq -0x8(%rbp), %rdi
movq 0x1a00f(%rip), %rax     # 0x42fc8
movq (%rax), %rsi
leaq 0xd67f(%rip), %rdx      # 0x36642
leaq 0xd683(%rip), %rcx      # 0x3664d
callq 0x29070
movq -0x8(%rbp), %rdi
movq 0x1a016(%rip), %rax     # 0x42ff0
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq 0xd66c(%rip), %rcx      # 0x36654
callq 0x29070
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: createmeta
static void createmeta (lua_State *L) {
  luaL_newmetatable(L, LUA_FILEHANDLE);  /* create metatable for file handles */
  lua_pushvalue(L, -1);  /* push metatable */
  lua_setfield(L, -2, "__index");  /* metatable.__index = metatable */
  luaL_setfuncs(L, flib, 0);  /* add file methods to new metatable */
  lua_pop(L, 1);  /* pop new metatable */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd664(%rip), %rsi      # 0x3667b
callq 0x1ffa0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6190
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xc10f(%rip), %rdx      # 0x35149
callq 0x7ae0
movq -0x8(%rbp), %rdi
leaq 0x19706(%rip), %rsi     # 0x42750
xorl %edx, %edx
callq 0x214b0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: createstdfile
static void createstdfile (lua_State *L, FILE *f, const char *k,
                           const char *fname) {
  LStream *p = newprefile(L);
  p->f = f;
  p->closef = &io_noclose;
  if (k != NULL) {
    lua_pushvalue(L, -1);
    lua_setfield(L, LUA_REGISTRYINDEX, k);  /* add file to registry */
  }
  lua_setfield(L, -2, fname);  /* add file to module */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x298a0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
leaq 0x1865(%rip), %rcx      # 0x2a910
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x290d6
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6190
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x7ae0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7ae0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: io_close
static int io_close (lua_State *L) {
  if (lua_isnone(L, 1))  /* no argument? */
    lua_getfield(L, LUA_REGISTRYINDEX, IO_OUTPUT);  /* use standard output */
  tofile(L);  /* make sure argument is an open stream */
  return aux_close(L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
cmpl $-0x1, %eax
jne 0x29124
movq -0x8(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0xd523(%rip), %rdx      # 0x36642
callq 0x72f0
movq -0x8(%rbp), %rdi
callq 0x29630
movq -0x8(%rbp), %rdi
callq 0x29680
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: io_lines
static int io_lines (lua_State *L) {
  int toclose;
  if (lua_isnone(L, 1)) lua_pushnil(L);  /* at least one argument */
  if (lua_isnil(L, 1)) {  /* no file name? */
    lua_getfield(L, LUA_REGISTRYINDEX, IO_INPUT);  /* get default input */
    lua_replace(L, 1);  /* put it at index 1 */
    tofile(L);  /* check that it's a valid file handle */
    toclose = 0;  /* do not close it after iteration */
  }
  else {  /* open a new file */
    const char *filename = luaL_checkstring(L, 1);
    opencheck(L, filename, "r");
    lua_replace(L, 1);  /* put file at index 1 */
    toclose = 1;  /* close it after iteration */
  }
  aux_lines(L, toclose);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
cmpl $-0x1, %eax
jne 0x291e8
movq -0x8(%rbp), %rdi
callq 0x6b60
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
cmpl $0x0, %eax
jne 0x29243
movq -0x8(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0xd42d(%rip), %rdx      # 0x36638
callq 0x72f0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x60d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movq -0x8(%rbp), %rdi
callq 0x29630
movl $0x0, -0xc(%rbp)
jmp 0x29295
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x20390
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0xadce(%rip), %rdx      # 0x34036
callq 0x297e0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x60d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5dc0
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x29950
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: io_open
static int io_open (lua_State *L) {
  const char *filename = luaL_checkstring(L, 1);
  const char *mode = luaL_optstring(L, 2, "r");
  LStream *p = newfile(L);
  const char *md = mode;  /* to traverse/check mode */
  luaL_argcheck(L, l_checkmode(md), 2, "invalid mode");
  p->f = fopen(filename, mode);
  return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x20390
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0xad54(%rip), %rdx      # 0x34036
xorl %eax, %eax
movl %eax, %ecx
callq 0x20310
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29860
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x29382
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl (%rax), %esi
leaq 0xd3ed(%rip), %rdi      # 0x36716
callq 0x5170
cmpq $0x0, %rax
je 0x29382
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x29354
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x29354
jmp 0x29382
movq -0x28(%rbp), %rdi
leaq 0xe21f(%rip), %rsi      # 0x3757e
callq 0x51e0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5150
movq -0x38(%rbp), %rcx
movq %rax, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x29(%rbp)
je 0x293a0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0xd388(%rip), %rdx      # 0x3671a
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x52d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x293d8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x1fe50
movl %eax, -0x3c(%rbp)
jmp 0x293e2
movl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x293e2
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: io_popen
static int io_popen (lua_State *L) {
  const char *filename = luaL_checkstring(L, 1);
  const char *mode = luaL_optstring(L, 2, "r");
  LStream *p = newprefile(L);
  p->f = l_popen(L, filename, mode);
  p->closef = &io_pclose;
  return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x20390
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0xabe4(%rip), %rdx      # 0x34036
xorl %eax, %eax
movl %eax, %ecx
callq 0x20310
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x298a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd2b0(%rip), %rsi      # 0x36727
movb $0x0, %al
callq 0x1fbf0
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
leaq 0xf8c(%rip), %rcx       # 0x2a420
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x294b6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x1fe50
movl %eax, -0x24(%rbp)
jmp 0x294c0
movl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x294c0
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)