LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: remarkupvals
static void remarkupvals (global_State *g) {
  UpVal *uv;
  for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {
    if (isgray(obj2gco(uv)))
      markvalue(g, uv->v);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0xd0(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq $0xb0, %rcx
cmpq %rcx, %rax
je 0x15837
movq 0x8(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $0x7, %eax
cmpl $0x0, %eax
jne 0x15825
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x15823
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x15823
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x12b10
jmp 0x15825
jmp 0x15827
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x157ba
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: retraversegrays
static void retraversegrays (global_State *g) {
  GCObject *weak = g->weak;  /* save original lists */
  GCObject *grayagain = g->grayagain;
  GCObject *ephemeron = g->ephemeron;
  g->weak = g->grayagain = g->ephemeron = NULL;
  propagateall(g);  /* traverse main gray list */
  propagatelist(g, grayagain);
  propagatelist(g, weak);
  propagatelist(g, ephemeron);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x88(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq $0x0, 0x98(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x88(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x90(%rax)
movq 0x20(%rsp), %rdi
callq 0x15840
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x15bc0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x15bc0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x15bc0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lgc.c
// Function: udata2finalize
static GCObject *udata2finalize (global_State *g) {
  GCObject *o = g->tobefnz;  /* get first element */
  lua_assert(isfinalized(o));
  g->tobefnz = gch(o)->next;  /* remove it from 'tobefnz' list */
  gch(o)->next = g->allgc;  /* return it to 'allgc' list */
  g->allgc = o;
  resetbit(gch(o)->marked, SEPARATED);  /* mark that it is not in 'tobefnz' */
  lua_assert(!isold(o));  /* see MOVE OLD rule */
  if (!keepinvariantout(g))  /* not keeping invariant? */
    makewhite(g, o);  /* "sweep" object */
  return o;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0xa8(%rax)
movq -0x8(%rsp), %rax
movq 0x60(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rsp), %rax
movzbl 0x9(%rax), %ecx
andl $0xef, %ecx
movb %cl, 0x9(%rax)
movq -0x8(%rsp), %rax
movzbl 0x55(%rax), %eax
cmpl $0x1, %eax
jle 0x15c80
movq -0x10(%rsp), %rax
movzbl 0x9(%rax), %eax
andl $-0x48, %eax
movq -0x8(%rsp), %rcx
movzbl 0x54(%rcx), %ecx
andl $0x3, %ecx
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x9(%rax)
movq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/linit.c
// Function: luaL_openlibs
LUALIB_API void luaL_openlibs (lua_State *L) {
  const luaL_Reg *lib;
  /* call open functions from 'loadedlibs' and set results to global table */
  for (lib = loadedlibs; lib->func; lib++) {
    luaL_requiref(L, lib->name, lib->func, 1);
    lua_pop(L, 1);  /* remove lib */
  }
  /* add open functions from 'preloadedlibs' into 'package.preload' table */
  luaL_getsubtable(L, LUA_REGISTRYINDEX, "_PRELOAD");
  for (lib = preloadedlibs; lib->func; lib++) {
    lua_pushcfunction(L, lib->func);
    lua_setfield(L, -2, lib->name);
  }
  lua_pop(L, 1);  /* remove _PRELOAD table */
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x2a240(%rip), %rax     # 0x3ff10
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x15d20
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movl $0x1, %ecx
callq 0xe010
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
jmp 0x15cd5
movq 0x10(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x1ff68(%rip), %rdx     # 0x35c99
callq 0xdf60
leaq 0x1ff83(%rip), %rax     # 0x35cc0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x15d8a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
callq 0xa1e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xaad0
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
jmp 0x15d42
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: io_popen
static int io_popen (lua_State *L) {
  const char *filename = luaL_checkstring(L, 1);
  const char *mode = luaL_optstring(L, 2, "r");
  LStream *p = newprefile(L);
  p->f = lua_popen(L, filename, mode);
  p->closef = &io_pclose;
  return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xcd00
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
leaq 0x202f9(%rip), %rdx     # 0x3656b
xorl %eax, %eax
movl %eax, %ecx
callq 0xcc70
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x16700
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x73b0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x7490
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
leaq 0xd12(%rip), %rcx       # 0x16fd0
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x162e4
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
xorl %esi, %esi
callq 0xc760
movl %eax, 0x4(%rsp)
jmp 0x162ef
movl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x162ef
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: aux_close
static int aux_close (lua_State *L) {
  LStream *p = tolstream(L);
  lua_CFunction cf = p->closef;
  p->closef = NULL;  /* mark stream as closed */
  return (*cf)(L);  /* close it */
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x1f8dd(%rip), %rdx     # 0x35db7
callq 0xcaa0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq 0x10(%rsp), %rdi
callq *%rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/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 + strlen(IO_PREFIX));
  return p->f;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0xa530
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9c60
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1656c
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
addq $0x4, %rdx
leaq 0x1f875(%rip), %rsi     # 0x35dda
movb $0x0, %al
callq 0xc520
movq (%rsp), %rax
movq (%rax), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/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 " LUA_QS " (%s)", fname, strerror(errno));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x166c0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x7330
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x166b2
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x7070
movl (%rax), %edi
callq 0x7550
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x1f74a(%rip), %rsi     # 0x35df5
movb $0x0, %al
callq 0xc520
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: aux_lines
static void aux_lines (lua_State *L, int toclose) {
  int i;
  int n = lua_gettop(L) - 1;  /* number of arguments to read */
  /* ensure that arguments will fit here and into 'io_readline' stack */
  luaL_argcheck(L, n <= LUA_MINSTACK - 3, LUA_MINSTACK - 3, "too many options");
  lua_pushvalue(L, 1);  /* file handle */
  lua_pushinteger(L, n);  /* number of arguments to read */
  lua_pushboolean(L, toclose);  /* close/not close file when finished */
  for (i = 1; i <= n; i++) lua_pushvalue(L, i + 1);  /* copy arguments */
  lua_pushcclosure(L, io_readline, 3 + n);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8e20
subl $0x1, %eax
movl %eax, 0x4(%rsp)
movb $0x1, %al
cmpl $0x11, 0x4(%rsp)
movb %al, 0x3(%rsp)
jle 0x167fb
movq 0x10(%rsp), %rdi
movl $0x11, %esi
leaq 0x1f624(%rip), %rdx     # 0x35e10
callq 0xc3a0
cmpl $0x0, %eax
setne %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x92e0
movq 0x10(%rsp), %rdi
movslq 0x4(%rsp), %rsi
callq 0x9e70
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xa330
movl $0x1, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x4(%rsp), %eax
jg 0x1685b
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
addl $0x1, %esi
callq 0x92e0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x16833
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %edx
addl $0x3, %edx
leaq 0x12(%rip), %rsi        # 0x16880
callq 0xa1e0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/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);
  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_isnil(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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x9c60
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0xfff0b9d6, %esi       # imm = 0xFFF0B9D6
xorl %eax, %eax
movl %eax, %edx
callq 0x98a0
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x168dc
movq 0x18(%rsp), %rdi
leaq 0x1f555(%rip), %rsi     # 0x35e21
movb $0x0, %al
callq 0xc520
movl %eax, 0x24(%rsp)
jmp 0x169e2
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x8e50
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jg 0x16922
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x3, %eax
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
subl %eax, %esi
callq 0x92e0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x168f3
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl $0x2, %edx
callq 0x169f0
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
subl 0x8(%rsp), %esi
callq 0x9350
cmpl $0x0, %eax
je 0x1695f
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x169e2
cmpl $0x1, 0x8(%rsp)
jle 0x169a1
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
subl 0x8(%rsp), %esi
addl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x9a80
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x1f85d(%rip), %rsi     # 0x361f1
movb $0x0, %al
callq 0xc520
movl %eax, 0x24(%rsp)
jmp 0x169e2
movq 0x18(%rsp), %rdi
movl $0xfff0b9d5, %esi       # imm = 0xFFF0B9D5
callq 0x9a10
cmpl $0x0, %eax
je 0x169da
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x8e50
movq 0x18(%rsp), %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x92e0
movq 0x18(%rsp), %rdi
callq 0x164c0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: read_line
static int read_line (lua_State *L, FILE *f, int chop) {
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  for (;;) {
    size_t l;
    char *p = luaL_prepbuffer(&b);
    if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) {  /* eof? */
      luaL_pushresult(&b);  /* close buffer */
      return (lua_rawlen(L, -1) > 0);  /* check whether read something */
    }
    l = strlen(p);
    if (l == 0 || p[l-1] != '\n')
      luaL_addsize(&b, l);
    else {
      luaL_addsize(&b, l - chop);  /* chop 'eol' if needed */
      luaL_pushresult(&b);  /* close buffer */
      return 1;  /* read at least an `eol' */
    }
  }
}

// Assembly:
subq $0x2058, %rsp           # imm = 0x2058
movq %rdi, 0x2048(%rsp)
movq %rsi, 0x2040(%rsp)
movl %edx, 0x203c(%rsp)
movq 0x2048(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd390
leaq 0x18(%rsp), %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0xd080
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x2040(%rsp), %rdx
movl $0x2000, %esi           # imm = 0x2000
callq 0x72a0
cmpq $0x0, %rax
jne 0x16d12
leaq 0x18(%rsp), %rdi
callq 0xd260
movq 0x2048(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9b50
cmpq $0x0, %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x2054(%rsp)
jmp 0x16d87
movq 0x8(%rsp), %rdi
callq 0x7170
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x16d40
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x16d51
movq 0x10(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x16d82
movq 0x10(%rsp), %rax
movslq 0x203c(%rsp), %rcx
subq %rcx, %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xd260
movl $0x1, 0x2054(%rsp)
jmp 0x16d87
jmp 0x16cb0
movl 0x2054(%rsp), %eax
addq $0x2058, %rsp           # imm = 0x2058
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: test_eof
static int test_eof (lua_State *L, FILE *f) {
  int c = getc(f);
  ungetc(c, f);
  lua_pushlstring(L, NULL, 0);
  return (c != EOF);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x7580
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x73d0
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x9f40
cmpl $-0x1, 0x4(%rsp)
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: read_number
static int read_number (lua_State *L, FILE *f) {
  lua_Number d;
  if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {
    lua_pushnumber(L, d);
    return 1;
  }
  else {
   lua_pushnil(L);  /* "result" to be removed */
   return 0;  /* read fails */
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x1efaf(%rip), %rsi     # 0x35e69
leaq 0x8(%rsp), %rdx
movb $0x0, %al
callq 0x70c0
cmpl $0x1, %eax
jne 0x16ee5
movq 0x18(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x9e20
movl $0x1, 0x24(%rsp)
jmp 0x16ef7
movq 0x18(%rsp), %rdi
callq 0x9df0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/liolib.c
// Function: read_all
static void read_all (lua_State *L, FILE *f) {
  size_t rlen = LUAL_BUFFERSIZE;  /* how much to read in each cycle */
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  for (;;) {
    char *p = luaL_prepbuffsize(&b, rlen);
    size_t nr = fread(p, sizeof(char), rlen, f);
    luaL_addsize(&b, nr);
    if (nr < rlen) break;  /* eof? */
    else if (rlen <= (MAX_SIZE_T / 4))  /* avoid buffers too large */
      rlen *= 2;  /* double buffer size at each iteration */
  }
  luaL_pushresult(&b);  /* close buffer */
}

// Assembly:
subq $0x2048, %rsp           # imm = 0x2048
movq %rdi, 0x2040(%rsp)
movq %rsi, 0x2038(%rsp)
movq $0x2000, 0x2030(%rsp) # imm = 0x2000
movq 0x2040(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd390
movq 0x2030(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0xd080
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x2030(%rsp), %rdx
movq 0x2038(%rsp), %rcx
movl $0x1, %esi
callq 0x7100
movq %rax, (%rsp)
movq (%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rax
cmpq 0x2030(%rsp), %rax
jae 0x16f8d
jmp 0x16fbb
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rax, 0x2030(%rsp)
ja 0x16fb4
movq 0x2030(%rsp), %rax
shlq %rax
movq %rax, 0x2030(%rsp)
jmp 0x16fb6
jmp 0x16f35
leaq 0x10(%rsp), %rdi
callq 0xd260
addq $0x2048, %rsp           # imm = 0x2048
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/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 */
      status = status &&
          fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movq 0x48(%rsp), %rdi
callq 0x8e20
subl 0x3c(%rsp), %eax
movl %eax, 0x38(%rsp)
movl $0x1, 0x34(%rsp)
movl 0x38(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x38(%rsp)
cmpl $0x0, %eax
je 0x17133
movq 0x48(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x9350
cmpl $0x3, %eax
jne 0x170ca
xorl %eax, %eax
cmpl $0x0, 0x34(%rsp)
movb %al, 0x1f(%rsp)
je 0x170bb
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movl 0x3c(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x9810
movq 0x10(%rsp), %rdi
leaq 0x1edd4(%rip), %rsi     # 0x35e7e
movb $0x1, %al
callq 0x7310
cmpl $0x0, %eax
setg %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
jmp 0x17121
movq 0x48(%rsp), %rdi
movl 0x3c(%rsp), %esi
leaq 0x28(%rsp), %rdx
callq 0xcd00
movq %rax, 0x20(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x34(%rsp)
movb %al, 0xf(%rsp)
je 0x17114
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x40(%rsp), %rcx
movl $0x1, %esi
callq 0x7530
cmpq 0x28(%rsp), %rax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
jmp 0x17123
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x1704c
cmpl $0x0, 0x34(%rsp)
je 0x17144
movl $0x1, 0x54(%rsp)
jmp 0x1715a
movq 0x48(%rsp), %rdi
movl 0x34(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xc760
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/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_Number p3 = luaL_optnumber(L, 3, 0);
  l_seeknum offset = (l_seeknum)p3;
  luaL_argcheck(L, (lua_Number)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_pushnumber(L, (lua_Number)l_ftell(f));
    return 1;
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x16470
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0x1ec55(%rip), %rdx     # 0x35e9e
leaq 0x28ed0(%rip), %rcx     # 0x40120
callq 0xcb70
movl %eax, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
xorps %xmm0, %xmm0
callq 0xcee0
movsd %xmm0, 0x20(%rsp)
cvttsd2si 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cvtsi2sdq 0x18(%rsp), %xmm0
movb $0x1, %al
ucomisd 0x20(%rsp), %xmm0
movb %al, 0x17(%rsp)
jne 0x17296
jp 0x17296
jmp 0x172b6
movq 0x38(%rsp), %rdi
movl $0x3, %esi
leaq 0x1ebff(%rip), %rdx     # 0x35ea6
callq 0xc3a0
cmpl $0x0, %eax
setne %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movslq 0x2c(%rsp), %rcx
leaq 0x1ea8c(%rip), %rax     # 0x35d5c
movl (%rax,%rcx,4), %edx
callq 0x7430
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x172f9
movq 0x38(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xc760
movl %eax, 0x44(%rsp)
jmp 0x17324
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7260
movq 0x8(%rsp), %rdi
cvtsi2sd %rax, %xmm0
callq 0x9e20
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/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, HUGE_VAL);
  lua_setfield(L, -2, "huge");
  return 1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x1b, %edx
callq 0xa780
movq (%rsp), %rdi
leaq 0x28c10(%rip), %rsi     # 0x40160
xorl %edx, %edx
callq 0xdd90
movq (%rsp), %rdi
movsd 0x1e9a5(%rip), %xmm0    # 0x35f08
callq 0x9e20
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1e9c8(%rip), %rdx     # 0x35f40
callq 0xaad0
movq (%rsp), %rdi
movsd 0x1e977(%rip), %xmm0    # 0x35f00
callq 0x9e20
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x1e9a5(%rip), %rdx     # 0x35f43
callq 0xaad0
movl $0x1, %eax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_frexp
static int math_frexp (lua_State *L) {
  int e;
  lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e));
  lua_pushinteger(L, e);
  return 2;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xce90
leaq 0xc(%rsp), %rdi
callq 0x72b0
movq (%rsp), %rdi
callq 0x9e20
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x9e70
movl $0x2, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_ldexp
static int math_ldexp (lua_State *L) {
  lua_Number x = luaL_checknumber(L, 1);
  int ep = luaL_checkint(L, 2);
  lua_pushnumber(L, l_mathop(ldexp)(x, ep));
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xce90
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0xcf40
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
movl 0x14(%rsp), %edi
callq 0x7080
movq 0x8(%rsp), %rdi
callq 0x9e20
movl $0x1, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/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 (base == (lua_Number)10.0) res = l_mathop(log10)(x);
    else res = l_mathop(log)(x)/l_mathop(log)(base);
  }
  lua_pushnumber(L, res);
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xce90
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x9350
cmpl $0x0, %eax
jg 0x17a05
movsd 0x18(%rsp), %xmm0
callq 0x7210
movsd %xmm0, 0x10(%rsp)
jmp 0x17a72
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0xce90
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd 0x1e4f0(%rip), %xmm1    # 0x35f18
ucomisd %xmm1, %xmm0
jne 0x17a43
jp 0x17a43
movsd 0x18(%rsp), %xmm0
callq 0x7300
movsd %xmm0, 0x10(%rsp)
jmp 0x17a70
movsd 0x18(%rsp), %xmm0
callq 0x7210
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x7210
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x17a72
movq 0x20(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x9e20
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_max
static int math_max (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  lua_Number dmax = luaL_checknumber(L, 1);
  int i;
  for (i=2; i<=n; i++) {
    lua_Number d = luaL_checknumber(L, i);
    if (d > dmax)
      dmax = d;
  }
  lua_pushnumber(L, dmax);
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x8e20
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xce90
movsd %xmm0, 0x10(%rsp)
movl $0x2, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jg 0x17b08
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xce90
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0x17af9
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x17afb
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x17ac4
movq 0x20(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x9e20
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_min
static int math_min (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  lua_Number dmin = luaL_checknumber(L, 1);
  int i;
  for (i=2; i<=n; i++) {
    lua_Number d = luaL_checknumber(L, i);
    if (d < dmin)
      dmin = d;
  }
  lua_pushnumber(L, dmin);
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x8e20
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xce90
movsd %xmm0, 0x10(%rsp)
movl $0x2, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jg 0x17bac
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xce90
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x17b9d
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x17b9f
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x17b64
movq 0x20(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x9e20
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_modf
static int math_modf (lua_State *L) {
  lua_Number ip;
  lua_Number fp = l_mathop(modf)(luaL_checknumber(L, 1), &ip);
  lua_pushnumber(L, ip);
  lua_pushnumber(L, fp);
  return 2;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xce90
leaq 0x8(%rsp), %rdi
callq 0x71c0
movsd %xmm0, (%rsp)
movq 0x10(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x9e20
movq 0x10(%rsp), %rdi
movsd (%rsp), %xmm0
callq 0x9e20
movl $0x2, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmathlib.c
// Function: math_pow
static int math_pow (lua_State *L) {
  lua_Number x = luaL_checknumber(L, 1);
  lua_Number y = luaL_checknumber(L, 2);
  lua_pushnumber(L, l_mathop(pow)(x, y));
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xce90
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0xce90
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x7140
movq 0x8(%rsp), %rdi
callq 0x9e20
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lmem.c
// Function: luaM_realloc_
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
  void *newblock;
  global_State *g = G(L);
  size_t realosize = (block) ? osize : 0;
  lua_assert((realosize == 0) == (block == NULL));
#if defined(HARDMEMTESTS)
  if (nsize > realosize && g->gcrunning)
    luaC_fullgc(L, 1);  /* force a GC whenever possible */
#endif
  newblock = (*g->frealloc)(g->ud, block, osize, nsize);
  if (newblock == NULL && nsize > 0) {
    api_check(L, nsize > realosize,
                 "realloc cannot fail when shrinking a block");
    if (g->gcrunning) {
      luaC_fullgc(L, 1);  /* try to free some memory... */
      newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
    }
    if (newblock == NULL)
      luaD_throw(L, LUA_ERRMEM);
  }
  lua_assert((nsize == 0) == (newblock == NULL));
  g->GCdebt = (g->GCdebt + nsize) - realosize;
  return newblock;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x181aa
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x181b3
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x181b3
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq *%rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1824e
cmpq $0x0, 0x28(%rsp)
jbe 0x1824e
movq 0x18(%rsp), %rax
cmpb $0x0, 0x57(%rax)
je 0x18235
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x13fe0
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq *%rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1824c
movq 0x40(%rsp), %rdi
movl $0x4, %esi
callq 0xfe30
jmp 0x1824e
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
addq 0x28(%rsp), %rcx
subq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: gctm
static int gctm (lua_State *L) {
  int n = luaL_len(L, 1);
  for (; n >= 1; n--) {  /* for each handle, in reverse order */
    lua_rawgeti(L, 1, n);  /* get handle CLIBS[n] */
    ll_unloadlib(lua_touserdata(L, -1));
    lua_pop(L, 1);  /* pop handle */
  }
  return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xdbe0
movl %eax, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
jl 0x184a9
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0x1, %esi
callq 0xa660
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9c60
movq %rax, %rdi
callq 0x18610
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1845c
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: createsearcherstable
static void createsearcherstable (lua_State *L) {
  static const lua_CFunction searchers[] =
    {searcher_preload, searcher_Lua, searcher_C, searcher_Croot, NULL};
  int i;
  /* create 'searchers' table */
  lua_createtable(L, sizeof(searchers)/sizeof(searchers[0]) - 1, 0);
  /* fill it with pre-defined searchers */
  for (i=0; searchers[i] != NULL; i++) {
    lua_pushvalue(L, -2);  /* set 'package' as upvalue for all searchers */
    lua_pushcclosure(L, searchers[i], 1);
    lua_rawseti(L, -2, i+1);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0xa780
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rcx
leaq 0x27e92(%rip), %rax     # 0x40370
cmpq $0x0, (%rax,%rcx,8)
je 0x18536
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x92e0
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rcx
leaq 0x27e6b(%rip), %rax     # 0x40370
movq (%rax,%rcx,8), %rsi
movl $0x1, %edx
callq 0xa1e0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
addl $0x1, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xac80
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x184d2
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: ll_loadfunc
static int ll_loadfunc (lua_State *L, const char *path, const char *sym) {
  void *reg = ll_checkclib(L, path);  /* check loaded C libraries */
  if (reg == NULL) {  /* must load library? */
    reg = ll_load(L, path, *sym == '*');
    if (reg == NULL) return ERRLIB;  /* unable to load library */
    ll_addtoclib(L, path, reg);
  }
  if (*sym == '*') {  /* loading only library (no function)? */
    lua_pushboolean(L, 1);  /* return 'true' */
    return 0;  /* no errors */
  }
  else {
    lua_CFunction f = ll_sym(L, reg, sym);
    if (f == NULL)
      return ERRFUNC;  /* unable to find function */
    lua_pushcfunction(L, f);  /* else create new function */
    return 0;  /* no errors */
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x188a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1882c
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
sete %al
andb $0x1, %al
movzbl %al, %edx
callq 0x18910
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x18818
movl $0x1, 0x34(%rsp)
jmp 0x18896
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x18980
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x18852
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0xa330
movl $0x0, 0x34(%rsp)
jmp 0x18896
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x18a20
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1887d
movl $0x2, 0x34(%rsp)
jmp 0x18896
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xa1e0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: ll_checkclib
static void *ll_checkclib (lua_State *L, const char *path) {
  void *plib;
  lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);
  lua_getfield(L, -1, path);
  plib = lua_touserdata(L, -1);  /* plib = CLIBS[path] */
  lua_pop(L, 2);  /* pop CLIBS table and 'plib' */
  return plib;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x1d76a(%rip), %rdx     # 0x36029
callq 0xa530
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xa530
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9c60
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x8e50
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: ll_addtoclib
static void ll_addtoclib (lua_State *L, const char *path, void *plib) {
  lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);
  lua_pushlightuserdata(L, plib);
  lua_pushvalue(L, -1);
  lua_setfield(L, -3, path);  /* CLIBS[path] = plib */
  lua_rawseti(L, -2, luaL_len(L, -2) + 1);  /* CLIBS[#CLIBS + 1] = plib */
  lua_pop(L, 1);  /* pop CLIBS table */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x1d685(%rip), %rdx     # 0x36029
callq 0xa530
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa380
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x92e0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0xaad0
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xdbe0
movq 0x8(%rsp), %rdi
movl %eax, %edx
addl $0x1, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xac80
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: searcher_preload
static int searcher_preload (lua_State *L) {
  const char *name = luaL_checkstring(L, 1);
  lua_getfield(L, LUA_REGISTRYINDEX, "_PRELOAD");
  lua_getfield(L, -1, name);
  if (lua_isnil(L, -1))  /* not found? */
    lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xcd00
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x1cf57(%rip), %rdx     # 0x35c99
callq 0xa530
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xa530
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9350
cmpl $0x0, %eax
jne 0x18d87
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x1d407(%rip), %rsi     # 0x36187
movb $0x0, %al
callq 0xa0f0
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: findfile
static const char *findfile (lua_State *L, const char *name,
                                           const char *pname,
                                           const char *dirsep) {
  const char *path;
  lua_getfield(L, lua_upvalueindex(1), pname);
  path = lua_tostring(L, -1);
  if (path == NULL)
    luaL_error(L, LUA_QL("package.%s") " must be a string", pname);
  return searchpath(L, name, path, ".", dirsep);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0xa530
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x9a80
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x19082
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x1d12d(%rip), %rsi     # 0x361a8
movb $0x0, %al
callq 0xc520
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %r8
leaq 0x1c3f1(%rip), %rcx     # 0x3548d
callq 0x18a80
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: checkload
static int checkload (lua_State *L, int stat, const char *filename) {
  if (stat) {  /* module loaded successfully? */
    lua_pushstring(L, filename);  /* will be 2nd argument to module */
    return 2;  /* return open function and file name */
  }
  else
    return luaL_error(L, "error loading module " LUA_QS
                         " from file " LUA_QS ":\n\t%s",
                          lua_tostring(L, 1), filename, lua_tostring(L, -1));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x190e2
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x9fe0
movl $0x2, 0x34(%rsp)
jmp 0x19143
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x9a80
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x9a80
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rax, %r8
leaq 0x1d08e(%rip), %rsi     # 0x361c6
movb $0x0, %al
callq 0xc520
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: loadfunc
static int loadfunc (lua_State *L, const char *filename, const char *modname) {
  const char *funcname;
  const char *mark;
  modname = luaL_gsub(L, modname, ".", LUA_OFSEP);
  mark = strchr(modname, *LUA_IGMARK);
  if (mark) {
    int stat;
    funcname = lua_pushlstring(L, modname, mark - modname);
    funcname = lua_pushfstring(L, LUA_POF"%s", funcname);
    stat = ll_loadfunc(L, filename, funcname);
    if (stat != ERRFUNC) return stat;
    modname = mark + 1;  /* else go ahead and try old-style name */
  }
  funcname = lua_pushfstring(L, LUA_POF"%s", modname);
  return ll_loadfunc(L, filename, funcname);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x1c319(%rip), %rdx     # 0x3548d
leaq 0x1d079(%rip), %rcx     # 0x361f4
callq 0xe0e0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movsbl 0x1d9af(%rip), %esi     # 0x36b40
callq 0x7190
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x19218
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
subq %rax, %rdx
callq 0x9f40
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x1d021(%rip), %rsi     # 0x361f6
movb $0x0, %al
callq 0xa0f0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x187b0
movl %eax, 0x4(%rsp)
cmpl $0x2, 0x4(%rsp)
je 0x1920a
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x1924d
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x1cfcd(%rip), %rsi     # 0x361f6
movb $0x0, %al
callq 0xa0f0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x187b0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/loadlib.c
// Function: findloader
static void findloader (lua_State *L, const char *name) {
  int i;
  luaL_Buffer msg;  /* to build error message */
  luaL_buffinit(L, &msg);
  lua_getfield(L, lua_upvalueindex(1), "searchers");  /* will be at index 3 */
  if (!lua_istable(L, 3))
    luaL_error(L, LUA_QL("package.searchers") " must be a table");
  /*  iterate over available searchers to find a loader */
  for (i = 1; ; i++) {
    lua_rawgeti(L, 3, i);  /* get a searcher */
    if (lua_isnil(L, -1)) {  /* no more searchers? */
      lua_pop(L, 1);  /* remove nil */
      luaL_pushresult(&msg);  /* create error message */
      luaL_error(L, "module " LUA_QS " not found:%s",
                    name, lua_tostring(L, -1));
    }
    lua_pushstring(L, name);
    lua_call(L, 1, 2);  /* call it */
    if (lua_isfunction(L, -2))  /* did it find a loader? */
      return;  /* module loader found */
    else if (lua_isstring(L, -2)) {  /* searcher returned error message? */
      lua_pop(L, 1);  /* remove extra return */
      luaL_addvalue(&msg);  /* concatenate error message */
    }
    else
      lua_pop(L, 2);  /* remove both returns */
  }
}

// Assembly:
subq $0x2048, %rsp           # imm = 0x2048
movq %rdi, 0x2040(%rsp)
movq %rsi, 0x2038(%rsp)
movq 0x2040(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd390
movq 0x2040(%rsp), %rdi
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
leaq 0x1cbe3(%rip), %rdx     # 0x36030
callq 0xa530
movq 0x2040(%rsp), %rdi
movl $0x3, %esi
callq 0x9350
cmpl $0x5, %eax
je 0x1947f
movq 0x2040(%rsp), %rdi
leaq 0x1cdb0(%rip), %rsi     # 0x36228
movb $0x0, %al
callq 0xc520
movl $0x1, 0x2034(%rsp)
movq 0x2040(%rsp), %rdi
movl 0x2034(%rsp), %edx
movl $0x3, %esi
callq 0xa660
movq 0x2040(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9350
cmpl $0x0, %eax
jne 0x1951f
movq 0x2040(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
leaq 0x10(%rsp), %rdi
callq 0xd260
movq 0x2040(%rsp), %rax
movq %rax, (%rsp)
movq 0x2038(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x2040(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x9a80
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x1cd34(%rip), %rsi     # 0x3624c
movb $0x0, %al
callq 0xc520
movq 0x2040(%rsp), %rdi
movq 0x2038(%rsp), %rsi
callq 0x9fe0
movq 0x2040(%rsp), %rdi
movl $0x1, %esi
movl $0x2, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xb0e0
movq 0x2040(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x9350
cmpl $0x6, %eax
jne 0x19571
addq $0x2048, %rsp           # imm = 0x2048
retq
movq 0x2040(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x9480
cmpl $0x0, %eax
je 0x195a6
movq 0x2040(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x8e50
leaq 0x10(%rsp), %rdi
callq 0xd2f0
jmp 0x195b8
movq 0x2040(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x8e50
jmp 0x195ba
jmp 0x195bc
movl 0x2034(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2034(%rsp)
jmp 0x1948a
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/lua/../opensource/lua-5.2.3/src/lobject.c
// Function: luaO_int2fb
int luaO_int2fb (unsigned int x) {
  int e = 0;  /* exponent */
  if (x < 8) return x;
  while (x >= 0x10) {
    x = (x+1) >> 1;
    e++;
  }
  return ((e+1) << 3) | (cast_int(x) - 8);
}

// Assembly:
movl %edi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x8, -0x8(%rsp)
jae 0x195fd
movl -0x8(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x19637
jmp 0x195ff
cmpl $0x10, -0x8(%rsp)
jb 0x19620
movl -0x8(%rsp), %eax
addl $0x1, %eax
shrl %eax
movl %eax, -0x8(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x195ff
movl -0xc(%rsp), %eax
addl $0x1, %eax
shll $0x3, %eax
movl -0x8(%rsp), %ecx
subl $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)