LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x5d3d
movl %eax, %r14d
cmpl $0xfc, %eax
jl 0x1a3c9
leaq 0x8b08(%rip), %rdx      # 0x22ec4
movq %rbx, %rdi
movl $0xfc, %esi
callq 0x13ea8
leal -0x1(%r14), %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x63e6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x660e
movq %rbx, %rdi
movl $0x2, %esi
movl $0x2, %edx
callq 0x5da2
addl $0x2, %r14d
leaq 0xf(%rip), %rsi         # 0x1a40e
movq %rbx, %rdi
movl %r14d, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x6591
// File: /workspace/github_c_makefile_star2_O1/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 0x633d
movq %rax, %r14
movq %rbx, %rdi
movl $0xfff0b9d6, %esi       # imm = 0xFFF0B9D6
xorl %edx, %edx
callq 0x61d3
cmpq $0x0, 0x8(%r14)
je 0x1a4be
movq %rax, %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5d51
leaq 0x8a6d(%rip), %rdx      # 0x22ec4
movq %rbx, %rdi
movl %r15d, %esi
callq 0x13e55
testl %r15d, %r15d
jle 0x1a48d
movl $0xfff0b9d4, %r12d      # imm = 0xFFF0B9D4
movq %rbx, %rdi
movl %r12d, %esi
callq 0x5f5b
leal (%r15,%r12), %eax
decl %eax
movl %r12d, %ecx
decl %ecx
movl %ecx, %r12d
cmpl $0xfff0b9d4, %eax       # imm = 0xFFF0B9D4
jne 0x1a46d
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x1a56f
movl %eax, %ebp
movl %eax, %esi
negl %esi
movq %rbx, %rdi
callq 0x6223
testl %eax, %eax
je 0x1a4db
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8a12(%rip), %rsi      # 0x22ed7
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x13f8e
cmpl $0x2, %ebp
jl 0x1a511
movl $0x1, %esi
subl %ebp, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6249
leaq 0x979a(%rip), %rsi      # 0x23c92
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x13f8e
movq %rbx, %rdi
movl $0xfff0b9d5, %esi       # imm = 0xFFF0B9D5
callq 0x6223
xorl %ebp, %ebp
testl %eax, %eax
je 0x1a4af
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5d51
movq %rbx, %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x5f5b
leaq 0x8929(%rip), %rdx      # 0x22e6b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14393
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rbx, %rdi
callq *%rax
jmp 0x1a4af
// File: /workspace/github_c_makefile_star2_O1/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 0x149f7
xorl %r14d, %r14d
cmpl $-0x1, %r14d
je 0x1a9ec
cmpl $0xa, %r14d
je 0x1a9ec
movl $0x2000, %esi           # imm = 0x2000
movq %r12, %rdi
callq 0x146f3
movq %rax, %r13
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x54f0
movl %eax, %r14d
cmpl $-0x1, %eax
je 0x1a9e3
cmpl $0xa, %r14d
je 0x1a9e3
movb %r14b, (%r13,%rbx)
incq %rbx
cmpq $0x2000, %rbx           # imm = 0x2000
jne 0x1a9b7
movl $0x2000, %ebx           # imm = 0x2000
movl %ebx, %eax
addq %rax, 0x18(%rsp)
jmp 0x1a999
movl %r14d, %eax
xorl $0xa, %eax
orl %eax, %ebp
jne 0x1aa28
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jb 0x1aa11
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x146f3
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rsp)
movb $0xa, (%rax,%rcx)
leaq 0x8(%rsp), %rdi
callq 0x148ef
movl $0x1, %eax
cmpl $0xa, %r14d
je 0x1aa56
movq (%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x62c9
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_O1/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 0x5540
movq %rax, %r15
movq (%r15), %rax
testl %ebx, %ebx
je 0x1aa92
movslq 0x8(%r14), %rcx
testb $0x10, 0x1(%rax,%rcx,2)
jne 0x1aa9d
jmp 0x1aaad
movslq 0x8(%r14), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x1aaad
movq %r14, %rdi
callq 0x1aaba
testl %eax, %eax
je 0x1aaad
incl %ebp
jmp 0x1aa7e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/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 0x1aad2
movb $0x0, 0x10(%rbx)
xorl %eax, %eax
jmp 0x1aaef
movb 0x8(%rbx), %cl
leal 0x1(%rax), %edx
movl %edx, 0xc(%rbx)
movb %cl, 0x10(%rbx,%rax)
movq (%rbx), %rdi
callq 0x54f0
movl %eax, 0x8(%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5d3d
movl %eax, %r15d
movl $0x1, %eax
cmpl %ebp, %r15d
je 0x1ac00
movl $0x1, %r13d
movq %rsp, %r12
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5f7f
movq %rbx, %rdi
movl %ebp, %esi
cmpl $0x3, %eax
jne 0x1ab85
callq 0x5fcc
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
testl %eax, %eax
je 0x1abb3
callq 0x61d3
movq %r14, %rdi
leaq 0x6bc7(%rip), %rsi      # 0x21740
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
jmp 0x1abc9
movq %r12, %rdx
callq 0x14535
testl %r13d, %r13d
je 0x1abdc
movq (%rsp), %rdx
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rcx
callq 0x54a0
xorl %r13d, %r13d
cmpq (%rsp), %rax
sete %r13b
jmp 0x1abdf
callq 0x6182
movq %r14, %rdi
leaq 0x6b83(%rip), %rsi      # 0x21745
movb $0x1, %al
callq 0x52c0
testl %r13d, %r13d
setne %cl
testl %eax, %eax
setg %al
andb %cl, %al
movzbl %al, %r13d
jmp 0x1abdf
xorl %r13d, %r13d
incl %ebp
cmpl %ebp, %r15d
jne 0x1ab46
movl $0x1, %eax
testl %r13d, %r13d
jne 0x1ac00
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x14198
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/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 0x1a1d9
movq %rax, %r14
leaq 0x82ba(%rip), %rdx      # 0x22f37
leaq 0x13b6c(%rip), %rcx     # 0x2e7f0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1444b
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x146c5
movslq %ebp, %rcx
leaq 0x82cc(%rip), %rdx      # 0x22f78
movl (%rdx,%rcx,4), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x53e0
testl %eax, %eax
je 0x1acce
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x14198
movq %r14, %rdi
callq 0x52d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x63e6
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1a1d9
movq %rax, %r14
leaq 0x13b0f(%rip), %rcx     # 0x2e810
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x1444b
movl %eax, %ebp
movl $0x2000, %edx           # imm = 0x2000
movq %rbx, %rdi
movl $0x3, %esi
callq 0x146c5
movslq %ebp, %rcx
leaq 0x8256(%rip), %rdx      # 0x22f84
movl (%rdx,%rcx,4), %edx
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rcx
callq 0x5410
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x14198
// File: /workspace/github_c_makefile_star2_O1/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 0x80d5(%rip), %rdx      # 0x22e6b
movl $0x1, %esi
callq 0x14393
cmpq $0x0, 0x8(%rax)
je 0x1addc
cmpq $0x0, (%rax)
je 0x1addc
leaq 0x80b7(%rip), %rdx      # 0x22e6b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14393
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rbx, %rdi
callq *%rax
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x807c(%rip), %rdx      # 0x22e6b
movl $0x1, %esi
callq 0x14393
cmpq $0x0, 0x8(%rax)
je 0x1ae16
movq (%rax), %rdx
leaq 0x8147(%rip), %rsi      # 0x22f51
movq %rbx, %rdi
xorl %eax, %eax
callq 0x64e8
jmp 0x1ae25
leaq 0x8126(%rip), %rsi      # 0x22f43
movq %rbx, %rdi
callq 0x645b
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: 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 0x8034(%rip), %rdx      # 0x22e6b
movl $0x1, %esi
callq 0x14393
leaq -0x1c(%rip), %rcx       # 0x1ae2c
movq %rcx, 0x8(%rax)
movq %rbx, %rdi
callq 0x63bd
leaq 0x8100(%rip), %rsi      # 0x22f5b
movq %rbx, %rdi
callq 0x645b
movl $0x2, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x7d85(%rip), %xmm0     # 0x22c00
movl $0x88, %esi
callq 0x1540b
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1b, %edx
callq 0x68d6
leaq 0x13995(%rip), %rsi     # 0x2e830
movq %rbx, %rdi
xorl %edx, %edx
callq 0x150f3
movsd 0x80e3(%rip), %xmm0     # 0x22f90
movq %rbx, %rdi
callq 0x63d1
leaq 0x8124(%rip), %rdx      # 0x22fe0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movsd 0x80c7(%rip), %xmm0     # 0x22f98
movq %rbx, %rdi
callq 0x63d1
leaq 0x8103(%rip), %rdx      # 0x22fe3
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movabsq $0x7fffffffffffffff, %r14 # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63e6
leaq 0x80df(%rip), %rdx      # 0x22fe8
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63e6
leaq 0x80c8(%rip), %rdx      # 0x22ff3
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5fcc
movq %rbx, %rdi
movl $0x1, %esi
testl %eax, %eax
je 0x1af7a
xorl %edx, %edx
callq 0x61d3
movq %rax, %rsi
negq %rsi
cmovsq %rax, %rsi
movq %rbx, %rdi
callq 0x63e6
jmp 0x1af8e
callq 0x145d6
andps 0x804a(%rip), %xmm0     # 0x22fd0
movq %rbx, %rdi
callq 0x63d1
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x145d6
movsd %xmm0, 0x8(%rsp)
movsd 0x6eff(%rip), %xmm0     # 0x21ef8
movq %rbx, %rdi
movl $0x2, %esi
callq 0x14625
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x53c0
movq %rbx, %rdi
callq 0x63d1
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5fcc
testl %eax, %eax
je 0x1b048
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5d51
jmp 0x1b062
movq %rbx, %rdi
movl $0x1, %esi
callq 0x145d6
callq 0x54e0
movq %rbx, %rdi
callq 0x1b6cc
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x61d3
cmpl $0x0, (%r14)
je 0x1b0fe
movq %rbx, %rdi
movq %rax, %rsi
callq 0x63e6
jmp 0x1b113
movq %rbx, %rdi
movl $0x1, %esi
callq 0x145a3
movq %rbx, %rdi
callq 0x63bd
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5fcc
testl %eax, %eax
je 0x1b141
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5d51
jmp 0x1b15b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x145d6
callq 0x5470
movq %rbx, %rdi
callq 0x1b6cc
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x5fcc
testl %eax, %eax
je 0x1b1c3
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5fcc
testl %eax, %eax
je 0x1b1c3
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x61d3
movq %rax, %r14
incq %rax
cmpq $0x1, %rax
ja 0x1b1f9
testq %r14, %r14
jne 0x1b1bc
leaq 0x6f82(%rip), %rdx      # 0x22131
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13ea8
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x1b213
movq %rbx, %rdi
movl $0x1, %esi
callq 0x145d6
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x145d6
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x51f0
movq %rbx, %rdi
callq 0x63d1
jmp 0x1b218
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x61d3
cqto
idivq %r14
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x63e6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1465a
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1465a
xorl %esi, %esi
cmpq %rax, %r14
setb %sil
movq %rbx, %rdi
callq 0x660e
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x145d6
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5f7f
testl %eax, %eax
jle 0x1b2b1
movq %rbx, %rdi
movl $0x2, %esi
callq 0x145d6
ucomisd 0x7d07(%rip), %xmm0     # 0x22fa8
jne 0x1b2bd
jp 0x1b2bd
movsd (%rsp), %xmm0
callq 0x5060
jmp 0x1b301
movsd (%rsp), %xmm0
callq 0x51e0
jmp 0x1b301
movapd %xmm0, %xmm1
ucomisd 0x7ce7(%rip), %xmm0     # 0x22fb0
movsd (%rsp), %xmm0
jne 0x1b2d9
jp 0x1b2d9
callq 0x52b0
jmp 0x1b301
movsd %xmm1, 0x8(%rsp)
callq 0x51e0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x51e0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x63d1
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5d3d
movl %eax, %r14d
testl %eax, %eax
jg 0x1b33e
leaq 0x6f61(%rip), %rdx      # 0x22292
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13ea8
movl $0x1, %ebp
cmpl $0x2, %r14d
jl 0x1b37e
negl %r14d
movl $0x2, %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
movl $0x1, %ecx
callq 0x60c4
testl %eax, %eax
je 0x1b36b
movl %r15d, %ebp
leal (%r14,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0x1b352
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5f5b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5d3d
movl %eax, %r14d
testl %eax, %eax
jg 0x1b3c2
leaq 0x6edd(%rip), %rdx      # 0x22292
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13ea8
movl $0x1, %ebp
cmpl $0x2, %r14d
jl 0x1b402
negl %r14d
movl $0x2, %r15d
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x60c4
testl %eax, %eax
je 0x1b3ef
movl %r15d, %ebp
leal (%r14,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0x1b3d6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5f5b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x5fcc
movq %rbx, %rdi
movl $0x1, %esi
testl %eax, %eax
je 0x1b445
callq 0x5d51
xorpd %xmm0, %xmm0
jmp 0x1b491
callq 0x145d6
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
movapd %xmm0, 0x10(%rsp)
jbe 0x1b461
callq 0x54e0
jmp 0x1b466
callq 0x5470
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x1b6cc
movapd 0x10(%rsp), %xmm0
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm1
cmpeqsd %xmm2, %xmm0
andnpd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x63d1
movl $0x2, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5520
cvtsi2sd %eax, %xmm0
mulsd 0x7adb(%rip), %xmm0     # 0x22fc0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x5d3d
cmpl $0x2, %eax
je 0x1b51b
cmpl $0x1, %eax
je 0x1b516
testl %eax, %eax
jne 0x1b5ca
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x63d1
jmp 0x1b5b9
movl %eax, %r14d
jmp 0x1b530
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1465a
movq %rax, %r14
movl $0x2, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x1465a
movq %rax, %r15
movq %rax, %r12
subq %r14, %r12
jge 0x1b559
leaq 0x7b31(%rip), %rdx      # 0x2307d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13ea8
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 0x1b58d
leaq 0x7b0f(%rip), %rdx      # 0x2308f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13ea8
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
addsd 0x695b(%rip), %xmm0     # 0x21ef8
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
addq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63e6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x7a92(%rip), %rsi      # 0x23063
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x13f8e
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x5f7f
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x3, %eax
jne 0x1b6a7
callq 0x5fcc
testl %eax, %eax
je 0x1b6b6
leaq 0x7b4f(%rip), %rsi      # 0x231f4
jmp 0x1b6bd
callq 0x145a3
movq %rbx, %rdi
callq 0x63bd
jmp 0x1b6c5
leaq 0x79e5(%rip), %rsi      # 0x230a2
movq %rbx, %rdi
callq 0x645b
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1465a
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1465a
movq %r14, %rdi
movq %rax, %rsi
callq 0x5180
movq %rbx, %rdi
callq 0x63d1
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x144dc
movq %rax, %r14
movq %rax, %rdi
callq 0x5160
movq %rbx, %rdi
movl %eax, %esi
testq %r14, %r14
je 0x1b9d8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1421d
callq 0x660e
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x5f7f
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x1, %eax
jne 0x1ba18
callq 0x6223
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
jmp 0x1ba22
xorl %edx, %edx
callq 0x146c5
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6223
testl %eax, %eax
je 0x1ba3b
movq %rbx, %rdi
callq 0xf094
testq %rbx, %rbx
jne 0x1ba4a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %r14d, %edi
callq 0x5490
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x144dc
movq %rax, %r14
leaq 0x722c(%rip), %rdx      # 0x22d48
leaq 0x12f8d(%rip), %rcx     # 0x2eab0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1444b
cltq
leaq 0x7727(%rip), %rcx      # 0x23260
movl (%rcx,%rax,4), %edi
movq %r14, %rsi
callq 0x5400
movq %rbx, %rdi
movq %rax, %rsi
callq 0x645b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x5f7f
testl %eax, %eax
jle 0x1bc8d
movq %rbx, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1456f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5d51
leaq 0x7589(%rip), %rsi      # 0x2312a
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1be50
movl %eax, (%rsp)
leaq 0x7488(%rip), %rsi      # 0x2303f
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1be50
movl %eax, 0x4(%rsp)
leaq 0x7560(%rip), %rsi      # 0x2312e
movq %rbx, %rdi
movl $0xc, %edx
xorl %ecx, %ecx
callq 0x1be50
movl %eax, 0x8(%rsp)
leaq 0x7557(%rip), %rsi      # 0x2313f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x1be50
movl %eax, 0xc(%rsp)
leaq 0x752c(%rip), %rsi      # 0x23133
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
callq 0x1be50
movl %eax, 0x10(%rsp)
leaq 0x7515(%rip), %rsi      # 0x23139
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x76c, %ecx            # imm = 0x76C
callq 0x1be50
movl %eax, 0x14(%rsp)
leaq 0x7507(%rip), %rdx      # 0x23148
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6777
testl %eax, %eax
je 0x1bc61
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6223
movl %eax, %ebp
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movq %rsp, %r15
movl %ebp, 0x20(%r15)
movq %r15, %rdi
callq 0x53b0
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1bd07
jmp 0x1bc97
xorl %edi, %edi
callq 0x5340
movq %rax, %r14
cmpq $-0x1, %r14
jne 0x1bcae
leaq 0x744c(%rip), %rsi      # 0x230f0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13f8e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63e6
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x54b0
testq %rax, %rax
je 0x1bcf0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x645b
movl $0x1, %eax
jmp 0x1bd01
leaq 0x7541(%rip), %rsi      # 0x23238
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13f8e
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: setallfields
static void setallfields (lua_State *L, struct tm *stm) {
  setfield(L, "sec", stm->tm_sec);
  setfield(L, "min", stm->tm_min);
  setfield(L, "hour", stm->tm_hour);
  setfield(L, "day", stm->tm_mday);
  setfield(L, "month", stm->tm_mon + 1);
  setfield(L, "year", stm->tm_year + 1900);
  setfield(L, "wday", stm->tm_wday + 1);
  setfield(L, "yday", stm->tm_yday + 1);
  setboolfield(L, "isdst", stm->tm_isdst);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq (%rsi), %rsi
callq 0x63e6
leaq 0x740a(%rip), %rdx      # 0x2312a
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movslq 0x4(%r14), %rsi
movq %rbx, %rdi
callq 0x63e6
leaq 0x72ff(%rip), %rdx      # 0x2303f
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movslq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x63e6
leaq 0x73ce(%rip), %rdx      # 0x2312e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movslq 0xc(%r14), %rsi
movq %rbx, %rdi
callq 0x63e6
leaq 0x73bf(%rip), %rdx      # 0x2313f
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movslq 0x10(%r14), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x63e6
leaq 0x7390(%rip), %rdx      # 0x23133
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movslq 0x14(%r14), %rsi
addq $0x76c, %rsi            # imm = 0x76C
movq %rbx, %rdi
callq 0x63e6
leaq 0x736f(%rip), %rdx      # 0x23139
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movslq 0x18(%r14), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x63e6
leaq 0x7351(%rip), %rdx      # 0x2313e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movslq 0x1c(%r14), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x63e6
leaq 0x7333(%rip), %rdx      # 0x23143
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6b3f
movl 0x20(%r14), %esi
testl %esi, %esi
js 0x1be48
movq %rbx, %rdi
callq 0x660e
leaq 0x7314(%rip), %rdx      # 0x23148
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6b3f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/loslib.c
// Function: getfield
static int getfield (lua_State *L, const char *key, int d, int delta) {
  int isnum;
  int t = lua_getfield(L, -1, key);  /* get field and its type */
  lua_Integer res = lua_tointegerx(L, -1, &isnum);
  if (!isnum) {  /* field is not an integer? */
    if (t != LUA_TNIL)  /* some other value? */
      return luaL_error(L, "field '%s' is not an integer", key);
    else if (d < 0)  /* absent field; no default? */
      return luaL_error(L, "field '%s' missing in date table", key);
    res = d;
  }
  else {
    if (!(-L_MAXDATEFIELD <= res && res <= L_MAXDATEFIELD))
      return luaL_error(L, "field '%s' is out-of-bound", key);
    res -= delta;
  }
  lua_pop(L, 1);
  return (int)res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x6777
movl %eax, %r12d
leaq 0x4(%rsp), %r13
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r13, %rdx
callq 0x61d3
cmpl $0x0, (%r13)
je 0x1bea9
leaq 0x3fffffff(%rax), %rcx
cmpq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
jae 0x1beb7
subl %r15d, %eax
movl %eax, %ebp
jmp 0x1bed3
testl %r12d, %r12d
je 0x1becf
leaq 0x732a(%rip), %rsi      # 0x231df
jmp 0x1bebe
leaq 0x735f(%rip), %rsi      # 0x2321d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x13f8e
movl %eax, %ebp
jmp 0x1bee0
testl %ebp, %ebp
js 0x1bef1
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5d51
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7304(%rip), %rsi      # 0x231fc
jmp 0x1bebe
nop
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_byte
static int str_byte (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  lua_Integer posi = posrelat(luaL_optinteger(L, 2, 1), l);
  lua_Integer pose = posrelat(luaL_optinteger(L, 3, posi), l);
  int n, i;
  if (posi < 1) posi = 1;
  if (pose > (lua_Integer)l) pose = l;
  if (posi > pose) return 0;  /* empty interval; return no values */
  if (pose - posi >= INT_MAX)  /* arithmetic overflow? */
    return luaL_error(L, "string slice too long");
  n = (int)(pose -  posi) + 1;
  luaL_checkstack(L, n, "string slice too long");
  for (i=0; i<n; i++)
    lua_pushinteger(L, uchar(s[posi+i-1]));
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdx
movl $0x1, %esi
callq 0x14535
movq %rax, %r14
movl $0x1, %edx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x146c5
movq %rax, %r15
testq %rax, %rax
jns 0x1bffe
movq (%rsp), %rax
movq %r15, %rcx
negq %rcx
cmpq %rcx, %rax
jae 0x1bff8
xorl %r15d, %r15d
jmp 0x1bffe
addq %rax, %r15
incq %r15
movq %rbx, %rdi
movl $0x3, %esi
movq %r15, %rdx
callq 0x146c5
movq (%rsp), %r12
testq %rax, %rax
jns 0x1c02c
movq %rax, %rcx
negq %rcx
cmpq %rcx, %r12
jae 0x1c026
xorl %eax, %eax
jmp 0x1c02c
addq %r12, %rax
incq %rax
cmpq $0x2, %r15
movl $0x1, %r13d
cmovgeq %r15, %r13
cmpq %r12, %rax
cmovlq %rax, %r12
xorl %ebp, %ebp
movq %r12, %r15
subq %r13, %r15
jl 0x1c0a7
cmpq $0x7fffffff, %r15       # imm = 0x7FFFFFFF
jl 0x1c069
leaq 0x7429(%rip), %rsi      # 0x23484
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13f8e
movl %eax, %ebp
jmp 0x1c0a7
leal 0x1(%r15), %ebp
leaq 0x7410(%rip), %rdx      # 0x23484
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13e55
testl %r15d, %r15d
js 0x1c0a7
addq %r13, %r14
decq %r14
subl %r13d, %r12d
incl %r12d
xorl %r15d, %r15d
movzbl (%r14,%r15), %esi
movq %rbx, %rdi
callq 0x63e6
incq %r15
cmpq %r15, %r12
jne 0x1c092
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_char
static int str_char (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  luaL_Buffer b;
  char *p = luaL_buffinitsize(L, &b, n);
  for (i=1; i<=n; i++) {
    lua_Integer c = luaL_checkinteger(L, i);
    luaL_argcheck(L, uchar(c) == c, i, "value out of range");
    p[i - 1] = uchar(c);
  }
  luaL_pushresultsize(&b, n);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, %rbx
callq 0x5d3d
movl %eax, %r15d
movslq %eax, %r14
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x14a13
movq %r14, (%rsp)
testl %r14d, %r14d
jle 0x1c134
movq %rax, %r12
incl %r15d
movl $0x1, %r13d
leaq 0x7397(%rip), %rbp      # 0x2349a
movq %rbx, %rdi
movl %r13d, %esi
callq 0x1465a
movq %rax, %r14
cmpq $0x100, %rax            # imm = 0x100
jb 0x1c127
movq %rbx, %rdi
movl %r13d, %esi
movq %rbp, %rdx
callq 0x13ea8
movb %r14b, -0x1(%r12,%r13)
incq %r13
cmpq %r13, %r15
jne 0x1c103
leaq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1494f
movl $0x1, %eax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_dump
static int str_dump (lua_State *L) {
  luaL_Buffer b;
  int strip = lua_toboolean(L, 2);
  luaL_checktype(L, 1, LUA_TFUNCTION);
  lua_settop(L, 1);
  luaL_buffinit(L,&b);
  if (lua_dump(L, writer, &b, strip) != 0)
    return luaL_error(L, "unable to dump given function");
  luaL_pushresult(&b);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, %rbx
movl $0x2, %esi
callq 0x6223
movl %eax, %r14d
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
movl $0x6, %edx
callq 0x1456f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5d51
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x149f7
leaq 0x1764(%rip), %rsi      # 0x1d915
movq %rbx, %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x7042
testl %eax, %eax
je 0x1c1d8
leaq 0x72e3(%rip), %rsi      # 0x234ad
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13f8e
movl %eax, %ebp
jmp 0x1c1e2
leaq 0x8(%rsp), %rdi
callq 0x148ef
movl %ebp, %eax
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: gmatch
static int gmatch (lua_State *L) {
  size_t ls, lp;
  const char *s = luaL_checklstring(L, 1, &ls);
  const char *p = luaL_checklstring(L, 2, &lp);
  GMatchState *gm;
  lua_settop(L, 2);  /* keep them on closure to avoid being collected */
  gm = (GMatchState *)lua_newuserdata(L, sizeof(GMatchState));
  prepstate(&gm->ms, L, s, ls, p, lp);
  gm->src = s; gm->p = p; gm->lastmatch = NULL;
  lua_pushcclosure(L, gmatch_aux, 3);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x14535
movq %rax, %r14
movq %rsp, %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x14535
movq %rax, %r13
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5d51
movl $0x240, %esi            # imm = 0x240
movq %rbx, %rdi
callq 0x727a
movq (%r15), %rcx
addq %r14, %rcx
movq (%r12), %rdx
addq %r13, %rdx
movq %rbx, 0x30(%rax)
movl $0xc8, 0x38(%rax)
movq %r14, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %r14, (%rax)
movq %r13, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq 0x1ba4(%rip), %rsi      # 0x1e4a2
movq %rbx, %rdi
movl $0x3, %edx
callq 0x6591
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_len
static int str_len (lua_State *L) {
  size_t l;
  luaL_checklstring(L, 1, &l);
  lua_pushinteger(L, (lua_Integer)l);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x14535
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x63e6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tylerneylon[P]APIsWithLua/lua/lstrlib.c
// Function: str_lower
static int str_lower (lua_State *L) {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  char *p = luaL_buffinitsize(L, &b, l);
  for (i=0; i<l; i++)
    p[i] = tolower(uchar(s[i]));
  luaL_pushresultsize(&b, l);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x14535
movq %rax, %rbx
movq (%r15), %rdx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x14a13
movq (%r15), %rsi
testq %rsi, %rsi
je 0x1ce1c
movq %rax, %r14
xorl %r15d, %r15d
callq 0x5530
movq (%rax), %rcx
movzbl (%rbx,%r15), %edx
movb (%rcx,%rdx,4), %cl
movb %cl, (%r14,%r15)
incq %r15
movq 0x8(%rsp), %rsi
cmpq %rsi, %r15
jb 0x1ce00
leaq 0x10(%rsp), %rdi
callq 0x1494f
movl $0x1, %eax
addq $0x2030, %rsp           # imm = 0x2030
popq %rbx
popq %r14
popq %r15
retq