LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_next
static int luaB_next (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  lua_settop(L, 2);  /* create a 2nd argument if there isn't one */
  if (lua_next(L, 1))
    return 2;
  else {
    lua_pushnil(L);
    return 1;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x1456f
movl $0x2, %ebp
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5d51
movq %rbx, %rdi
movl $0x1, %esi
callq 0x719c
testl %eax, %eax
jne 0x182c4
movq %rbx, %rdi
callq 0x63bd
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_pcall
static int luaB_pcall (lua_State *L) {
  int status;
  luaL_checkany(L, 1);
  lua_pushboolean(L, 1);  /* first result if no errors */
  lua_insert(L, 1);  /* put it in place */
  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall);
  return finishpcall(L, status, 0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x145a3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x660e
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x5da2
movq %rbx, %rdi
callq 0x5d3d
leal -0x2(%rax), %esi
leaq 0x7e6(%rip), %r9        # 0x18b68
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6e8a
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x18b68
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_print
static int luaB_print (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  lua_getglobal(L, "tostring");
  for (i=1; i<=n; i++) {
    const char *s;
    size_t l;
    lua_pushvalue(L, -1);  /* function to be called */
    lua_pushvalue(L, i);   /* value to print */
    lua_call(L, 1, 1);
    s = lua_tolstring(L, -1, &l);  /* get result */
    if (s == NULL)
      return luaL_error(L, "'tostring' must return a string to 'print'");
    if (i>1) lua_writestring("\t", 1);
    lua_writestring(s, l);
    lua_pop(L, 1);  /* pop result */
  }
  lua_writeline();
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5d3d
movl %eax, %r14d
leaq 0x9f2b(%rip), %rsi      # 0x222e9
movq %rbx, %rdi
callq 0x6660
testl %r14d, %r14d
jle 0x18495
negl %r14d
movl $0x1, %r12d
movq %rsp, %r15
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5f5b
movq %rbx, %rdi
movl %r12d, %esi
callq 0x5f5b
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6e22
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x6249
movq %rax, %r13
testq %rax, %rax
je 0x18466
cmpl $0x2, %r12d
jb 0x1843c
movq 0x16b99(%rip), %rax     # 0x2efc8
movq (%rax), %rsi
movl $0x9, %edi
callq 0x5220
movq (%rsp), %rdx
movq 0x16b81(%rip), %rax     # 0x2efc8
movq (%rax), %rcx
movl $0x1, %esi
movq %r13, %rdi
callq 0x54a0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
jmp 0x18479
movq %rbx, %rdi
leaq 0xa6c6(%rip), %rsi      # 0x22b36
xorl %eax, %eax
callq 0x13f8e
movl %eax, %ebp
testq %r13, %r13
je 0x184b3
leal (%r14,%r12), %eax
incl %eax
movl %r12d, %ecx
incl %ecx
movl %ecx, %r12d
cmpl $0x1, %eax
jne 0x183db
movq 0x16b2c(%rip), %rbx     # 0x2efc8
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x5220
movq (%rbx), %rdi
callq 0x5360
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_rawequal
static int luaB_rawequal (lua_State *L) {
  luaL_checkany(L, 1);
  luaL_checkany(L, 2);
  lua_pushboolean(L, lua_rawequal(L, 1, 2));
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x145a3
movq %rbx, %rdi
movl $0x2, %esi
callq 0x145a3
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x603d
movq %rbx, %rdi
movl %eax, %esi
callq 0x660e
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_rawlen
static int luaB_rawlen (lua_State *L) {
  int t = lua_type(L, 1);
  luaL_argcheck(L, t == LUA_TTABLE || t == LUA_TSTRING, 1,
                   "table or string expected");
  lua_pushinteger(L, lua_rawlen(L, 1));
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5f7f
andl $-0x2, %eax
cmpl $0x4, %eax
je 0x1852c
leaq 0xa642(%rip), %rdx      # 0x22b61
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13ea8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x62c9
movq %rbx, %rdi
movq %rax, %rsi
callq 0x63e6
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_rawget
static int luaB_rawget (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_checkany(L, 2);
  lua_settop(L, 2);
  lua_rawget(L, 1);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x1456f
movq %rbx, %rdi
movl $0x2, %esi
callq 0x145a3
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5d51
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6815
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_rawset
static int luaB_rawset (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_checkany(L, 2);
  luaL_checkany(L, 3);
  lua_settop(L, 3);
  lua_rawset(L, 1);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x1456f
movq %rbx, %rdi
movl $0x2, %esi
callq 0x145a3
movq %rbx, %rdi
movl $0x3, %esi
callq 0x145a3
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5d51
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6c1a
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_select
static int luaB_select (lua_State *L) {
  int n = lua_gettop(L);
  if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
    lua_pushinteger(L, n-1);
    return 1;
  }
  else {
    lua_Integer i = luaL_checkinteger(L, 1);
    if (i < 0) i = n + i;
    else if (i > n) i = n;
    luaL_argcheck(L, 1 <= i, 1, "index out of range");
    return n - (int)i;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5d3d
movl %eax, %ebx
movq %r14, %rdi
movl $0x1, %esi
callq 0x5f7f
cmpl $0x4, %eax
jne 0x18625
movl $0x1, %ebp
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x6249
cmpb $0x23, (%rax)
jne 0x18625
decl %ebx
movslq %ebx, %rsi
movq %r14, %rdi
callq 0x63e6
jmp 0x18665
movq %r14, %rdi
movl $0x1, %esi
callq 0x1465a
movslq %ebx, %r15
leaq (%rax,%r15), %rcx
cmpq %r15, %rax
cmovlq %rax, %r15
testq %rax, %rax
cmovsq %rcx, %r15
testq %r15, %r15
jg 0x18660
leaq 0xa527(%rip), %rdx      # 0x22b7a
movq %r14, %rdi
movl $0x1, %esi
callq 0x13ea8
subl %r15d, %ebx
movl %ebx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_setmetatable
static int luaB_setmetatable (lua_State *L) {
  int t = lua_type(L, 2);
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
                    "nil or table expected");
  if (luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL)
    return luaL_error(L, "cannot change a protected metatable");
  lua_settop(L, 2);
  lua_setmetatable(L, 1);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, %esi
callq 0x5f7f
movl %eax, %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1456f
testl %ebp, %ebp
je 0x186b3
cmpl $0x5, %ebp
je 0x186b3
leaq 0xa4e7(%rip), %rdx      # 0x22b8d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13ea8
leaq 0xa41e(%rip), %rdx      # 0x22ad8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14eb2
testl %eax, %eax
je 0x186e2
leaq 0xa4d1(%rip), %rsi      # 0x22ba3
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x13f8e
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5d51
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6d47
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_type
static int luaB_type (lua_State *L) {
  int t = lua_type(L, 1);
  luaL_argcheck(L, t != LUA_TNONE, 1, "value expected");
  lua_pushstring(L, lua_typename(L, t));
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5f7f
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x18942
leaq 0x995d(%rip), %rdx      # 0x22292
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13ea8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5fa0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x645b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: luaB_xpcall
static int luaB_xpcall (lua_State *L) {
  int status;
  int n = lua_gettop(L);
  luaL_checktype(L, 2, LUA_TFUNCTION);  /* check error function */
  lua_pushboolean(L, 1);  /* first result */
  lua_pushvalue(L, 1);  /* function */
  lua_rotate(L, 3, 2);  /* move them below function's arguments */
  status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall);
  return finishpcall(L, status, 2);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5d3d
movl %eax, %ebp
movq %rbx, %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x1456f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x660e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5f5b
movq %rbx, %rdi
movl $0x3, %esi
movl $0x2, %edx
callq 0x5da2
addl $-0x2, %ebp
leaq 0x1b0(%rip), %r9        # 0x18b68
movl $0x2, %r8d
movq %rbx, %rdi
movl %ebp, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x2, %ecx
callq 0x6e8a
movl $0x2, %edx
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x18b68
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lbaselib.c
// Function: load_aux
static int load_aux (lua_State *L, int status, int envidx) {
  if (status == LUA_OK) {
    if (envidx != 0) {  /* 'env' parameter? */
      lua_pushvalue(L, envidx);  /* environment for loaded function */
      if (!lua_setupvalue(L, -2, 1))  /* set it as 1st upvalue */
        lua_pop(L, 1);  /* remove 'env' if not used by previous call */
    }
    return 1;
  }
  else {  /* error (message is on top of the stack) */
    lua_pushnil(L);
    lua_insert(L, -2);  /* put before error message */
    return 2;  /* return nil plus error message */
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x18a65
movq %rbx, %rdi
callq 0x63bd
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5da2
movl $0x2, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
testl %edx, %edx
je 0x18a9e
movq %rbx, %rdi
movl %edx, %esi
callq 0x5f5b
movl $0x1, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x739c
testq %rax, %rax
jne 0x18a5c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
jmp 0x18a5c
movl $0x1, %ebp
jmp 0x18a5c
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xa039(%rip), %rdx      # 0x22aef
movl $0x2, %esi
callq 0x13e55
movq %r14, %rdi
movl $0x1, %esi
callq 0x5f5b
movq %r14, %rdi
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6e22
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5f7f
testl %eax, %eax
je 0x18b4a
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6008
testl %eax, %eax
jne 0x18b14
leaq 0x9fff(%rip), %rsi      # 0x22b09
movq %r14, %rdi
xorl %eax, %eax
callq 0x13f8e
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x5, %edx
callq 0x5f00
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movq %r14, %rdi
movl $0x5, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6249
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x2, %esi
jb 0x18b92
movq %r14, %rdi
xorl %esi, %esi
callq 0x660e
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5f5b
movl $0x2, %eax
jmp 0x18b9f
movq %rdx, %rbx
movq %r14, %rdi
callq 0x5d3d
subl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x6, %edx
callq 0x1456f
movq %rbx, %rdi
callq 0xeb99
movq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5f5b
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x5cb2
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x18da4
movq %rax, %r14
movq %rbx, %rdi
callq 0x5d3d
leal -0x1(%rax), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18ddc
testl %eax, %eax
js 0x18c72
movl %eax, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x660e
leal 0x1(%r14), %ebp
notl %r14d
jmp 0x18c87
movq %rbx, %rdi
xorl %esi, %esi
callq 0x660e
movl $0x2, %ebp
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
movq %rbx, %rdi
movl %r14d, %esi
movl $0x1, %edx
callq 0x5da2
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x18da4
cmpq %rbx, %rax
je 0x18cec
movq %rax, %r14
movq %rax, %rdi
callq 0x7068
testl %eax, %eax
je 0x18cf5
cmpl $0x1, %eax
jne 0x18d11
leaq 0x9f8b(%rip), %rsi      # 0x22c75
jmp 0x18d36
leaq 0x9ddd(%rip), %rsi      # 0x22ad0
jmp 0x18d36
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x75ba
testl %eax, %eax
jle 0x18d1a
leaq 0x9f70(%rip), %rsi      # 0x22c7f
jmp 0x18d36
leaq 0x9f6e(%rip), %rsi      # 0x22c86
jmp 0x18d36
movq %r14, %rdi
callq 0x5d3d
testl %eax, %eax
leaq 0x9f5b(%rip), %rax      # 0x22c86
leaq 0x9f43(%rip), %rsi      # 0x22c75
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x645b
movl $0x1, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x5c28
testl %eax, %eax
je 0x18e5b
movq %r14, %rdi
callq 0x7068
testl %eax, %eax
jne 0x18e11
movq %r14, %rdi
callq 0x5d3d
testl %eax, %eax
je 0x18e8d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x5cb2
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x8dc5
cmpl $0x1, %eax
ja 0x18e64
movq %r14, %rdi
callq 0x5d3d
movl %eax, %r15d
leal 0x1(%r15), %esi
movq %rbx, %rdi
callq 0x5c28
testl %eax, %eax
je 0x18e76
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x5cb2
jmp 0x18ea2
leaq 0x9ddb(%rip), %rsi      # 0x22c3d
jmp 0x18e94
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x5cb2
jmp 0x18e9c
notl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5d51
leaq 0x9dcf(%rip), %rsi      # 0x22c5a
jmp 0x18e94
leaq 0x85ba(%rip), %rsi      # 0x2144e
movq %rbx, %rdi
callq 0x645b
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x6365
movq %rax, %r14
movq %rbx, %rdi
callq 0x5d3d
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x18ddc
testl %eax, %eax
js 0x18ee5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5f7f
cmpl $0x4, %eax
jne 0x18f23
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1412a
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5da2
movq %rbx, %rdi
movl $0x2, %esi
callq 0x71d3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7196
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5f7f
movq %rbx, %rdi
cmpl $0x7, %eax
jne 0x18f93
movl $0x1, %esi
callq 0x6995
jmp 0x18f98
callq 0x63bd
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
callq 0x19a2b
movq %rax, %r14
movq %rax, %rdi
callq 0x75ac
movl %eax, %ebp
movq %r14, %rdi
callq 0x75a4
testq %rax, %rax
je 0x18feb
leaq 0xa9c(%rip), %rcx       # 0x19a71
cmpq %rcx, %rax
je 0x18ff5
leaq 0x9d53(%rip), %rsi      # 0x22d34
movq %rbx, %rdi
callq 0x645b
jmp 0x1905d
movq %rbx, %rdi
callq 0x63bd
jmp 0x1905d
leaq 0x9e14(%rip), %rdx      # 0x22e10
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6889
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19afa
movq %r14, %rdi
callq 0x663c
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x5cb2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6815
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5da2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
xorl %eax, %eax
testb $0x1, %bpl
je 0x1906f
movb $0x63, 0x7(%rsp)
movl $0x1, %eax
testb $0x2, %bpl
je 0x1907e
movl %eax, %ecx
incl %eax
movb $0x72, 0x7(%rsp,%rcx)
testb $0x4, %bpl
je 0x1908d
movl %eax, %ecx
incl %eax
movb $0x6c, 0x7(%rsp,%rcx)
movl %eax, %eax
movb $0x0, 0x7(%rsp,%rax)
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0x645b
movq %r14, %rdi
callq 0x75b3
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x63e6
movl $0x3, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r15
movq %r15, %rsi
callq 0x19a2b
movq %rax, %r14
movl (%r15), %r12d
leal 0x2(%r12), %esi
movq %rbx, %rdi
callq 0x1465a
movq %rax, %r15
incl %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x5f7f
movq %rbx, %rdi
cmpl $0x6, %eax
jne 0x19484
movl %r12d, %esi
callq 0x5f5b
movq %rbx, %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0x7614
movq %rbx, %rdi
movq %rax, %rsi
callq 0x645b
movl $0x1, %ebp
jmp 0x1951e
movl %r12d, %esi
callq 0x1465a
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0x75ba
testl %eax, %eax
je 0x19500
movl $0x1, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19afa
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x7614
testq %rax, %rax
je 0x19516
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x5cb2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x645b
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5da2
movl $0x2, %ebp
jmp 0x1951e
leaq 0x98c7(%rip), %rdx      # 0x22dce
movq %rbx, %rdi
movl %r12d, %esi
callq 0x13ea8
movl %eax, %ebp
jmp 0x1951e
movq %rbx, %rdi
callq 0x63bd
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x145a3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6935
testl %eax, %eax
jne 0x19569
movq %rbx, %rdi
callq 0x63bd
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x2, %edx
callq 0x19bea
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
movl $0x4, %edx
callq 0x19bea
movl %eax, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5fb0
testl %eax, %eax
je 0x195cc
leaq 0x9822(%rip), %rdx      # 0x22de1
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13ea8
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5fb0
testl %eax, %eax
je 0x195f1
leaq 0x97fd(%rip), %rdx      # 0x22de1
movq %rbx, %rdi
movl $0x3, %esi
callq 0x13ea8
movq %rbx, %rdi
movl $0x1, %esi
movl %ebp, %edx
movl $0x3, %ecx
movl %r14d, %r8d
callq 0x74b9
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x1, %esi
movl $0x7, %edx
callq 0x1456f
movq %rbx, %rdi
movl $0x2, %esi
callq 0x145a3
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5d51
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6dd8
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %r15
movq %r15, %rsi
callq 0x19a2b
movq %rax, %r14
movl (%r15), %r12d
leal 0x1(%r12), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1465a
movq %rax, %r13
leal 0x2(%r12), %esi
movq %rbx, %rdi
callq 0x1465a
movq %rax, %r15
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %r13d, %esi
callq 0x75ba
testl %eax, %eax
je 0x19912
addl $0x3, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x145a3
movq %rbx, %rdi
movl %r12d, %esi
callq 0x5d51
movl $0x1, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x19afa
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x5cb2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x77a4
movq %rax, %r15
testq %rax, %rax
jne 0x19905
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movq %rbx, %rdi
movq %r15, %rsi
callq 0x645b
jmp 0x19925
leaq 0x94b5(%rip), %rdx      # 0x22dce
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13ea8
movl %eax, %ebp
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x2, %esi
callq 0x5f7f
testl %eax, %eax
je 0x19964
cmpl $0x5, %eax
je 0x19964
leaq 0x9236(%rip), %rdx      # 0x22b8d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13ea8
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5d51
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6d47
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r15
movq %r15, %rsi
callq 0x19a2b
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x6249
movq %rax, %r12
testq %rax, %rax
je 0x19a01
addl $0x2, %r15d
xorl %edx, %edx
cmpq %rbx, %r14
sete %dl
movq %rbx, %rdi
movl %r15d, %esi
callq 0x146c5
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %eax, %ecx
callq 0x13ba8
jmp 0x19a19
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5f7f
testl %eax, %eax
jle 0x199d8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5f5b
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5f7f
cmpl $0x8, %eax
jne 0x19a5f
movl $0x1, (%r14)
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6365
movl $0x0, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x938e(%rip), %rdx      # 0x22e10
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6889
movq %rbx, %rdi
callq 0x663c
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6815
cmpl $0x6, %eax
jne 0x19ad2
movslq (%r14), %rax
leaq 0x9364(%rip), %rcx      # 0x22e14
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x645b
movslq 0x28(%r14), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
js 0x19ada
callq 0x63e6
jmp 0x19adf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x63bd
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6e22
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpq %rsi, %rdi
je 0x19b46
movq %rsi, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x5cb2
jmp 0x19b58
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5da2
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6b3f
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x2, %esi
callq 0x1465a
movq %rax, %r15
movq %r14, %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x1456f
movq %r14, %rdi
movl $0x1, %esi
movl %r15d, %edx
testl %ebx, %ebx
je 0x19bb0
callq 0x72be
jmp 0x19bb5
callq 0x739c
testq %rax, %rax
je 0x19bdb
movq %r14, %rdi
movq %rax, %rsi
callq 0x645b
leal 0x1(%rbx), %ebp
notl %ebx
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
callq 0x5da2
jmp 0x19bdd
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %edx, %esi
callq 0x1465a
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
movl $0x6, %edx
callq 0x1456f
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x72be
testq %rax, %rax
jne 0x19c34
leaq 0x91cd(%rip), %rdx      # 0x22df7
movq %r14, %rdi
movl %ebx, %esi
callq 0x13ea8
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movsd 0x8fb0(%rip), %xmm0     # 0x22c00
movl $0x88, %esi
callq 0x1540b
movq %rbx, %rdi
xorl %esi, %esi
movl $0xb, %edx
callq 0x68d6
leaq 0x14a20(%rip), %rsi     # 0x2e690
movq %rbx, %rdi
xorl %edx, %edx
callq 0x150f3
leaq 0x91ea(%rip), %rsi      # 0x22e6b
movq %rbx, %rdi
callq 0x1427d
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5f5b
leaq 0x8034(%rip), %rdx      # 0x21cd1
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
leaq 0x14a9f(%rip), %rsi     # 0x2e750
movq %rbx, %rdi
xorl %edx, %edx
callq 0x150f3
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movq 0x15301(%rip), %rax     # 0x2efd0
movq (%rax), %rsi
leaq 0x914f(%rip), %rdx      # 0x22e28
leaq 0x85d3(%rip), %rcx      # 0x222b3
movq %rbx, %rdi
callq 0x19d2a
movq 0x152d9(%rip), %rax     # 0x2efc8
movq (%rax), %rsi
leaq 0x9139(%rip), %rdx      # 0x22e32
leaq 0x913d(%rip), %rcx      # 0x22e3d
movq %rbx, %rdi
callq 0x19d2a
movq 0x152e1(%rip), %rax     # 0x2eff0
movq (%rax), %rsi
leaq 0x912b(%rip), %rcx      # 0x22e44
movq %rbx, %rdi
xorl %edx, %edx
callq 0x19d2a
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x10, %esi
callq 0x727a
movq %rax, %r13
movq $0x0, 0x8(%rax)
leaq 0x9110(%rip), %rsi      # 0x22e6b
movq %r14, %rdi
callq 0x14301
movq %r12, (%r13)
leaq 0x10be(%rip), %rax      # 0x1ae2c
movq %rax, 0x8(%r13)
testq %r15, %r15
je 0x19d94
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5f5b
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %r15, %rdx
callq 0x6b3f
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6b3f
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5f7f
cmpl $-0x1, %eax
jne 0x19dd8
leaq 0x9067(%rip), %rdx      # 0x22e32
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6777
movq %rbx, %rdi
callq 0x1a1d9
leaq 0x9084(%rip), %rdx      # 0x22e6b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14393
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5f7f
cmpl $-0x1, %eax
jne 0x19e77
movq %rbx, %rdi
callq 0x63bd
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5f7f
testl %eax, %eax
je 0x19ecf
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14535
leaq 0x718b(%rip), %rdx      # 0x2102e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1a2de
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x5f00
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
jmp 0x19f0c
leaq 0x8f52(%rip), %rdx      # 0x22e28
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6777
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x5f00
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movq %rbx, %rdi
callq 0x1a1d9
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1a39d
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
movl $0x1, %esi
xorl %edx, %edx
callq 0x14535
movq %rax, %r14
leaq 0x70e5(%rip), %rdx      # 0x2102e
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x144dc
movq %rax, %r15
movl $0x10, %esi
movq %rbx, %rdi
callq 0x727a
movq %rax, %r12
movq %r13, 0x8(%rax)
leaq 0x8ef5(%rip), %rsi      # 0x22e6b
movq %rbx, %rdi
callq 0x14301
movq %r13, (%r12)
leaq 0x3e4(%rip), %rax       # 0x1a36d
movq %rax, 0x8(%r12)
movsbl (%r15), %esi
testl %esi, %esi
je 0x19fdf
leaq 0x8f66(%rip), %rdi      # 0x22f03
movl $0x4, %edx
callq 0x5230
testq %rax, %rax
je 0x19fdf
leaq 0x1(%r15), %rax
movq %r15, %r13
addq $0x2, %r13
cmpb $0x2b, 0x1(%r15)
cmovneq %rax, %r13
leaq 0x9bf9(%rip), %rsi      # 0x23bc0
movq %r13, %rdi
callq 0x5200
movq %rax, %rbp
movq %r13, %rdi
callq 0x5150
cmpq %rax, %rbp
je 0x19ff3
leaq 0x8f21(%rip), %rdx      # 0x22f07
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13ea8
movq %r14, %rdi
movq %r15, %rsi
callq 0x52f0
movq %rax, (%r12)
testq %rax, %rax
je 0x1a01b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14198
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
movl $0x1, %esi
xorl %edx, %edx
callq 0x14535
movq %rax, %r14
leaq 0x6fb9(%rip), %rdx      # 0x2102e
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x144dc
movl $0x10, %esi
movq %rbx, %rdi
callq 0x727a
movq %rax, %r15
movq %r12, 0x8(%rax)
leaq 0x8dcc(%rip), %rsi      # 0x22e6b
movq %rbx, %rdi
callq 0x14301
leaq 0x8e66(%rip), %rsi      # 0x22f14
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13f8e
movq %r12, (%r15)
leaq 0xa2f(%rip), %rax       # 0x1aaf1
movq %rax, 0x8(%r15)
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x14198
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: io_type
static int io_type (lua_State *L) {
  LStream *p;
  luaL_checkany(L, 1);
  p = (LStream *)luaL_testudata(L, 1, LUA_FILEHANDLE);
  if (p == NULL)
    lua_pushnil(L);  /* not a file */
  else if (isclosed(p))
    lua_pushliteral(L, "closed file");
  else
    lua_pushliteral(L, "file");
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x145a3
leaq 0x8cf5(%rip), %rdx      # 0x22e6b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14320
testq %rax, %rax
je 0x1a198
cmpq $0x0, 0x8(%rax)
je 0x1a1a2
leaq 0x8cf3(%rip), %rsi      # 0x22e89
jmp 0x1a1a9
movq %rbx, %rdi
callq 0x63bd
jmp 0x1a1b1
leaq 0x8cd9(%rip), %rsi      # 0x22e82
movq %rbx, %rdi
callq 0x645b
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: tofile
static FILE *tofile (lua_State *L) {
  LStream *p = tolstream(L);
  if (isclosed(p))
    luaL_error(L, "attempt to use a closed file");
  lua_assert(p->f);
  return p->f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8c84(%rip), %rdx      # 0x22e6b
movl $0x1, %esi
callq 0x14393
movq %rax, %r14
cmpq $0x0, 0x8(%rax)
jne 0x1a20c
leaq 0x8c6f(%rip), %rsi      # 0x22e71
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13f8e
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: getiofile
static FILE *getiofile (lua_State *L, const char *findex) {
  LStream *p;
  lua_getfield(L, LUA_REGISTRYINDEX, findex);
  p = (LStream *)lua_touserdata(L, -1);
  if (isclosed(p))
    luaL_error(L, "standard %s file is closed", findex + IOPREF_LEN);
  return p->f;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
callq 0x6777
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x633d
movq %rax, %r15
cmpq $0x0, 0x8(%rax)
jne 0x1a25e
addq $0x4, %rbx
leaq 0x8c3d(%rip), %rsi      # 0x22e8e
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x13f8e
movq (%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: g_iofile
static int g_iofile (lua_State *L, const char *f, const char *mode) {
  if (!lua_isnoneornil(L, 1)) {
    const char *filename = lua_tostring(L, 1);
    if (filename)
      opencheck(L, filename, mode);
    else {
      tofile(L);  /* check that it's a valid file handle */
      lua_pushvalue(L, 1);
    }
    lua_setfield(L, LUA_REGISTRYINDEX, f);
  }
  /* return current value */
  lua_getfield(L, LUA_REGISTRYINDEX, f);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %esi
callq 0x5f7f
testl %eax, %eax
jle 0x1a2c9
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x6249
movq %r14, %rdi
testq %rax, %rax
je 0x1a2a7
movq %rax, %rsi
movq %r15, %rdx
callq 0x1a2de
jmp 0x1a2b9
callq 0x1a1d9
movq %r14, %rdi
movl $0x1, %esi
callq 0x5f5b
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
callq 0x6b3f
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x6777
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: opencheck
static void opencheck (lua_State *L, const char *fname, const char *mode) {
  LStream *p = newfile(L);
  p->f = fopen(fname, mode);
  if (p->f == NULL)
    luaL_error(L, "cannot open file '%s' (%s)", fname, strerror(errno));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %esi
callq 0x727a
movq %rax, %r12
xorl %r13d, %r13d
movq %r13, 0x8(%rax)
leaq 0x8b60(%rip), %rsi      # 0x22e6b
movq %r14, %rdi
callq 0x14301
movq %r13, (%r12)
leaq 0x4f(%rip), %rax        # 0x1a36d
movq %rax, 0x8(%r12)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x52f0
movq %rax, (%r12)
testq %rax, %rax
je 0x1a341
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5090
movl (%rax), %edi
callq 0x54d0
leaq 0x8b55(%rip), %rsi      # 0x22ea9
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x13f8e