LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: luaopen_io
LUAMOD_API int luaopen_io (lua_State *L) {
  luaL_newlib(L, iolib);  /* new module */
  createmeta(L);
  /* create (and set) default files */
  createstdfile(L, stdin, IO_INPUT, "stdin");
  createstdfile(L, stdout, IO_OUTPUT, "stdout");
  createstdfile(L, stderr, NULL, "stderr");
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x88fe(%rip), %xmm0     # 0x20d20
movl $0x88, %esi
callq 0x13f6d
pushq $0xb
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x665a
leaq 0x16250(%rip), %rsi     # 0x2e690
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13c52
leaq 0x8b3a(%rip), %rsi      # 0x20f8b
movq %rbx, %rdi
callq 0x12ea0
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5cee
leaq 0x78fe(%rip), %rdx      # 0x1fd69
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x68b9
leaq 0x162d1(%rip), %rsi     # 0x2e750
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13c52
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5b31
movq 0x16b36(%rip), %rax     # 0x2efd0
movq (%rax), %rsi
leaq 0x8aa4(%rip), %rdx      # 0x20f48
leaq 0x7ed4(%rip), %rcx      # 0x2037f
movq %rbx, %rdi
callq 0x184f8
movq 0x16b0e(%rip), %rax     # 0x2efc8
movq (%rax), %rsi
leaq 0x8a8e(%rip), %rdx      # 0x20f52
leaq 0x8a92(%rip), %rcx      # 0x20f5d
movq %rbx, %rdi
callq 0x184f8
movq 0x16b16(%rip), %rax     # 0x2eff0
movq (%rax), %rsi
leaq 0x8a80(%rip), %rcx      # 0x20f64
movq %rbx, %rdi
xorl %edx, %edx
callq 0x184f8
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x18a5d
movq %r12, (%rax)
leaq 0xf46(%rip), %rcx       # 0x19461
movq %rcx, 0x8(%rax)
testq %r15, %r15
je 0x1853f
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x5cee
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %r15, %rdx
callq 0x68b9
pushq $-0x2
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x68b9
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x5d12
cmpl $-0x1, %eax
jne 0x1857d
leaq 0x89e2(%rip), %rdx      # 0x20f52
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x64f4
movq %rbx, %rdi
callq 0x188b0
movq %rbx, %rdi
popq %rbx
jmp 0x188ec
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x5d12
cmpl $-0x1, %eax
jne 0x185ed
movq %rbx, %rdi
callq 0x6135
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5d12
testl %eax, %eax
je 0x18636
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x13131
leaq 0x6a25(%rip), %rdx      # 0x1f036
movq %rbx, %rdi
movq %rax, %rsi
callq 0x189df
pushq $-0x1
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x5c93
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x5b31
jmp 0x1866d
leaq 0x890b(%rip), %rdx      # 0x20f48
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x64f4
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x5c93
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x5b31
movq %rbx, %rdi
callq 0x188b0
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x18abc
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x13131
movq %rax, %r14
leaq 0x6993(%rip), %rdx      # 0x1f036
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x130d8
movq %rax, %r15
movq %rbx, %rdi
callq 0x18a46
movq %rax, %r12
movsbl (%r15), %esi
testl %esi, %esi
je 0x1870d
leaq 0x8959(%rip), %rdi      # 0x21026
pushq $0x4
popq %rdx
callq 0x5210
testq %rax, %rax
je 0x1870d
leaq 0x1(%r15), %rax
movq %r15, %r13
addq $0x2, %r13
cmpb $0x2b, 0x1(%r15)
cmovneq %rax, %r13
leaq 0x95eb(%rip), %rsi      # 0x21ce0
movq %r13, %rdi
callq 0x51e0
movq %rax, %rbp
movq %r13, %rdi
callq 0x5140
cmpq %rax, %rbp
je 0x1871f
leaq 0x8916(%rip), %rdx      # 0x2102a
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12af2
movq %r14, %rdi
movq %r15, %rsi
callq 0x52d0
movq %rax, (%r12)
testq %rax, %rax
je 0x18745
pushq $0x1
popq %rax
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 0x12dc6
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x13131
movq %rax, %r14
leaq 0x68a1(%rip), %rdx      # 0x1f036
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x130d8
movq %rbx, %rdi
callq 0x18a5d
movq %rax, %r15
leaq 0x8883(%rip), %rsi      # 0x21037
movq %rbx, %rdi
xorl %eax, %eax
callq 0x12bd6
andq $0x0, (%r15)
leaq 0x9b5(%rip), %rax       # 0x1917e
movq %rax, 0x8(%r15)
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x12dc6
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x131a8
leaq 0x873c(%rip), %rdx      # 0x20f8b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12f35
testq %rax, %rax
je 0x1886e
cmpq $0x0, 0x8(%rax)
je 0x18878
leaq 0x873d(%rip), %rsi      # 0x20fa9
jmp 0x1887f
movq %rbx, %rdi
callq 0x6135
jmp 0x18887
leaq 0x8723(%rip), %rsi      # 0x20fa2
movq %rbx, %rdi
callq 0x61d0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x86cd(%rip), %rdx      # 0x20f8b
pushq $0x1
popq %rsi
callq 0x12fa2
movq %rax, %r14
cmpq $0x0, 0x8(%rax)
jne 0x188e1
leaq 0x86ba(%rip), %rsi      # 0x20f91
movq %rbx, %rdi
xorl %eax, %eax
callq 0x12bd6
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: aux_close
static int aux_close (lua_State *L) {
  LStream *p = tolstream(L);
  volatile lua_CFunction cf = p->closef;
  p->closef = NULL;  /* mark stream as closed */
  return (*cf)(L);  /* close it */
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8690(%rip), %rdx      # 0x20f8b
pushq $0x1
popq %rsi
callq 0x12fa2
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
andq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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 0x64f4
pushq $-0x1
popq %rsi
movq %r14, %rdi
callq 0x60b5
movq %rax, %r15
cmpq $0x0, 0x8(%rax)
jne 0x18965
addq $0x4, %rbx
leaq 0x8656(%rip), %rsi      # 0x20fae
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x12bd6
movq (%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x5d12
testl %eax, %eax
jle 0x189ca
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x5fca
movq %r14, %rdi
testq %rax, %rax
je 0x189aa
movq %rax, %rsi
movq %r15, %rdx
callq 0x189df
jmp 0x189ba
callq 0x188b0
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x5cee
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
callq 0x68b9
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x64f4
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x18a46
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x52d0
movq %rax, (%r12)
testq %rax, %rax
je 0x18a18
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5090
movl (%rax), %edi
callq 0x54b0
leaq 0x859e(%rip), %rsi      # 0x20fc9
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12bd6
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: newfile
static LStream *newfile (lua_State *L) {
  LStream *p = newprefile(L);
  p->f = NULL;
  p->closef = &io_fclose;
  return p;
}

// Assembly:
pushq %rax
callq 0x18a5d
andq $0x0, (%rax)
leaq 0x37(%rip), %rcx        # 0x18a8e
movq %rcx, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: newprefile
static LStream *newprefile (lua_State *L) {
  LStream *p = (LStream *)lua_newuserdata(L, sizeof(LStream));
  p->closef = NULL;  /* mark file handle as 'closed' */
  luaL_setmetatable(L, LUA_FILEHANDLE);
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rsi
callq 0x6ffe
movq %rax, %r14
andq $0x0, 0x8(%rax)
leaq 0x8510(%rip), %rsi      # 0x20f8b
movq %rbx, %rdi
callq 0x12f18
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5b1d
movl %eax, %r14d
cmpl $0xfc, %eax
jl 0x18ae8
leaq 0x8509(%rip), %rdx      # 0x20fe4
movq %rbx, %rdi
movl $0xfc, %esi
callq 0x12af2
leal -0x1(%r14), %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x615b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6386
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
callq 0x5b7f
addl $0x2, %r14d
leaq 0xf(%rip), %rsi         # 0x18b28
movq %rbx, %rdi
movl %r14d, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x630a
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x60b5
movq %rax, %r14
xorl %r12d, %r12d
movq %rbx, %rdi
movl $0xfff0b9d6, %esi       # imm = 0xFFF0B9D6
xorl %edx, %edx
callq 0x5f59
cmpq $0x0, 0x8(%r14)
je 0x18bd0
movq %rax, %r15
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5b31
leaq 0x8474(%rip), %rdx      # 0x20fe4
movq %rbx, %rdi
movl %r15d, %esi
callq 0x12a9f
testl %r15d, %r15d
cmovgl %r15d, %r12d
movl $0xfff0b9d4, %r15d      # imm = 0xFFF0B9D4
leal (%r12,%r15), %eax
cmpl $0xfff0b9d4, %eax       # imm = 0xFFF0B9D4
je 0x18ba3
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5cee
decl %r15d
jmp 0x18b88
movq (%r14), %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
callq 0x18c52
movl %eax, %r14d
movl %eax, %esi
negl %esi
movq %rbx, %rdi
callq 0x5fa6
testl %eax, %eax
je 0x18be9
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8420(%rip), %rsi      # 0x20ff7
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x12bd6
cmpl $0x2, %r14d
jl 0x18c1a
subl %r14d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x5fca
leaq 0x91ad(%rip), %rsi      # 0x21db2
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x12bd6
movq %rbx, %rdi
movl $0xfff0b9d5, %esi       # imm = 0xFFF0B9D5
callq 0x5fa6
xorl %r14d, %r14d
testl %eax, %eax
je 0x18bc4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b31
movq %rbx, %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x5cee
movq %rbx, %rdi
callq 0x188ec
jmp 0x18bc4
// File: /workspace/github_c_makefile_star2_O2/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, %r15
leaq 0x8(%rsp), %r12
movq %rdi, (%rsp)
movq %r12, %rsi
callq 0x13589
xorl %r14d, %r14d
cmpl $-0x1, %r14d
je 0x1906a
cmpl $0xa, %r14d
je 0x1906a
movl $0x2000, %esi           # imm = 0x2000
movq %r12, %rdi
callq 0x132de
movq %rax, %r13
xorl %ebx, %ebx
cmpq $0x2000, %rbx           # imm = 0x2000
je 0x19063
movq %r15, %rdi
callq 0x54d0
movl %eax, %r14d
cmpl $-0x1, %eax
je 0x19063
cmpl $0xa, %r14d
je 0x19063
movb %r14b, (%r13,%rbx)
incq %rbx
jmp 0x1903a
addq %rbx, 0x18(%rsp)
jmp 0x1901c
movl %r14d, %eax
xorl $0xa, %eax
orl %eax, %ebp
jne 0x190a6
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jb 0x19094
leaq 0x8(%rsp), %r15
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x132de
movq 0x10(%r15), %rax
movq 0x8(%rsp), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x18(%rsp)
movb $0xa, (%rcx,%rax)
leaq 0x8(%rsp), %rdi
callq 0x134ba
cmpl $0xa, %r14d
jne 0x190bb
pushq $0x1
popq %rax
jmp 0x190d2
pushq $-0x1
popq %rsi
movq (%rsp), %rdi
callq 0x6047
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_O2/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 0x5520
movq %rax, %r15
movq (%r15), %rax
movslq 0x8(%r14), %rcx
movzwl (%rax,%rcx,2), %eax
testl %ebx, %ebx
je 0x19126
btl $0xc, %eax
jb 0x1912c
jmp 0x1913c
btl $0xb, %eax
jae 0x1913c
movq %r14, %rdi
callq 0x19149
testl %eax, %eax
je 0x1913c
incl %ebp
jmp 0x1910f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19161
movb $0x0, 0x10(%rbx)
xorl %eax, %eax
jmp 0x1917c
movb 0x8(%rbx), %cl
leal 0x1(%rax), %edx
movl %edx, 0xc(%rbx)
movb %cl, 0x10(%rbx,%rax)
movq (%rbx), %rdi
callq 0x54d0
movl %eax, 0x8(%rbx)
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5b1d
movl %eax, %r15d
pushq $0x1
popq %r13
movq %rsp, %r12
cmpl %ebp, %r15d
je 0x19266
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5d12
movq %rbx, %rdi
movl %ebp, %esi
cmpl $0x3, %eax
jne 0x19207
callq 0x5d5d
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
testl %eax, %eax
je 0x19233
callq 0x5f59
movq %r14, %rdi
leaq 0x6595(%rip), %rsi      # 0x1f790
movq %rax, %rdx
xorl %eax, %eax
callq 0x52a0
jmp 0x19249
movq %r12, %rdx
callq 0x13131
testl %r13d, %r13d
je 0x1925c
movq (%rsp), %rdx
movq %rax, %rdi
pushq $0x1
popq %rsi
movq %r14, %rcx
callq 0x5480
xorl %r13d, %r13d
cmpq (%rsp), %rax
sete %r13b
jmp 0x1925f
callq 0x5f0b
movq %r14, %rdi
leaq 0x6553(%rip), %rsi      # 0x1f795
movb $0x1, %al
callq 0x52a0
testl %r13d, %r13d
setne %cl
testl %eax, %eax
setg %al
andb %cl, %al
movzbl %al, %r13d
jmp 0x1925f
xorl %r13d, %r13d
incl %ebp
jmp 0x191bf
testl %r13d, %r13d
je 0x19270
pushq $0x1
popq %rax
jmp 0x1927c
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x12dc6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x188b0
movq %rax, %r14
leaq 0x7d65(%rip), %rdx      # 0x2105a
leaq 0x154f4(%rip), %rcx     # 0x2e7f0
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x1305b
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x132b0
movslq %ebp, %rcx
leaq 0x7d7c(%rip), %rdx      # 0x2109c
movl (%rdx,%rcx,4), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x53c0
testl %eax, %eax
je 0x19342
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x12dc6
movq %r14, %rdi
callq 0x52b0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x615b
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x188b0
movq %rax, %r14
leaq 0x1549d(%rip), %rcx     # 0x2e810
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1305b
movl %eax, %ebp
pushq $0x3
popq %rsi
movl $0x2000, %edx           # imm = 0x2000
movq %rbx, %rdi
callq 0x132b0
movslq %ebp, %rcx
leaq 0x7d0c(%rip), %rdx      # 0x210a8
movl (%rdx,%rcx,4), %edx
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rcx
callq 0x53f0
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x12dc6
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
leaq 0x7b8f(%rip), %rdx      # 0x20f8b
pushq $0x1
popq %rsi
callq 0x12fa2
cmpq $0x0, 0x8(%rax)
je 0x19419
cmpq $0x0, (%rax)
je 0x19419
movq %rbx, %rdi
callq 0x188ec
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7b63(%rip), %rdx      # 0x20f8b
pushq $0x1
popq %rsi
callq 0x12fa2
cmpq $0x0, 0x8(%rax)
je 0x1944d
movq (%rax), %rdx
leaq 0x7c33(%rip), %rsi      # 0x21074
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6261
jmp 0x1945c
leaq 0x7c12(%rip), %rsi      # 0x21066
movq %rbx, %rdi
callq 0x61d0
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7b1f(%rip), %rdx      # 0x20f8b
pushq $0x1
popq %rsi
callq 0x12fa2
leaq -0x1a(%rip), %rcx       # 0x19461
movq %rcx, 0x8(%rax)
movq %rbx, %rdi
callq 0x6135
leaq 0x7bf0(%rip), %rsi      # 0x2107e
movq %rbx, %rdi
callq 0x61d0
pushq $0x2
popq %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movsd 0x7875(%rip), %xmm0     # 0x20d20
movl $0x88, %esi
callq 0x13f6d
pushq $0x1b
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x665a
leaq 0x15367(%rip), %rsi     # 0x2e830
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13c52
movsd 0x7bdd(%rip), %xmm0     # 0x210b8
movq %rbx, %rdi
callq 0x6146
leaq 0x7c16(%rip), %rdx      # 0x21100
pushq $-0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x68b9
movsd 0x7bc1(%rip), %xmm0     # 0x210c0
movq %rbx, %rdi
callq 0x6146
leaq 0x7bf5(%rip), %rdx      # 0x21103
movq %rbx, %rdi
movl %ebp, %esi
callq 0x68b9
movabsq $0x7fffffffffffffff, %r14 # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %rdi
movq %r14, %rsi
callq 0x615b
leaq 0x7bd4(%rip), %rdx      # 0x21108
movq %rbx, %rdi
movl %ebp, %esi
callq 0x68b9
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x615b
leaq 0x7bc0(%rip), %rdx      # 0x21113
movq %rbx, %rdi
movl %ebp, %esi
callq 0x68b9
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x5d5d
pushq $0x1
popq %rsi
movq %rbx, %rdi
testl %eax, %eax
je 0x19596
xorl %edx, %edx
callq 0x5f59
movq %rax, %rsi
negq %rsi
cmovsq %rax, %rsi
movq %rbx, %rdi
callq 0x615b
jmp 0x195aa
callq 0x131db
andps 0x7b4e(%rip), %xmm0     # 0x210f0
movq %rbx, %rdi
callq 0x6146
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x131db
movsd %xmm0, (%rsp)
pushq $0x2
popq %rsi
movsd 0x696d(%rip), %xmm0     # 0x1ff88
movq %rbx, %rdi
callq 0x1321d
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x53a0
movq %rbx, %rdi
callq 0x6146
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x5d5d
pushq $0x1
popq %rsi
testl %eax, %eax
je 0x1965e
movq %rbx, %rdi
callq 0x5b31
jmp 0x19673
movq %rbx, %rdi
callq 0x131db
callq 0x54c0
movq %rbx, %rdi
callq 0x19c72
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
leaq 0x4(%rsp), %r14
movq %r14, %rdx
callq 0x5f59
cmpl $0x0, (%r14)
je 0x19717
movq %rbx, %rdi
movq %rax, %rsi
callq 0x615b
jmp 0x1972a
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x131a8
movq %rbx, %rdi
callq 0x6135
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x5d5d
pushq $0x1
popq %rsi
testl %eax, %eax
je 0x19752
movq %rbx, %rdi
callq 0x5b31
jmp 0x19767
movq %rbx, %rdi
callq 0x131db
callq 0x5450
movq %rbx, %rdi
callq 0x19c72
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_fmod
static int math_fmod (lua_State *L) {
  if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
    lua_Integer d = lua_tointeger(L, 2);
    if ((lua_Unsigned)d + 1u <= 1u) {  /* special cases: -1 or 0 */
      luaL_argcheck(L, d != 0, 2, "zero");
      lua_pushinteger(L, 0);  /* avoid overflow with 0x80000... / -1 */
    }
    else
      lua_pushinteger(L, lua_tointeger(L, 1) % d);
  }
  else
    lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
                                     luaL_checknumber(L, 2)));
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x5d5d
testl %eax, %eax
je 0x197c5
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x5d5d
testl %eax, %eax
je 0x197c5
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5f59
movq %rax, %r14
incq %rax
cmpq $0x1, %rax
ja 0x197f7
testq %r14, %r14
jne 0x197be
leaq 0x6a4a(%rip), %rdx      # 0x201fd
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x12af2
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x1980f
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x131db
movsd %xmm0, (%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x131db
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x51d0
movq %rbx, %rdi
callq 0x6146
jmp 0x19814
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5f59
cqto
idivq %r14
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x615b
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_ult
static int math_ult (lua_State *L) {
  lua_Integer a = luaL_checkinteger(L, 1);
  lua_Integer b = luaL_checkinteger(L, 2);
  lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x13252
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13252
xorl %esi, %esi
cmpq %rax, %r14
setb %sil
movq %rbx, %rdi
callq 0x6386
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_log
static int math_log (lua_State *L) {
  lua_Number x = luaL_checknumber(L, 1);
  lua_Number res;
  if (lua_isnoneornil(L, 2))
    res = l_mathop(log)(x);
  else {
    lua_Number base = luaL_checknumber(L, 2);
#if !defined(LUA_USE_C89)
    if (base == 2.0) res = l_mathop(log2)(x); else
#endif
    if (base == 10.0) res = l_mathop(log10)(x);
    else res = l_mathop(log)(x)/l_mathop(log)(base);
  }
  lua_pushnumber(L, res);
  return 1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x131db
movsd %xmm0, (%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x5d12
testl %eax, %eax
jle 0x1989d
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x131db
ucomisd 0x7843(%rip), %xmm0     # 0x210d0
jne 0x198a9
jp 0x198a9
movsd (%rsp), %xmm0
callq 0x5060
jmp 0x198ed
movsd (%rsp), %xmm0
callq 0x51c0
jmp 0x198ed
movapd %xmm0, %xmm1
ucomisd 0x7823(%rip), %xmm0     # 0x210d8
movsd (%rsp), %xmm0
jne 0x198c5
jp 0x198c5
callq 0x5290
jmp 0x198ed
movsd %xmm1, 0x8(%rsp)
callq 0x51c0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x51c0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x6146
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_max
static int math_max (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int imax = 1;  /* index of current maximum value */
  int i;
  luaL_argcheck(L, n >= 1, 1, "value expected");
  for (i = 2; i <= n; i++) {
    if (lua_compare(L, imax, i, LUA_OPLT))
      imax = i;
  }
  lua_pushvalue(L, imax);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x5b1d
movl %eax, %ebp
testl %eax, %eax
jg 0x19926
leaq 0x6a43(%rip), %rdx      # 0x2035e
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x12af2
pushq $0x1
popq %r14
pushq $0x2
popq %r12
movl %r14d, %r15d
cmpl %ebp, %r12d
jg 0x19953
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
movl %r14d, %ecx
callq 0x5e4d
testl %eax, %eax
je 0x1994e
movl %r12d, %r15d
incl %r12d
jmp 0x19931
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5cee
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_min
static int math_min (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int imin = 1;  /* index of current minimum value */
  int i;
  luaL_argcheck(L, n >= 1, 1, "value expected");
  for (i = 2; i <= n; i++) {
    if (lua_compare(L, i, imin, LUA_OPLT))
      imin = i;
  }
  lua_pushvalue(L, imin);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x5b1d
movl %eax, %ebp
testl %eax, %eax
jg 0x19992
leaq 0x69d7(%rip), %rdx      # 0x2035e
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x12af2
pushq $0x1
popq %r14
pushq $0x2
popq %r12
movl %r14d, %r15d
cmpl %ebp, %r12d
jg 0x199bf
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x5e4d
testl %eax, %eax
je 0x199ba
movl %r12d, %r15d
incl %r12d
jmp 0x1999d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5cee
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_modf
static int math_modf (lua_State *L) {
  if (lua_isinteger(L ,1)) {
    lua_settop(L, 1);  /* number is its own integer part */
    lua_pushnumber(L, 0);  /* no fractional part */
  }
  else {
    lua_Number n = luaL_checknumber(L, 1);
    /* integer part (rounds toward zero) */
    lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n);
    pushnumint(L, ip);
    /* fractional part (test needed for inf/-inf) */
    lua_pushnumber(L, (n == ip) ? l_mathop(0.0) : (n - ip));
  }
  return 2;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x5d5d
pushq $0x1
popq %rsi
movq %rbx, %rdi
testl %eax, %eax
je 0x199fb
callq 0x5b31
xorpd %xmm0, %xmm0
jmp 0x19a47
callq 0x131db
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
movapd %xmm0, 0x10(%rsp)
jbe 0x19a17
callq 0x54c0
jmp 0x19a1c
callq 0x5450
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x19c72
movapd 0x10(%rsp), %xmm0
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm1
cmpeqsd %xmm2, %xmm0
andnpd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x6146
pushq $0x2
popq %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_random
static int math_random (lua_State *L) {
  lua_Integer low, up;
  double r = (double)l_rand() * (1.0 / ((double)L_RANDMAX + 1.0));
  switch (lua_gettop(L)) {  /* check number of arguments */
    case 0: {  /* no arguments */
      lua_pushnumber(L, (lua_Number)r);  /* Number between 0 and 1 */
      return 1;
    }
    case 1: {  /* only upper limit */
      low = 1;
      up = luaL_checkinteger(L, 1);
      break;
    }
    case 2: {  /* lower and upper limits */
      low = luaL_checkinteger(L, 1);
      up = luaL_checkinteger(L, 2);
      break;
    }
    default: return luaL_error(L, "wrong number of arguments");
  }
  /* random integer in the interval [low, up] */
  luaL_argcheck(L, low <= up, 1, "interval is empty"); 
  luaL_argcheck(L, low >= 0 || up <= LUA_MAXINTEGER + low, 1,
                   "interval too large");
  r *= (double)(up - low) + 1.0;
  lua_pushinteger(L, (lua_Integer)r + low);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5500
cvtsi2sd %eax, %xmm0
mulsd 0x764b(%rip), %xmm0     # 0x210e8
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x5b1d
movl %eax, %r15d
cmpl $0x2, %eax
je 0x19ad4
movq %r15, %r14
cmpl $0x1, %eax
je 0x19ae2
testl %eax, %eax
jne 0x19b74
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x6146
jmp 0x19b65
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x13252
movq %rax, %r14
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13252
movq %rax, %r15
movq %rax, %r12
subq %r14, %r12
jge 0x19b0a
leaq 0x769e(%rip), %rdx      # 0x2119d
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x12af2
testq %r14, %r14
sets %al
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
addq %r14, %rcx
cmpq %rcx, %r15
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x19b3c
leaq 0x767e(%rip), %rdx      # 0x211af
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x12af2
cvtsi2sd %r12, %xmm0
addsd 0x643f(%rip), %xmm0     # 0x1ff88
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
addq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x615b
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x7608(%rip), %rsi      # 0x21183
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12bd6
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: math_type
static int math_type (lua_State *L) {
  if (lua_type(L, 1) == LUA_TNUMBER) {
      if (lua_isinteger(L, 1))
        lua_pushliteral(L, "integer"); 
      else
        lua_pushliteral(L, "float"); 
  }
  else {
    luaL_checkany(L, 1);
    lua_pushnil(L);
  }
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x5d12
pushq $0x1
popq %rsi
movq %rbx, %rdi
cmpl $0x3, %eax
jne 0x19c4f
callq 0x5d5d
testl %eax, %eax
je 0x19c5e
leaq 0x76c4(%rip), %rsi      # 0x21311
jmp 0x19c65
callq 0x131a8
movq %rbx, %rdi
callq 0x6135
jmp 0x19c6d
leaq 0x755d(%rip), %rsi      # 0x211c2
movq %rbx, %rdi
callq 0x61d0
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: os_difftime
static int os_difftime (lua_State *L) {
  time_t t1 = l_checktime(L, 1);
  time_t t2 = l_checktime(L, 2);
  lua_pushnumber(L, (lua_Number)difftime(t1, t2));
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x13252
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13252
movq %r14, %rdi
movq %rax, %rsi
callq 0x5170
movq %rbx, %rdi
callq 0x6146
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: os_execute
static int os_execute (lua_State *L) {
  const char *cmd = luaL_optstring(L, 1, NULL);
  int stat = system(cmd);
  if (cmd != NULL)
    return luaL_execresult(L, stat);
  else {
    lua_pushboolean(L, stat);  /* true if there is a shell */
    return 1;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x130d8
movq %rax, %r14
movq %rax, %rdi
callq 0x5150
movq %rbx, %rdi
movl %eax, %esi
testq %r14, %r14
je 0x19f5d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12e44
callq 0x6386
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: os_exit
static int os_exit (lua_State *L) {
  int status;
  if (lua_isboolean(L, 1))
    status = (lua_toboolean(L, 1) ? EXIT_SUCCESS : EXIT_FAILURE);
  else
    status = (int)luaL_optinteger(L, 1, EXIT_SUCCESS);
  if (lua_toboolean(L, 2))
    lua_close(L);
  if (L) exit(status);  /* 'if' to avoid warnings for unreachable 'return' */
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x5d12
pushq $0x1
popq %rsi
movq %rbx, %rdi
cmpl $0x1, %eax
jne 0x19f97
callq 0x5fa6
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
jmp 0x19fa1
xorl %edx, %edx
callq 0x132b0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x5fa6
testl %eax, %eax
je 0x19fb8
movq %rbx, %rdi
callq 0xe432
testq %rbx, %rbx
jne 0x19fc7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %r14d, %edi
callq 0x5470
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: os_setlocale
static int os_setlocale (lua_State *L) {
  static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
                      LC_NUMERIC, LC_TIME};
  static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
     "numeric", "time", NULL};
  const char *l = luaL_optstring(L, 1, NULL);
  int op = luaL_checkoption(L, 2, "all", catnames);
  lua_pushstring(L, setlocale(cat[op], l));
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x130d8
movq %rax, %r14
leaq 0x6dd1(%rip), %rdx      # 0x20e68
leaq 0x14a12(%rip), %rcx     # 0x2eab0
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x1305b
cltq
leaq 0x72ce(%rip), %rcx      # 0x21380
movl (%rcx,%rax,4), %edi
movq %r14, %rsi
callq 0x53e0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61d0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: os_time
static int os_time (lua_State *L) {
  time_t t;
  if (lua_isnoneornil(L, 1))  /* called without args? */
    t = time(NULL);  /* get current time */
  else {
    struct tm ts;
    luaL_checktype(L, 1, LUA_TTABLE);
    lua_settop(L, 1);  /* make sure table is at the top */
    ts.tm_sec = getfield(L, "sec", 0, 0);
    ts.tm_min = getfield(L, "min", 0, 0);
    ts.tm_hour = getfield(L, "hour", 12, 0);
    ts.tm_mday = getfield(L, "day", -1, 0);
    ts.tm_mon = getfield(L, "month", -1, 1);
    ts.tm_year = getfield(L, "year", -1, 1900);
    ts.tm_isdst = getboolfield(L, "isdst");
    t = mktime(&ts);
    setallfields(L, &ts);  /* update fields with normalized values */
  }
  if (t != (time_t)(l_timet)t || t == (time_t)(-1))
    luaL_error(L, "time result cannot be represented in this installation");
  l_pushtime(L, t);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x5d12
testl %eax, %eax
jle 0x1a1e8
pushq $0x1
popq %rbp
pushq $0x5
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1315e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5b31
leaq 0x713a(%rip), %rsi      # 0x21247
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1a35e
movl %eax, (%rsp)
leaq 0x703c(%rip), %rsi      # 0x2115f
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1a35e
movl %eax, 0x4(%rsp)
leaq 0x7111(%rip), %rsi      # 0x2124b
pushq $0xc
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1a35e
movl %eax, 0x8(%rsp)
leaq 0x710a(%rip), %rsi      # 0x2125c
pushq $-0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x1a35e
movl %eax, 0xc(%rsp)
leaq 0x70e2(%rip), %rsi      # 0x21250
movq %rbx, %rdi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x1a35e
movl %eax, 0x10(%rsp)
leaq 0x70d0(%rip), %rsi      # 0x21256
movq %rbx, %rdi
movl %r14d, %edx
movl $0x76c, %ecx            # imm = 0x76C
callq 0x1a35e
movl %eax, 0x14(%rsp)
leaq 0x70c4(%rip), %rdx      # 0x21265
movq %rbx, %rdi
movl %r14d, %esi
callq 0x64f4
testl %eax, %eax
je 0x1a1be
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5fa6
movl %eax, %r14d
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x5b31
movq %rsp, %r15
movl %r14d, 0x20(%r15)
movq %r15, %rdi
callq 0x5390
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a25e
jmp 0x1a1f2
xorl %edi, %edi
callq 0x5320
movq %rax, %r14
cmpq $-0x1, %r14
jne 0x1a209
leaq 0x7011(%rip), %rsi      # 0x21210
movq %rbx, %rdi
xorl %eax, %eax
callq 0x12bd6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x615b
pushq $0x1
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: os_tmpname
static int os_tmpname (lua_State *L) {
  char buff[LUA_TMPNAMBUFSIZE];
  int err;
  lua_tmpnam(buff, err);
  if (err)
    return luaL_error(L, "unable to generate a unique filename");
  lua_pushstring(L, buff);
  return 1;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x5490
testq %rax, %rax
je 0x1a247
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x61d0
pushq $0x1
popq %rax
jmp 0x1a258
leaq 0x7107(%rip), %rsi      # 0x21355
movq %rbx, %rdi
xorl %eax, %eax
callq 0x12bd6
addq $0x20, %rsp
popq %rbx
retq