LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x20470
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xd0e1(%rip), %rdx      # 0x3667b
callq 0x20080
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x295b5
movq -0x8(%rbp), %rdi
callq 0x6b60
jmp 0x295e4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x295d2
movq -0x8(%rbp), %rdi
leaq 0xd0c7(%rip), %rsi      # 0x36692
callq 0x6ce0
jmp 0x295e2
movq -0x8(%rbp), %rdi
leaq 0xd0bc(%rip), %rsi      # 0x36699
callq 0x6ce0
jmp 0x295e4
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xd02f(%rip), %rdx      # 0x3667b
callq 0x20120
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x29672
movq -0x8(%rbp), %rdi
leaq 0xd016(%rip), %rsi      # 0x36681
movb $0x0, %al
callq 0x1fbf0
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xcfdf(%rip), %rdx      # 0x3667b
callq 0x20120
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x72f0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x69e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x29729
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x4, %rdx
leaq 0xcf7c(%rip), %rsi      # 0x3669e
movb $0x0, %al
callq 0x1fbf0
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
cmpl $0x0, %eax
jle 0x297c0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x67d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x29797
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x297e0
jmp 0x297ae
movq -0x8(%rbp), %rdi
callq 0x29630
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6190
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x7ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x72f0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29860
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x52d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x29857
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x5080
movl (%rax), %edi
callq 0x54a0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0xce69(%rip), %rsi      # 0x366b9
movb $0x0, %al
callq 0x1fbf0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x298a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
leaq 0x61(%rip), %rcx        # 0x298f0
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x8990
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
leaq 0xcda6(%rip), %rsi      # 0x3667b
callq 0x20040
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d90
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movb $0x1, %al
cmpl $0xfa, -0x10(%rbp)
movb %al, -0x11(%rbp)
jle 0x2999a
movq -0x8(%rbp), %rdi
movl $0xfc, %esi
leaq 0xcd48(%rip), %rdx      # 0x366d4
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x6be0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6fc0
movq -0x8(%rbp), %rdi
movl $0x2, %edx
movl %edx, %esi
callq 0x5e60
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
addl $0x3, %edx
leaq 0x19(%rip), %rsi        # 0x299f0
callq 0x6ea0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x69e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xfff0b9d6, %esi       # imm = 0xFFF0B9D6
xorl %eax, %eax
movl %eax, %edx
callq 0x66e0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x29a48
movq -0x10(%rbp), %rdi
leaq 0xccae(%rip), %rsi      # 0x366e7
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x29b45
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5dc0
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
leaq 0xcc70(%rip), %rdx      # 0x366d4
callq 0x1f930
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x29a99
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x3, %eax
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
subl %eax, %esi
callq 0x6190
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x29a70
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x2, %edx
callq 0x29b50
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
subl -0x20(%rbp), %esi
callq 0x6770
cmpl $0x0, %eax
je 0x29acc
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x29b45
cmpl $0x1, -0x20(%rbp)
jle 0x29b09
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
subl -0x20(%rbp), %esi
addl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x67d0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0xdb53(%rip), %rsi      # 0x37650
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x29b45
movq -0x10(%rbp), %rdi
movl $0xfff0b9d5, %esi       # imm = 0xFFF0B9D5
callq 0x6770
cmpl $0x0, %eax
je 0x29b3e
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5dc0
movq -0x10(%rbp), %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x6190
movq -0x10(%rbp), %rdi
callq 0x29680
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x203c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2038(%rbp), %rsi
callq 0x20aa0
xorl %eax, %eax
cmpl $-0x1, -0x203c(%rbp)
movb %al, -0x204d(%rbp)
je 0x29dc1
cmpl $0xa, -0x203c(%rbp)
setne %al
movb %al, -0x204d(%rbp)
movb -0x204d(%rbp), %al
testb $0x1, %al
jne 0x29dd0
jmp 0x29e82
leaq -0x2038(%rbp), %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x20630
movq %rax, -0x2048(%rbp)
movl $0x0, -0x204c(%rbp)
xorl %eax, %eax
cmpl $0x2000, -0x204c(%rbp)  # imm = 0x2000
movb %al, -0x204e(%rbp)
jge 0x29e34
movq -0x10(%rbp), %rdi
callq 0x54c0
movl %eax, %ecx
movl %ecx, -0x203c(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x204e(%rbp)
je 0x29e34
cmpl $0xa, -0x203c(%rbp)
setne %al
movb %al, -0x204e(%rbp)
movb -0x204e(%rbp), %al
testb $0x1, %al
jne 0x29e40
jmp 0x29e68
movl -0x203c(%rbp), %eax
movb %al, %dl
movq -0x2048(%rbp), %rax
movl -0x204c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x204c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x29df2
movslq -0x204c(%rbp), %rax
addq -0x2028(%rbp), %rax
movq %rax, -0x2028(%rbp)
jmp 0x29da0
cmpl $0x0, -0x14(%rbp)
jne 0x29ef4
cmpl $0xa, -0x203c(%rbp)
jne 0x29ef4
movq -0x2028(%rbp), %rcx
movb $0x1, %al
cmpq -0x2030(%rbp), %rcx
movb %al, -0x204f(%rbp)
jb 0x29ec7
leaq -0x2038(%rbp), %rdi
movl $0x1, %esi
callq 0x20630
cmpq $0x0, %rax
setne %al
movb %al, -0x204f(%rbp)
movb -0x204f(%rbp), %al
movl -0x203c(%rbp), %eax
movb %al, %dl
movq -0x2038(%rbp), %rax
movq -0x2028(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x2028(%rbp)
movb %dl, (%rax,%rcx)
leaq -0x2038(%rbp), %rdi
callq 0x20940
movb $0x1, %al
cmpl $0xa, -0x203c(%rbp)
movb %al, -0x2050(%rbp)
je 0x29f2c
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x68c0
cmpq $0x0, %rax
seta %al
movb %al, -0x2050(%rbp)
movb -0x2050(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: test_eof
static int test_eof (lua_State *L, FILE *f) {
  int c = getc(f);
  ungetc(c, f);  /* no-op when c == EOF */
  lua_pushliteral(L, "");
  return (c != EOF);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x54c0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x5360
movq -0x8(%rbp), %rdi
leaq 0xd713(%rip), %rsi      # 0x37686
callq 0x6ce0
cmpl $-0x1, -0x14(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: read_chars
static int read_chars (lua_State *L, FILE *f, size_t n) {
  size_t nr;  /* number of chars actually read */
  char *p;
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  p = luaL_prepbuffsize(&b, n);  /* prepare buffer to read whole block */
  nr = fread(p, sizeof(char), n, f);  /* try to read 'n' chars */
  luaL_addsize(&b, nr);
  luaL_pushresult(&b);  /* close buffer */
  return (nr > 0);  /* true iff read something */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2048(%rbp), %rsi
callq 0x20aa0
movq -0x18(%rbp), %rsi
leaq -0x2048(%rbp), %rdi
callq 0x20630
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x50e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x2038(%rbp), %rax
movq %rax, -0x2038(%rbp)
leaq -0x2048(%rbp), %rdi
callq 0x20940
cmpq $0x0, -0x20(%rbp)
seta %al
andb $0x1, %al
movzbl %al, %eax
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: read_all
static void read_all (lua_State *L, FILE *f) {
  size_t nr;
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  do {  /* read file in chunks of LUAL_BUFFERSIZE bytes */
    char *p = luaL_prepbuffer(&b);
    nr = fread(p, sizeof(char), LUAL_BUFFERSIZE, f);
    luaL_addsize(&b, nr);
  } while (nr == LUAL_BUFFERSIZE);
  luaL_pushresult(&b);  /* close buffer */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2038(%rbp), %rsi
callq 0x20aa0
leaq -0x2038(%rbp), %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x20630
movq %rax, -0x2040(%rbp)
movq -0x2040(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x50e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq -0x2028(%rbp), %rax
movq %rax, -0x2028(%rbp)
cmpq $0x2000, -0x18(%rbp)    # imm = 0x2000
je 0x2a233
leaq -0x2038(%rbp), %rdi
callq 0x20940
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x2a342
callq 0x5500
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x1000, %ecx           # imm = 0x1000
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x2a366
jmp 0x2a378
callq 0x5500
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x2a378
movq -0x8(%rbp), %rdi
callq 0x2a3a0
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x2a381
jmp 0x2a38c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2a316
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xc8, 0xc(%rax)
jl 0x2a3ca
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2a409
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movl 0xc(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0xc(%rsi)
movslq %ecx, %rcx
movb %dl, 0x10(%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x54c0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5d90
subl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
cmpl $0x0, %eax
je 0x2a5a4
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x61f0
cmpl $0x3, %eax
jne 0x2a54a
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x62c0
cmpl $0x0, %eax
je 0x2a4f5
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x66e0
movq -0x48(%rbp), %rdi
movq %rax, %rdx
leaq 0xa6e7(%rip), %rsi      # 0x34bd0
movb $0x0, %al
callq 0x52a0
movl %eax, -0x3c(%rbp)
jmp 0x2a522
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6650
movq -0x50(%rbp), %rdi
leaq 0xa6bd(%rip), %rsi      # 0x34bd5
movb $0x1, %al
callq 0x52a0
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0x51(%rbp)
je 0x2a53d
cmpl $0x0, -0x28(%rbp)
setg %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
jmp 0x2a594
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0x20390
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x24(%rbp)
movb %al, -0x52(%rbp)
je 0x2a589
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x5470
cmpq -0x30(%rbp), %rax
sete %al
movb %al, -0x52(%rbp)
movb -0x52(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
jmp 0x2a596
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2a489
cmpl $0x0, -0x24(%rbp)
je 0x2a5b3
movl $0x1, -0x4(%rbp)
jmp 0x2a5c6
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1fe50
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29630
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0xc091(%rip), %rdx      # 0x3674a
leaq 0x18130(%rip), %rcx     # 0x427f0
callq 0x20230
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x205e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movb $0x1, %al
cmpq -0x28(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x2a713
movq -0x10(%rbp), %rdi
movl $0x3, %esi
leaq 0xc049(%rip), %rdx      # 0x3674e
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0x1c(%rbp), %rcx
leaq 0xbef7(%rip), %rax      # 0x36620
movl (%rax,%rcx,4), %edx
callq 0x53b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2a74e
movq -0x10(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1fe50
movl %eax, -0x4(%rbp)
jmp 0x2a772
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x52b0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x6be0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/liolib.c
// Function: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29630
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x18063(%rip), %rcx     # 0x42810
callq 0x20230
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x205e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xbe51(%rip), %rax      # 0x3662c
movl (%rax,%rcx,4), %edx
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x53e0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
cmpl $0x0, -0x24(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1fe50
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xbe0f(%rip), %rdx      # 0x3667b
callq 0x20120
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2a893
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2a893
movq -0x8(%rbp), %rdi
callq 0x29680
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xbdbf(%rip), %rdx      # 0x3667b
callq 0x20120
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2a8e2
movq -0x8(%rbp), %rdi
leaq 0xbe9a(%rip), %rsi      # 0x36775
callq 0x6ce0
jmp 0x2a8fb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xbe8f(%rip), %rsi      # 0x36783
movb $0x0, %al
callq 0x6de0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xbd4f(%rip), %rdx      # 0x3667b
callq 0x20120
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq -0x30(%rip), %rcx       # 0x2a910
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x6b60
movq -0x8(%rbp), %rdi
leaq 0xbe35(%rip), %rsi      # 0x3678d
callq 0x6ce0
movl $0x2, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movsd 0xb9f8(%rip), %xmm0     # 0x36380
movl $0x88, %esi
callq 0x218a0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1b, %edx
callq 0x75e0
movq -0x8(%rbp), %rdi
leaq 0x17e83(%rip), %rsi     # 0x42830
xorl %edx, %edx
callq 0x214b0
movq -0x8(%rbp), %rdi
movsd 0xbdf0(%rip), %xmm0     # 0x367b0
callq 0x6b90
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xbe1b(%rip), %rdx      # 0x367f0
callq 0x7ae0
movq -0x8(%rbp), %rdi
movsd 0xbdc2(%rip), %xmm0     # 0x367a8
callq 0x6b90
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xbdf8(%rip), %rdx      # 0x367f3
callq 0x7ae0
movq -0x8(%rbp), %rdi
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
callq 0x6be0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xbdd5(%rip), %rdx      # 0x367f8
callq 0x7ae0
movq -0x8(%rbp), %rdi
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
callq 0x6be0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xbdb8(%rip), %rdx      # 0x36803
callq 0x7ae0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x62c0
cmpl $0x0, %eax
je 0x2aab5
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x66e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x2aaa6
xorl %eax, %eax
subq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6be0
jmp 0x2aadf
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x204b0
movq -0x18(%rbp), %rdi
movaps 0xbd0a(%rip), %xmm1     # 0x367e0
pand %xmm1, %xmm0
callq 0x6b90
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x204b0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movsd 0xa7a0(%rip), %xmm0     # 0x35340
callq 0x20500
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x5390
movq -0x20(%rbp), %rdi
callq 0x6b90
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x62c0
cmpl $0x0, %eax
je 0x2ac0f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x5dc0
jmp 0x2ac35
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x204b0
callq 0x54b0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x2b5c0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0xc(%rbp), %rdx
callq 0x66e0
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x2ad47
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6be0
jmp 0x2ad5e
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x20470
movq -0x8(%rbp), %rdi
callq 0x6b60
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x62c0
cmpl $0x0, %eax
je 0x2ad9f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x5dc0
jmp 0x2adc5
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x204b0
callq 0x5440
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x2b5c0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x62c0
cmpl $0x0, %eax
je 0x2ae98
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x62c0
cmpl $0x0, %eax
je 0x2ae98
movq -0x8(%rbp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x66e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
cmpq $0x1, %rax
ja 0x2ae6a
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
jne 0x2ae58
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0xa733(%rip), %rdx      # 0x3557d
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6be0
jmp 0x2ae96
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x66e0
movq -0x20(%rbp), %rdi
cqto
idivq -0x10(%rbp)
movq %rdx, %rsi
callq 0x6be0
jmp 0x2aed7
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x204b0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x204b0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
callq 0x51d0
movq -0x28(%rbp), %rdi
callq 0x6b90
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x20550
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x20550
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %esi
callq 0x6fc0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x204b0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x61f0
cmpl $0x0, %eax
jg 0x2af96
movsd -0x10(%rbp), %xmm0
callq 0x51c0
movsd %xmm0, -0x18(%rbp)
jmp 0x2b023
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x204b0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0xb80a(%rip), %xmm1     # 0x367c0
ucomisd %xmm1, %xmm0
jne 0x2afcf
jp 0x2afcf
movsd -0x10(%rbp), %xmm0
callq 0x5050
movsd %xmm0, -0x18(%rbp)
jmp 0x2b021
movsd -0x20(%rbp), %xmm0
movsd 0xb7ec(%rip), %xmm1     # 0x367c8
ucomisd %xmm1, %xmm0
jne 0x2aff5
jp 0x2aff5
movsd -0x10(%rbp), %xmm0
callq 0x5290
movsd %xmm0, -0x18(%rbp)
jmp 0x2b01f
movsd -0x10(%rbp), %xmm0
callq 0x51c0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x51c0
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x2b021
jmp 0x2b023
movq -0x8(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x6b90
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d90
movl %eax, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movb $0x1, %al
cmpl $0x1, -0xc(%rbp)
movb %al, -0x15(%rbp)
jge 0x2b088
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xa664(%rip), %rdx      # 0x356de
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x2b0c6
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl $0x1, %ecx
callq 0x6530
cmpl $0x0, %eax
je 0x2b0b9
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x2b0bb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b092
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x6190
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d90
movl %eax, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movb $0x1, %al
cmpl $0x1, -0xc(%rbp)
movb %al, -0x15(%rbp)
jge 0x2b128
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0xa5c4(%rip), %rdx      # 0x356de
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x2b166
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
movl $0x1, %ecx
callq 0x6530
cmpl $0x0, %eax
je 0x2b159
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x2b15b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b132
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x6190
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x62c0
cmpl $0x0, %eax
je 0x2b1be
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x5dc0
movq -0x8(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x6b90
jmp 0x2b250
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x204b0
movsd %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x2b1ec
movsd -0x10(%rbp), %xmm0
callq 0x54b0
movsd %xmm0, -0x20(%rbp)
jmp 0x2b1fb
movsd -0x10(%rbp), %xmm0
callq 0x5440
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x2b5c0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jne 0x2b233
jp 0x2b233
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x2b242
movsd -0x10(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x6b90
movl $0x2, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x54f0
cvtsi2sd %eax, %xmm0
movsd 0xb50b(%rip), %xmm1     # 0x367d8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5d90
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
testl %eax, %eax
je 0x2b2fe
jmp 0x2b2ea
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x2b318
jmp 0x2b2f4
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x2b334
jmp 0x2b35a
movq -0x10(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x6b90
movl $0x1, -0x4(%rbp)
jmp 0x2b42a
movq $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x20550
movq %rax, -0x20(%rbp)
jmp 0x2b374
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x20550
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x20550
movq %rax, -0x20(%rbp)
jmp 0x2b374
movq -0x10(%rbp), %rdi
leaq 0xb50e(%rip), %rsi      # 0x36873
movb $0x0, %al
callq 0x1fbf0
movl %eax, -0x4(%rbp)
jmp 0x2b42a
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpq -0x20(%rbp), %rcx
movb %al, -0x2d(%rbp)
jle 0x2b3a1
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0xb4fa(%rip), %rdx      # 0x3688d
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x2e(%rbp)
jge 0x2b3ea
movq -0x20(%rbp), %rcx
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
addq -0x18(%rbp), %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x2e(%rbp)
jle 0x2b3ea
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0xb4c3(%rip), %rdx      # 0x3689f
callq 0x1fab0
cmpl $0x0, %eax
setne %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x9f3e(%rip), %xmm1     # 0x35340
addsd %xmm1, %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
cvttsd2si -0x28(%rbp), %rsi
addq -0x18(%rbp), %rsi
callq 0x6be0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x61f0
cmpl $0x3, %eax
jne 0x2b596
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x62c0
cmpl $0x0, %eax
je 0x2b584
movq -0x8(%rbp), %rdi
leaq 0xb49a(%rip), %rsi      # 0x36a17
callq 0x6ce0
jmp 0x2b594
movq -0x8(%rbp), %rdi
leaq 0xb323(%rip), %rsi      # 0x368b2
callq 0x6ce0
jmp 0x2b5ad
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x20470
movq -0x8(%rbp), %rdi
callq 0x6b60
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/lua/lmathlib.c
// Function: pushnumint
static void pushnumint (lua_State *L, lua_Number d) {
  lua_Integer n;
  if (lua_numbertointeger(d, &n))  /* does 'd' fit in an integer? */
    lua_pushinteger(L, n);  /* result is integer */
  else
    lua_pushnumber(L, d);  /* result is float */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x9aea(%rip), %xmm1     # 0x350c8
ucomisd %xmm1, %xmm0
jb 0x2b614
movsd 0x9aec(%rip), %xmm0     # 0x350d8
ucomisd -0x10(%rbp), %xmm0
jbe 0x2b614
cvttsd2si -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x2b605
jmp 0x2b614
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6be0
jmp 0x2b622
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x6b90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2bda0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x2bda0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5180
movq -0x20(%rbp), %rdi
callq 0x6b90
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x20310
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5160
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2b989
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1ff10
movl %eax, -0x4(%rbp)
jmp 0x2b99c
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6fc0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)