LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x6475
movq %rax, %r14
movq %rbx, %rdi
callq 0x5d39
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x19940
testl %eax, %eax
js 0x19a49
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x608f
cmpl $0x4, %eax
jne 0x19a87
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14bf4
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5eb2
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7316
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x72d9
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x608f
movq %rbx, %rdi
cmpl $0x7, %eax
jne 0x19af7
movl $0x1, %esi
callq 0x6aba
jmp 0x19afc
callq 0x64cd
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a58f
movq %rax, %r14
movq %rax, %rdi
callq 0x76e4
movl %eax, %ebp
movq %r14, %rdi
callq 0x76dc
testq %rax, %rax
je 0x19b4f
leaq 0xa9c(%rip), %rcx       # 0x1a5d5
cmpq %rcx, %rax
je 0x19b59
leaq 0xa27f(%rip), %rsi      # 0x23dc4
movq %rbx, %rdi
callq 0x656b
jmp 0x19bc1
movq %rbx, %rdi
callq 0x64cd
jmp 0x19bc1
leaq 0xa340(%rip), %rdx      # 0x23ea0
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x69ae
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x1a65e
movq %r14, %rdi
callq 0x6753
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x5ca7
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x693a
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5eb2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
xorl %eax, %eax
testb $0x1, %bpl
je 0x19bd3
movb $0x63, 0x7(%rsp)
movl $0x1, %eax
testb $0x2, %bpl
je 0x19be2
movl %eax, %ecx
incl %eax
movb $0x72, 0x7(%rsp,%rcx)
testb $0x4, %bpl
je 0x19bf1
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 0x656b
movq %r14, %rdi
callq 0x76eb
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x64f6
movl $0x3, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a58f
movq %rax, %r14
movl (%r15), %r12d
leal 0x2(%r12), %esi
movq %rbx, %rdi
callq 0x15124
movq %rax, %r15
incl %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x608f
movq %rbx, %rdi
cmpl $0x6, %eax
jne 0x19fe8
movl %r12d, %esi
callq 0x606b
movq %rbx, %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0x774c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x656b
movl $0x1, %ebp
jmp 0x1a082
movl %r12d, %esi
callq 0x15124
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movl %eax, %esi
callq 0x76f2
testl %eax, %eax
je 0x1a064
movl $0x1, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x1a65e
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x774c
testq %rax, %rax
je 0x1a07a
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x5ca7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x656b
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5eb2
movl $0x2, %ebp
jmp 0x1a082
leaq 0x9df3(%rip), %rdx      # 0x23e5e
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1497c
movl %eax, %ebp
jmp 0x1a082
movq %rbx, %rdi
callq 0x64cd
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1506d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6a5a
testl %eax, %eax
jne 0x1a0cd
movq %rbx, %rdi
callq 0x64cd
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a74e
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
movl $0x4, %edx
callq 0x1a74e
movl %eax, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x60c0
testl %eax, %eax
je 0x1a130
leaq 0x9d4e(%rip), %rdx      # 0x23e71
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1497c
movq %rbx, %rdi
movl $0x3, %esi
callq 0x60c0
testl %eax, %eax
je 0x1a155
leaq 0x9d29(%rip), %rdx      # 0x23e71
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1497c
movq %rbx, %rdi
movl $0x1, %esi
movl %ebp, %edx
movl $0x3, %ecx
movl %r14d, %r8d
callq 0x75fc
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x15039
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1506d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5d4d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6f16
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a58f
movq %rax, %r14
movl (%r15), %r12d
leal 0x1(%r12), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x15124
movq %rax, %r13
leal 0x2(%r12), %esi
movq %rbx, %rdi
callq 0x15124
movq %rax, %r15
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl %r13d, %esi
callq 0x76f2
testl %eax, %eax
je 0x1a476
addl $0x3, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1506d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x5d4d
movl $0x1, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x1a65e
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x5ca7
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x78d0
movq %rax, %r15
testq %rax, %rax
jne 0x1a469
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x656b
jmp 0x1a489
leaq 0x99e1(%rip), %rdx      # 0x23e5e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1497c
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_O3/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 0x608f
testl %eax, %eax
je 0x1a4c8
cmpl $0x5, %eax
je 0x1a4c8
leaq 0x9762(%rip), %rdx      # 0x23c1d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1497c
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5d4d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6e85
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a58f
movq %rax, %r14
movl (%r15), %r15d
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x6359
movq %rax, %r12
testq %rax, %rax
je 0x1a565
addl $0x2, %r15d
xorl %edx, %edx
cmpq %rbx, %r14
sete %dl
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1518f
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %eax, %ecx
callq 0x1467c
jmp 0x1a57d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x608f
testl %eax, %eax
jle 0x1a53c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x606b
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x608f
cmpl $0x8, %eax
jne 0x1a5c3
movl $0x1, (%r14)
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6475
movl $0x0, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x98ba(%rip), %rdx      # 0x23ea0
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x69ae
movq %rbx, %rdi
callq 0x6753
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x693a
cmpl $0x6, %eax
jne 0x1a636
movslq (%r14), %rax
leaq 0x9890(%rip), %rcx      # 0x23ea4
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x656b
movslq 0x28(%r14), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
js 0x1a63e
callq 0x64f6
jmp 0x1a643
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x64cd
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6f67
// File: /workspace/github_c_makefile_star2_O3/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 0x1a6aa
movq %rsi, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x5ca7
jmp 0x1a6bc
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x5eb2
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c66
// File: /workspace/github_c_makefile_star2_O3/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 0x15124
movq %rax, %r15
movq %r14, %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x15039
movq %r14, %rdi
movl $0x1, %esi
movl %r15d, %edx
testl %ebx, %ebx
je 0x1a714
callq 0x7401
jmp 0x1a719
callq 0x74df
testq %rax, %rax
je 0x1a73f
movq %r14, %rdi
movq %rax, %rsi
callq 0x656b
leal 0x1(%rbx), %ebp
notl %ebx
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
callq 0x5eb2
jmp 0x1a741
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x15124
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
movl $0x6, %edx
callq 0x15039
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x7401
testq %rax, %rax
jne 0x1a798
leaq 0x96f9(%rip), %rdx      # 0x23e87
movq %r14, %rdi
movl %ebx, %esi
callq 0x1497c
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x94dc(%rip), %xmm0     # 0x23c90
movl $0x88, %esi
callq 0x15ef6
movq %rbx, %rdi
xorl %esi, %esi
movl $0xb, %edx
callq 0x69fb
leaq 0x14ebc(%rip), %rsi     # 0x2f690
movq %rbx, %rdi
xorl %edx, %edx
callq 0x15bde
leaq 0x9716(%rip), %rsi      # 0x23efb
movq %rbx, %rdi
callq 0x14d47
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x606b
leaq 0x8540(%rip), %rdx      # 0x22d41
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
leaq 0x14f3b(%rip), %rsi     # 0x2f750
movq %rbx, %rdi
xorl %edx, %edx
callq 0x15bde
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movq 0x1579d(%rip), %rax     # 0x2ffd0
movq (%rax), %rsi
leaq 0x967b(%rip), %rdx      # 0x23eb8
leaq 0x8aff(%rip), %rcx      # 0x23343
movq %rbx, %rdi
callq 0x1a88e
movq 0x15775(%rip), %rax     # 0x2ffc8
movq (%rax), %rsi
leaq 0x9665(%rip), %rdx      # 0x23ec2
leaq 0x9669(%rip), %rcx      # 0x23ecd
movq %rbx, %rdi
callq 0x1a88e
movq 0x1577d(%rip), %rax     # 0x2fff0
movq (%rax), %rsi
leaq 0x9657(%rip), %rcx      # 0x23ed4
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a88e
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x73bd
movq %rax, %r13
movq $0x0, 0x8(%rax)
leaq 0x963c(%rip), %rsi      # 0x23efb
movq %r14, %rdi
callq 0x14dcb
movq %r12, (%r13)
leaq 0x10ad(%rip), %rax      # 0x1b97f
movq %rax, 0x8(%r13)
testq %r15, %r15
je 0x1a8f8
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x606b
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %r15, %rdx
callq 0x6c66
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6c66
// File: /workspace/github_c_makefile_star2_O3/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 0x608f
cmpl $-0x1, %eax
jne 0x1a93c
leaq 0x9593(%rip), %rdx      # 0x23ec2
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6895
movq %rbx, %rdi
callq 0x1ad3d
leaq 0x95b0(%rip), %rdx      # 0x23efb
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14e5d
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_O3/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 0x608f
cmpl $-0x1, %eax
jne 0x1a9db
movq %rbx, %rdi
callq 0x64cd
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x608f
testl %eax, %eax
je 0x1aa33
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x14fff
leaq 0x7627(%rip), %rdx      # 0x2202e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1ae42
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x6010
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
jmp 0x1aa70
leaq 0x947e(%rip), %rdx      # 0x23eb8
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6895
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x6010
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d4d
movq %rbx, %rdi
callq 0x1ad3d
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1af01
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x14fff
movq %rax, %r14
leaq 0x7581(%rip), %rdx      # 0x2202e
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x14fa6
movq %rax, %r15
movl $0x10, %esi
movq %rbx, %rdi
callq 0x73bd
movq %rax, %r12
movq %r13, 0x8(%rax)
leaq 0x9421(%rip), %rsi      # 0x23efb
movq %rbx, %rdi
callq 0x14dcb
movq %r13, (%r12)
leaq 0x3e4(%rip), %rax       # 0x1aed1
movq %rax, 0x8(%r12)
movsbl (%r15), %esi
testl %esi, %esi
je 0x1ab43
leaq 0x9492(%rip), %rdi      # 0x23f93
movl $0x4, %edx
callq 0x5220
testq %rax, %rax
je 0x1ab43
leaq 0x1(%r15), %rax
movq %r15, %r13
addq $0x2, %r13
cmpb $0x2b, 0x1(%r15)
cmovneq %rax, %r13
leaq 0xa155(%rip), %rsi      # 0x24c80
movq %r13, %rdi
callq 0x51f0
movq %rax, %rbp
movq %r13, %rdi
callq 0x5140
cmpq %rax, %rbp
je 0x1ab57
leaq 0x944d(%rip), %rdx      # 0x23f97
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1497c
movq %r14, %rdi
movq %r15, %rsi
callq 0x52e0
movq %rax, (%r12)
testq %rax, %rax
je 0x1ab7f
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 0x14c62
// File: /workspace/github_c_makefile_star2_O3/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 0x14fff
movq %rax, %r14
leaq 0x7455(%rip), %rdx      # 0x2202e
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x14fa6
movl $0x10, %esi
movq %rbx, %rdi
callq 0x73bd
movq %rax, %r15
movq %r12, 0x8(%rax)
leaq 0x92f8(%rip), %rsi      # 0x23efb
movq %rbx, %rdi
callq 0x14dcb
leaq 0x9392(%rip), %rsi      # 0x23fa4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x14a62
movq %r12, (%r15)
leaq 0xa1e(%rip), %rax       # 0x1b644
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 0x14c62
// File: /workspace/github_c_makefile_star2_O3/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 0x1506d
leaq 0x9221(%rip), %rdx      # 0x23efb
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14dea
testq %rax, %rax
je 0x1acfc
cmpq $0x0, 0x8(%rax)
je 0x1ad06
leaq 0x921f(%rip), %rsi      # 0x23f19
jmp 0x1ad0d
movq %rbx, %rdi
callq 0x64cd
jmp 0x1ad15
leaq 0x9205(%rip), %rsi      # 0x23f12
movq %rbx, %rdi
callq 0x656b
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x91b0(%rip), %rdx      # 0x23efb
movl $0x1, %esi
callq 0x14e5d
movq %rax, %r14
cmpq $0x0, 0x8(%rax)
jne 0x1ad70
leaq 0x919b(%rip), %rsi      # 0x23f01
movq %rbx, %rdi
xorl %eax, %eax
callq 0x14a62
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6895
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x644d
movq %rax, %r15
cmpq $0x0, 0x8(%rax)
jne 0x1adc2
addq $0x4, %rbx
leaq 0x9169(%rip), %rsi      # 0x23f1e
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x14a62
movq (%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x608f
testl %eax, %eax
jle 0x1ae2d
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x6359
movq %r14, %rdi
testq %rax, %rax
je 0x1ae0b
movq %rax, %rsi
movq %r15, %rdx
callq 0x1ae42
jmp 0x1ae1d
callq 0x1ad3d
movq %r14, %rdi
movl $0x1, %esi
callq 0x606b
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
callq 0x6c66
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x6895
// File: /workspace/github_c_makefile_star2_O3/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 0x73bd
movq %rax, %r12
xorl %r13d, %r13d
movq %r13, 0x8(%rax)
leaq 0x908c(%rip), %rsi      # 0x23efb
movq %r14, %rdi
callq 0x14dcb
movq %r13, (%r12)
leaq 0x4f(%rip), %rax        # 0x1aed1
movq %rax, 0x8(%r12)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x52e0
movq %rax, (%r12)
testq %rax, %rax
je 0x1aea5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5090
movl (%rax), %edi
callq 0x54c0
leaq 0x9081(%rip), %rsi      # 0x23f39
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x14a62
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: aux_lines
static void aux_lines (lua_State *L, int toclose) {
  int n = lua_gettop(L) - 1;  /* number of arguments to read */
  luaL_argcheck(L, n <= MAXARGLINE, MAXARGLINE + 2, "too many arguments");
  lua_pushinteger(L, n);  /* number of arguments to read */
  lua_pushboolean(L, toclose);  /* close/not close file when finished */
  lua_rotate(L, 2, 2);  /* move 'n' and 'toclose' to their positions */
  lua_pushcclosure(L, io_readline, 3 + n);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x5d39
movl %eax, %r14d
cmpl $0xfc, %eax
jl 0x1af2d
leaq 0x9034(%rip), %rdx      # 0x23f54
movq %rbx, %rdi
movl $0xfc, %esi
callq 0x1497c
leal -0x1(%r14), %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x64f6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6725
movq %rbx, %rdi
movl $0x2, %esi
movl $0x2, %edx
callq 0x5eb2
addl $0x2, %r14d
leaq 0xf(%rip), %rsi         # 0x1af72
movq %rbx, %rdi
movl %r14d, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x66a8
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: io_readline
static int io_readline (lua_State *L) {
  LStream *p = (LStream *)lua_touserdata(L, lua_upvalueindex(1));
  int i;
  int n = (int)lua_tointeger(L, lua_upvalueindex(2));
  if (isclosed(p))  /* file is already closed? */
    return luaL_error(L, "file is already closed");
  lua_settop(L , 1);
  luaL_checkstack(L, n, "too many arguments");
  for (i = 1; i <= n; i++)  /* push arguments to 'g_read' */
    lua_pushvalue(L, lua_upvalueindex(3 + i));
  n = g_read(L, p->f, 2);  /* 'n' is number of results */
  lua_assert(n > 0);  /* should return at least a nil */
  if (lua_toboolean(L, -n))  /* read at least one value? */
    return n;  /* return them */
  else {  /* first result is nil: EOF or error */
    if (n > 1) {  /* is there error information? */
      /* 2nd result is error message */
      return luaL_error(L, "%s", lua_tostring(L, -n + 1));
    }
    if (lua_toboolean(L, lua_upvalueindex(3))) {  /* generator created file? */
      lua_settop(L, 0);
      lua_pushvalue(L, lua_upvalueindex(1));
      aux_close(L);  /* close it */
    }
    return 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x644d
movq %rax, %r14
movq %rbx, %rdi
movl $0xfff0b9d6, %esi       # imm = 0xFFF0B9D6
xorl %edx, %edx
callq 0x62e1
cmpq $0x0, 0x8(%r14)
je 0x1b022
movq %rax, %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5d4d
leaq 0x8f99(%rip), %rdx      # 0x23f54
movq %rbx, %rdi
movl %r15d, %esi
callq 0x14929
testl %r15d, %r15d
jle 0x1aff1
movl $0xfff0b9d4, %r12d      # imm = 0xFFF0B9D4
movq %rbx, %rdi
movl %r12d, %esi
callq 0x606b
leal (%r15,%r12), %eax
decl %eax
movl %r12d, %ecx
decl %ecx
movl %ecx, %r12d
cmpl $0xfff0b9d4, %eax       # imm = 0xFFF0B9D4
jne 0x1afd1
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x1b0d3
movl %eax, %ebp
movl %eax, %esi
negl %esi
movq %rbx, %rdi
callq 0x6333
testl %eax, %eax
je 0x1b03f
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8f3e(%rip), %rsi      # 0x23f67
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x14a62
cmpl $0x2, %ebp
jl 0x1b075
movl $0x1, %esi
subl %ebp, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6359
leaq 0x9cf6(%rip), %rsi      # 0x24d52
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x14a62
movq %rbx, %rdi
movl $0xfff0b9d5, %esi       # imm = 0xFFF0B9D5
callq 0x6333
xorl %ebp, %ebp
testl %eax, %eax
je 0x1b013
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5d4d
movq %rbx, %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x606b
leaq 0x8e55(%rip), %rdx      # 0x23efb
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14e5d
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rbx, %rdi
callq *%rax
jmp 0x1b013
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: read_line
static int read_line (lua_State *L, FILE *f, int chop) {
  luaL_Buffer b;
  int c = '\0';
  luaL_buffinit(L, &b);
  while (c != EOF && c != '\n') {  /* repeat until end of line */
    char *buff = luaL_prepbuffer(&b);  /* preallocate buffer */
    int i = 0;
    l_lockfile(f);  /* no memory errors can happen inside the lock */
    while (i < LUAL_BUFFERSIZE && (c = l_getc(f)) != EOF && c != '\n')
      buff[i++] = c;
    l_unlockfile(f);
    luaL_addsize(&b, i);
  }
  if (!chop && c == '\n')  /* want a newline and have one? */
    luaL_addchar(&b, c);  /* add ending newline to result */
  luaL_pushresult(&b);  /* close buffer */
  /* return ok if read something (either a newline or something else) */
  return (c == '\n' || lua_rawlen(L, -1) > 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movl %edx, %ebp
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq %rdi, (%rsp)
movq %r15, %rsi
callq 0x154c8
xorl %r12d, %r12d
cmpl $-0x1, %r12d
je 0x1b531
cmpl $0xa, %r12d
je 0x1b531
movl $0x2000, %esi           # imm = 0x2000
movq %r15, %rdi
callq 0x151bd
movq %rax, %r13
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x54e0
movl %eax, %r12d
cmpl $-0x1, %eax
je 0x1b528
cmpl $0xa, %r12d
je 0x1b528
movb %r12b, (%r13,%rbx)
incq %rbx
cmpq $0x2000, %rbx           # imm = 0x2000
jne 0x1b4fc
movl $0x2000, %ebx           # imm = 0x2000
movl %ebx, %eax
addq %rax, 0x18(%rsp)
jmp 0x1b4de
movl %r12d, %eax
xorl $0xa, %eax
orl %eax, %ebp
jne 0x1b57d
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jb 0x1b55d
leaq 0x8(%rsp), %rbx
movl $0x1, %esi
movq %rbx, %rdi
callq 0x151bd
movq 0x10(%rbx), %rax
leaq 0x8(%rsp), %rdi
movq (%rdi), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x10(%rdi)
movb $0xa, (%rcx,%rax)
callq 0x153c0
movl $0x1, %eax
jmp 0x1b5ab
leaq 0x8(%rsp), %rdi
callq 0x153c0
movl $0x1, %eax
cmpl $0xa, %r12d
je 0x1b5ab
movq (%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x63d9
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: readdigits
static int readdigits (RN *rn, int hex) {
  int count = 0;
  while ((hex ? isxdigit(rn->c) : isdigit(rn->c)) && nextc(rn))
    count++;
  return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
callq 0x5530
movq %rax, %r15
movq (%r15), %rax
movslq 0x8(%r14), %rcx
movzwl (%rax,%rcx,2), %eax
testl %ebx, %ebx
je 0x1b5ea
btl $0xc, %eax
jb 0x1b5f0
jmp 0x1b600
btl $0xb, %eax
jae 0x1b600
movq %r14, %rdi
callq 0x1b60d
testl %eax, %eax
je 0x1b600
incl %ebp
jmp 0x1b5d3
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: nextc
static int nextc (RN *rn) {
  if (rn->n >= L_MAXLENNUM) {  /* buffer overflow? */
    rn->buff[0] = '\0';  /* invalidate result */
    return 0;  /* fail */
  }
  else {
    rn->buff[rn->n++] = rn->c;  /* save current char */
    rn->c = l_getc(rn->f);  /* read next one */
    return 1;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0xc(%rdi), %rax
cmpq $0xc8, %rax
jl 0x1b625
movb $0x0, 0x10(%rbx)
xorl %eax, %eax
jmp 0x1b642
movb 0x8(%rbx), %cl
leal 0x1(%rax), %edx
movl %edx, 0xc(%rbx)
movb %cl, 0x10(%rbx,%rax)
movq (%rbx), %rdi
callq 0x54e0
movl %eax, 0x8(%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: g_write
static int g_write (lua_State *L, FILE *f, int arg) {
  int nargs = lua_gettop(L) - arg;
  int status = 1;
  for (; nargs--; arg++) {
    if (lua_type(L, arg) == LUA_TNUMBER) {
      /* optimization: could be done exactly as for strings */
      int len = lua_isinteger(L, arg)
                ? fprintf(f, LUA_INTEGER_FMT, lua_tointeger(L, arg))
                : fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg));
      status = status && (len > 0);
    }
    else {
      size_t l;
      const char *s = luaL_checklstring(L, arg, &l);
      status = status && (fwrite(s, sizeof(char), l, f) == l);
    }
  }
  if (status) return 1;  /* file handle already on stack top */
  else return luaL_fileresult(L, status, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5d39
movl %eax, %r15d
movl $0x1, %eax
cmpl %ebp, %r15d
je 0x1b753
movl $0x1, %r13d
movq %rsp, %r12
movq %rbx, %rdi
movl %ebp, %esi
callq 0x608f
movq %rbx, %rdi
movl %ebp, %esi
cmpl $0x3, %eax
jne 0x1b6d8
callq 0x60dc
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
testl %eax, %eax
je 0x1b706
callq 0x62e1
movq %r14, %rdi
leaq 0x70a4(%rip), %rsi      # 0x22770
movq %rax, %rdx
xorl %eax, %eax
callq 0x52b0
jmp 0x1b71c
movq %r12, %rdx
callq 0x14fff
testl %r13d, %r13d
je 0x1b72f
movq (%rsp), %rdx
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rcx
callq 0x5490
xorl %r13d, %r13d
cmpq (%rsp), %rax
sete %r13b
jmp 0x1b732
callq 0x628e
movq %r14, %rdi
leaq 0x7060(%rip), %rsi      # 0x22775
movb $0x1, %al
callq 0x52b0
testl %r13d, %r13d
setne %cl
testl %eax, %eax
setg %al
andb %cl, %al
movzbl %al, %r13d
jmp 0x1b732
xorl %r13d, %r13d
incl %ebp
cmpl %ebp, %r15d
jne 0x1b699
movl $0x1, %eax
testl %r13d, %r13d
jne 0x1b753
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x14c62
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: f_seek
static int f_seek (lua_State *L) {
  static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
  static const char *const modenames[] = {"set", "cur", "end", NULL};
  FILE *f = tofile(L);
  int op = luaL_checkoption(L, 2, "cur", modenames);
  lua_Integer p3 = luaL_optinteger(L, 3, 0);
  l_seeknum offset = (l_seeknum)p3;
  luaL_argcheck(L, (lua_Integer)offset == p3, 3,
                  "not an integer in proper range");
  op = l_fseek(f, offset, mode[op]);
  if (op)
    return luaL_fileresult(L, 0, NULL);  /* error */
  else {
    lua_pushinteger(L, (lua_Integer)l_ftell(f));
    return 1;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1ad3d
movq %rax, %r14
leaq 0x87f7(%rip), %rdx      # 0x23fc7
leaq 0x14019(%rip), %rcx     # 0x2f7f0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x14f15
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x1518f
movslq %ebp, %rcx
leaq 0x8809(%rip), %rdx      # 0x24008
movl (%rdx,%rcx,4), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x53d0
testl %eax, %eax
je 0x1b821
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x14c62
movq %r14, %rdi
callq 0x52c0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x64f6
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: f_setvbuf
static int f_setvbuf (lua_State *L) {
  static const int mode[] = {_IONBF, _IOFBF, _IOLBF};
  static const char *const modenames[] = {"no", "full", "line", NULL};
  FILE *f = tofile(L);
  int op = luaL_checkoption(L, 2, NULL, modenames);
  lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
  int res = setvbuf(f, NULL, mode[op], (size_t)sz);
  return luaL_fileresult(L, res == 0, NULL);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1ad3d
movq %rax, %r14
leaq 0x13fbc(%rip), %rcx     # 0x2f810
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x14f15
movl %eax, %ebp
movl $0x2000, %edx           # imm = 0x2000
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1518f
movslq %ebp, %rcx
leaq 0x8793(%rip), %rdx      # 0x24014
movl (%rdx,%rcx,4), %edx
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rcx
callq 0x5400
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x14c62
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: f_gc
static int f_gc (lua_State *L) {
  LStream *p = tolstream(L);
  if (!isclosed(p) && p->f != NULL)
    aux_close(L);  /* ignore closed and incompletely open files */
  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8612(%rip), %rdx      # 0x23efb
movl $0x1, %esi
callq 0x14e5d
cmpq $0x0, 0x8(%rax)
je 0x1b92f
cmpq $0x0, (%rax)
je 0x1b92f
leaq 0x85f4(%rip), %rdx      # 0x23efb
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14e5d
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rbx, %rdi
callq *%rax
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: f_tostring
static int f_tostring (lua_State *L) {
  LStream *p = tolstream(L);
  if (isclosed(p))
    lua_pushliteral(L, "file (closed)");
  else
    lua_pushfstring(L, "file (%p)", p->f);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x85b9(%rip), %rdx      # 0x23efb
movl $0x1, %esi
callq 0x14e5d
cmpq $0x0, 0x8(%rax)
je 0x1b969
movq (%rax), %rdx
leaq 0x8684(%rip), %rsi      # 0x23fe1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x65ff
jmp 0x1b978
leaq 0x8663(%rip), %rsi      # 0x23fd3
movq %rbx, %rdi
callq 0x656b
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: io_noclose
static int io_noclose (lua_State *L) {
  LStream *p = tolstream(L);
  p->closef = &io_noclose;  /* keep file opened */
  lua_pushnil(L);
  lua_pushliteral(L, "cannot close standard file");
  return 2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x8571(%rip), %rdx      # 0x23efb
movl $0x1, %esi
callq 0x14e5d
leaq -0x1c(%rip), %rcx       # 0x1b97f
movq %rcx, 0x8(%rax)
movq %rbx, %rdi
callq 0x64cd
leaq 0x863d(%rip), %rsi      # 0x23feb
movq %rbx, %rdi
callq 0x656b
movl $0x2, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: luaopen_math
LUAMOD_API int luaopen_math (lua_State *L) {
  luaL_newlib(L, mathlib);
  lua_pushnumber(L, PI);
  lua_setfield(L, -2, "pi");
  lua_pushnumber(L, (lua_Number)HUGE_VAL);
  lua_setfield(L, -2, "huge");
  lua_pushinteger(L, LUA_MAXINTEGER);
  lua_setfield(L, -2, "maxinteger");
  lua_pushinteger(L, LUA_MININTEGER);
  lua_setfield(L, -2, "mininteger");
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x82c1(%rip), %xmm0     # 0x23c90
movl $0x88, %esi
callq 0x15ef6
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1b, %edx
callq 0x69fb
leaq 0x13e41(%rip), %rsi     # 0x2f830
movq %rbx, %rdi
xorl %edx, %edx
callq 0x15bde
movsd 0x861f(%rip), %xmm0     # 0x24020
movq %rbx, %rdi
callq 0x64e1
leaq 0x8660(%rip), %rdx      # 0x24070
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
movsd 0x8603(%rip), %xmm0     # 0x24028
movq %rbx, %rdi
callq 0x64e1
leaq 0x863f(%rip), %rdx      # 0x24073
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
movabsq $0x7fffffffffffffff, %r14 # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64f6
leaq 0x861b(%rip), %rdx      # 0x24078
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x64f6
leaq 0x8604(%rip), %rdx      # 0x24083
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6c66
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_abs
static int math_abs (lua_State *L) {
  if (lua_isinteger(L, 1)) {
    lua_Integer n = lua_tointeger(L, 1);
    if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n);
    lua_pushinteger(L, n);
  }
  else
    lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x60dc
movq %rbx, %rdi
movl $0x1, %esi
testl %eax, %eax
je 0x1bace
xorl %edx, %edx
callq 0x62e1
movq %rax, %rsi
negq %rsi
cmovsq %rax, %rsi
movq %rbx, %rdi
callq 0x64f6
jmp 0x1bae2
callq 0x150a0
andps 0x8586(%rip), %xmm0     # 0x24060
movq %rbx, %rdi
callq 0x64e1
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_atan
static int math_atan (lua_State *L) {
  lua_Number y = luaL_checknumber(L, 1);
  lua_Number x = luaL_optnumber(L, 2, 1);
  lua_pushnumber(L, l_mathop(atan2)(y, x));
  return 1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x150a0
movsd %xmm0, 0x8(%rsp)
movsd 0x743b(%rip), %xmm0     # 0x22f88
movq %rbx, %rdi
movl $0x2, %esi
callq 0x150ef
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x53b0
movq %rbx, %rdi
callq 0x64e1
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_ceil
static int math_ceil (lua_State *L) {
  if (lua_isinteger(L, 1))
    lua_settop(L, 1);  /* integer is its own ceil */
  else {
    lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1));
    pushnumint(L, d);
  }
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x60dc
testl %eax, %eax
je 0x1bb9c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5d4d
jmp 0x1bbb6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x150a0
callq 0x54d0
movq %rbx, %rdi
callq 0x1c229
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_toint
static int math_toint (lua_State *L) {
  int valid;
  lua_Integer n = lua_tointegerx(L, 1, &valid);
  if (valid)
    lua_pushinteger(L, n);
  else {
    luaL_checkany(L, 1);
    lua_pushnil(L);  /* value is not convertible to integer */
  }
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x62e1
cmpl $0x0, (%r14)
je 0x1bc52
movq %rbx, %rdi
movq %rax, %rsi
callq 0x64f6
jmp 0x1bc67
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1506d
movq %rbx, %rdi
callq 0x64cd
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_floor
static int math_floor (lua_State *L) {
  if (lua_isinteger(L, 1))
    lua_settop(L, 1);  /* integer is its own floor */
  else {
    lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1));
    pushnumint(L, d);
  }
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x60dc
testl %eax, %eax
je 0x1bc95
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5d4d
jmp 0x1bcaf
movq %rbx, %rdi
movl $0x1, %esi
callq 0x150a0
callq 0x5460
movq %rbx, %rdi
callq 0x1c229
movl $0x1, %eax
popq %rbx
retq