LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio_getAction
static int
xpio_getAction(lua_State *L,
               int ndxActions,
               int indx,
               int *fdFrom,
               int *fdTo)
{
   lua_rawgeti(L, ndxActions, indx);
   if (!lua_istable(L, -1)) {
      lua_pop(L, 1);
      return 0;
   }

   lua_rawgeti(L, -1, 1);   // to
   lua_rawgeti(L, -2, 2);   // from
   *fdTo = tointegerDefault(L, -2, -1);
   *fdFrom = tointegerDefault(L, -1, -1);
   lua_pop(L, 3);

   return (*fdTo != -1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x8cb0
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x79a0
cmpl $0x5, %eax
je 0x4dcc
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74a0
movl $0x0, 0x24(%rsp)
jmp 0x4e4c
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x8cb0
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x8cb0
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5120
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %edx, %esi
callq 0x5120
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rdi
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x74a0
movq (%rsp), %rax
cmpl $-0x1, (%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: readStringArray
static char **readStringArray(lua_State *L, int ndxArray)
{
   int numStrings = lengthOf(L, ndxArray);
   char **ptrs = (char**) calloc(numStrings + 1, sizeof(char*));
   if (!ptrs) {
      return NULL;
   }

   int offset = 0;
   for (offset = 0; offset < numStrings; ++offset) {
      lua_rawgeti(L, ndxArray, offset+1);
      size_t len;
      const char *pc = lua_tolstring(L, -1, &len);
      ptrs[offset] = pc ? strdup(pc) : NULL;
      lua_pop(L, 1);
      if (! ptrs[offset]) {
         break;
      }
   }

   return ptrs;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x5170
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x3250
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x4eae
movq $0x0, 0x40(%rsp)
jmp 0x4f6d
movl $0x0, 0x24(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x4f63
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movl 0x24(%rsp), %edx
addl $0x1, %edx
callq 0x8cb0
movq 0x38(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x18(%rsp), %rdx
callq 0x80d0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4f13
movq 0x10(%rsp), %rdi
callq 0x3410
movq %rax, 0x8(%rsp)
jmp 0x4f1c
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x4f1c
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x38(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74a0
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x4f51
jmp 0x4f63
jmp 0x4f53
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4ebe
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpproc_init
static void xpproc_init(void)
{
   static int initialized = 0;     // not MT-safe!
   struct sigaction sa;

   ZERO_REC(sa);
   if (!initialized) {
      initialized = 1;

      sa.sa_handler = handleSIGCHLD;
      sa.sa_flags = SA_RESTART;

      if (pipe(sigchldPipe)) {
         fprintf(stderr, "ERROR: pipe() failed: %d (%s)\n", errno, strerror(errno));
         return;
      }

      if (setNonBlocking(sigchldPipe[0], 1) == -1) {
         fprintf(stderr, "ERROR: failed to set pipe non-blocking\n");
         return;
      }

      if (sigaction(SIGCHLD, &sa, 0)) {
         fprintf(stderr, "ERROR: sigaction failed: %d (%s)\n", errno, strerror(errno));
         return;
      }
   }
}

// Assembly:
subq $0xb8, %rsp
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x31c0
cmpl $0x0, 0x2c2c1(%rip)     # 0x31260
jne 0x50a5
movl $0x1, 0x2c2b1(%rip)     # 0x31260
leaq 0xfa(%rip), %rax        # 0x50b0
movq %rax, 0x20(%rsp)
movl $0x10000000, 0xa8(%rsp) # imm = 0x10000000
leaq 0x2c27b(%rip), %rdi     # 0x31248
callq 0x31f0
cmpl $0x0, %eax
je 0x501c
movq 0x2c012(%rip), %rax     # 0x30ff0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x3060
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
callq 0x3060
movl (%rax), %edi
callq 0x3420
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %edx
movq %rax, %rcx
leaq 0x23122(%rip), %rsi     # 0x28132
movb $0x0, %al
callq 0x3280
jmp 0x50a5
movl 0x2c226(%rip), %edi     # 0x31248
movl $0x1, %esi
callq 0x4a20
cmpl $-0x1, %eax
jne 0x504b
movq 0x2bfb8(%rip), %rax     # 0x30ff0
movq (%rax), %rdi
leaq 0x2310f(%rip), %rsi     # 0x28151
movb $0x0, %al
callq 0x3280
jmp 0x50a5
movl $0x11, %edi
leaq 0x20(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3090
cmpl $0x0, %eax
je 0x50a3
movq 0x2bf86(%rip), %rax     # 0x30ff0
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x3060
movl (%rax), %eax
movl %eax, 0xc(%rsp)
callq 0x3060
movl (%rax), %edi
callq 0x3420
movq (%rsp), %rdi
movl 0xc(%rsp), %edx
movq %rax, %rcx
leaq 0x230df(%rip), %rsi     # 0x28179
movb $0x0, %al
callq 0x3280
jmp 0x50a5
jmp 0x50a5
addq $0xb8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: handleSIGCHLD
static void handleSIGCHLD(int sig)
{
   int n;
   int oldErrno = errno;
   //printf("SIGCHLD!\n");
   do {
      n = write(sigchldPipe[1], "\1", 1);
   } while (n == -1 && errno == EINTR);
   errno = oldErrno;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
callq 0x3060
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0x2c183(%rip), %edi     # 0x3124c
leaq 0x230cb(%rip), %rsi     # 0x2819b
movl $0x1, %edx
callq 0x30f0
movl %eax, 0x10(%rsp)
xorl %eax, %eax
cmpl $-0x1, 0x10(%rsp)
movb %al, 0xb(%rsp)
jne 0x50fa
callq 0x3060
cmpl $0x4, (%rax)
sete %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x50c3
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
callq 0x3060
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: lengthOf
static int lengthOf(lua_State *L, int ndx)
{
   int len;
   lua_len(L, ndx);
   len = lua_tointeger(L, -1);
   lua_pop(L, 1);
   return len;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x9f80
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x7ef0
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74a0
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpproc_dtor
static int xpproc_dtor(lua_State *L)
{
   XPProc *me = XLUA_CAST(L, 1, XPProc);

   // dequeue from global list
   SLL_DEQUEUE(me, gpHeadProc, XPProc, next);

   if (me->pid) {
      (void) kill(me->pid, SIGKILL);
      me->pid = 0;
   }
   return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x2b656(%rip), %rdx     # 0x30830
leaq 0x22e48(%rip), %rcx     # 0x28029
callq 0x5450
movq %rax, 0x8(%rsp)
leaq 0x2c066(%rip), %rax     # 0x31258
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x522e
movq (%rsp), %rax
movq (%rax), %rax
cmpq 0x8(%rsp), %rax
jne 0x521f
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
jmp 0x522e
jmp 0x5221
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x51f6
movq 0x8(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x5257
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edi
movl $0x9, %esi
callq 0x32d0
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
xorl %eax, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpproc_kill
static int xpproc_kill(lua_State *L)
{
   XPProc *me = XLUA_CAST(L, 1, XPProc);

   if (me->pid <= 0) {
      return pushError(L, "process not running");
   }

   if (kill(me->pid, SIGKILL) == -1) {
      return pushError(L, NULL);
   }

   lua_pushboolean(L, 1);  // success
   return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x2b5b6(%rip), %rdx     # 0x30830
leaq 0x22da8(%rip), %rcx     # 0x28029
callq 0x5450
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
jg 0x52ab
movq 0x8(%rsp), %rdi
leaq 0x22f54(%rip), %rsi     # 0x281f4
callq 0x49a0
movl %eax, 0x14(%rsp)
jmp 0x52ec
movq (%rsp), %rax
movl 0x8(%rax), %edi
movl $0x9, %esi
callq 0x32d0
cmpl $-0x1, %eax
jne 0x52d5
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x14(%rsp)
jmp 0x52ec
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x8980
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpproc_try_wait
static int xpproc_try_wait(lua_State *L)
{
   XPProc *me = XLUA_CAST(L, 1, XPProc);

   if (me->pid > 0) {
      lua_pushnil(L);
      lua_pushstring(L, "retry");
      //printf("... try_wait(%d) --> retry\n", me->pid);
      return 2;
   }

   //printf("... try_wait() --> %x\n", me->status);
   if (WIFEXITED(me->status)) {
      lua_pushstring(L, "exit");
      lua_pushinteger(L, WEXITSTATUS(me->status));
      return 2;
   } else if (WIFSIGNALED(me->status)) {
      lua_pushstring(L, "signal");
      lua_pushinteger(L, WSTOPSIG(me->status));
      return 2;
   } else {
      // exit status not ready
      return pushError(L, "retry");
   }

   // should not happen
   return pushError(L, "xpio: unexpected waitpid() result");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x2b516(%rip), %rdx     # 0x30830
leaq 0x22d08(%rip), %rcx     # 0x28029
callq 0x5450
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x535c
movq 0x8(%rsp), %rdi
callq 0x8440
movq 0x8(%rsp), %rdi
leaq 0x22ebe(%rip), %rsi     # 0x28208
callq 0x8630
movl $0x2, 0x14(%rsp)
jmp 0x5405
movq (%rsp), %rax
movl 0xc(%rax), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x53a2
movq 0x8(%rsp), %rdi
leaq 0x22e97(%rip), %rsi     # 0x2820e
callq 0x8630
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movl 0xc(%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movslq %eax, %rsi
callq 0x84c0
movl $0x2, 0x14(%rsp)
jmp 0x5405
movq (%rsp), %rax
movl 0xc(%rax), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x53f0
movq 0x8(%rsp), %rdi
leaq 0x22e4e(%rip), %rsi     # 0x28213
callq 0x8630
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movl 0xc(%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movslq %eax, %rsi
callq 0x84c0
movl $0x2, 0x14(%rsp)
jmp 0x5405
movq 0x8(%rsp), %rdi
leaq 0x22e0c(%rip), %rsi     # 0x28208
callq 0x49a0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xlua.h
// Function: xlua_checkudata
static inline void*
xlua_checkudata(lua_State *L,
              int narg,
              const luaL_Reg *regs,
              const char *typeName)
{
   // if REGISTRY[getmetatable(udata)] == regs then
   //    return touserdata(udata)
   // else
   //    error(...)
   // end

   void *me = lua_touserdata(L, narg);

   if (me != NULL && lua_getmetatable(L, narg)) {
      lua_rawget(L, LUA_REGISTRYINDEX);
      void *tptr = lua_touserdata(L, -1);
      lua_pop(L, 1);
      if ((const void *)tptr == (const void*) regs) {
         return me;
      }
   }

   const char *msg = lua_pushfstring(L, "%s object expected, got %s",
                                     typeName, luaL_typename(L, narg));
   (void) luaL_argerror(L, narg, msg);
   return NULL;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x82b0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x54e1
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x8e70
cmpl $0x0, %eax
je 0x54e1
movq 0x48(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x8c30
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x82b0
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74a0
movq 0x20(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0x54df
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x5553
jmp 0x54e1
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x79a0
movq (%rsp), %rdi
movl %eax, %esi
callq 0x7a00
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x22cae(%rip), %rsi     # 0x281d9
movb $0x0, %al
callq 0x8740
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0xa9f0
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpqueue_enqueue
static int xpqueue_enqueue(lua_State *L, int ndxTask, int ndxKey, int mode)
{
   ndxTask = lua_absindex(L, ndxTask);
   ndxKey = lua_absindex(L, ndxKey);

   // assert(not task._dequeue)
   lua_getfield(L, ndxTask, "_dequeue");
   if (!lua_isnil(L, -1)) {
      luaL_error(L, "xpio: task scheduled twice");
   }

   // readers/writers/childWaiters[key] = task

   xpqueue_tableFromTask(L, ndxTask, mode);
   lua_pushvalue(L, ndxKey);   // key
   lua_pushvalue(L, ndxTask);  // value
   lua_rawset(L, -3);

   // task.dequeue = xpqueue_dequeue[R/W/C]

   lua_pushcfunction(L, (mode == XPQUEUE_READ ? xpqueue_dequeueR :
                         mode == XPQUEUE_WRITE ? xpqueue_dequeueW :
                         xpqueue_dequeueC));
   lua_setfield(L, ndxTask, "_dequeue");

   // task._dequeuedata = key

   lua_pushvalue(L, ndxKey);
   lua_setfield(L, ndxTask, "_dequeuedata");

   // leave 4 items on the stack
   return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x7410
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x7410
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
leaq 0x22c71(%rip), %rdx     # 0x2821a
callq 0x8b80
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x79a0
cmpl $0x0, %eax
je 0x55d5
movq 0x20(%rsp), %rdi
leaq 0x22c55(%rip), %rsi     # 0x28223
movb $0x0, %al
callq 0xab70
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x56a0
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x7930
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x7930
movq 0x20(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x91e0
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x1, 0x14(%rsp)
jne 0x5630
leaq 0xe6(%rip), %rax        # 0x5710
movq %rax, (%rsp)
jmp 0x564d
movl 0x14(%rsp), %edx
leaq 0x115(%rip), %rax       # 0x5750
leaq 0xee(%rip), %rcx        # 0x5730
cmpl $0x2, %edx
cmoveq %rcx, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0x8830
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
leaq 0x22bad(%rip), %rdx     # 0x2821a
callq 0x9120
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x7930
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
leaq 0x22bae(%rip), %rdx     # 0x2823e
callq 0x9120
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpqueue_tableFromTask
static void xpqueue_tableFromTask(lua_State *L, int ndxTask, int mode)
{
   lua_getfield(L, ndxTask, "_queue");  // task.tqueue
   (void) XLUA_CAST(L, -1, XPQueue);    // validate queue
   lua_getuservalue(L, -1);
   lua_rawgeti(L, -1, mode);            // readers/writers
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
leaq 0x22b8a(%rip), %rdx     # 0x2824b
callq 0x8b80
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2b1a9(%rip), %rdx     # 0x30880
leaq 0x22953(%rip), %rcx     # 0x28031
callq 0x5450
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8f60
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8cb0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpqueue_dequeue
static int xpqueue_dequeue(lua_State *L, int mode)
{
   xpqueue_tableFromTask(L, 1, mode);
   lua_getfield(L, 1, "_dequeuedata");  // key = fd
   lua_pushnil(L);                      // value = nil
   lua_rawset(L, -3);                   // readers/writers[fd] = nil

   lua_pushnil(L);
   lua_setfield(L, 1, "_dequeue");      // task.dequeue = nil
   return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0x1, %esi
callq 0x56a0
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x22a9d(%rip), %rdx     # 0x2823e
callq 0x8b80
movq 0x10(%rsp), %rdi
callq 0x8440
movq 0x10(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x91e0
movq 0x10(%rsp), %rdi
callq 0x8440
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x22a40(%rip), %rdx     # 0x2821a
callq 0x9120
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpqueue_dtor
static int xpqueue_dtor(lua_State *L)
{
   XPQueue *me = XLUA_CAST(L, 1, XPQueue);
   if (me->pfds) {
      free(me->pfds);
      me->pfds = NULL;
      me->nfds = 0;
   }
   return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x2b076(%rip), %rdx     # 0x30880
leaq 0x22820(%rip), %rcx     # 0x28031
callq 0x5450
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x584b
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x3040
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpqueue_isEmpty
static int xpqueue_isEmpty(lua_State *L)
{
   int mode;
   int isEmpty = 1;

   lua_getuservalue(L, 1);

   for (mode = 1; mode <= 3; ++mode) {
      lua_rawgeti(L, -1, mode);
      lua_pushnil(L);
      if (lua_next(L, -2) != 0) {
         isEmpty = 0;
         break;
      }
      lua_pop(L, 1);
   }

   lua_pushboolean(L, isEmpty);
   return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x8f60
movl $0x1, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jg 0x5d46
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8cb0
movq 0x10(%rsp), %rdi
callq 0x8440
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x9e50
cmpl $0x0, %eax
je 0x5d2a
movl $0x0, 0x8(%rsp)
jmp 0x5d46
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x74a0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5ce8
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x8980
movl $0x1, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpproc_reap
static int xpproc_reap(void)
{
   int numUpdated = 0;
   int n;
   int status;
   pid_t pid;
   char buf[32];
   int bReceived = 0;

   do {
      n = read(sigchldPipe[0], buf, sizeof buf);
      //printf("%d bytes from from signal pipe!\n", n);
      if (n > 0) {
         bReceived = 1;
      }
   } while (n == sizeof buf);

   if (!bReceived) {
      return 0;
   }

   // reap children
   do {
      pid = waitpid((pid_t)-1, &status, WNOHANG);
      //printf("waitpid -> pid=%d errno=%d\n", pid, errno);
      if (pid > 0) {
         // find and update process object
         XPProc *p;
         for (p = gpHeadProc; p; p = p->next) {
            if (p->pid == pid) {
               p->pid = 0;
               p->status = status;
               ++numUpdated;
               break;
            }
         }
      }
      // POSIX doesn't seem to explicitly disallow EINTER even with WNOHANG
   } while (pid > 0 || (pid == -1 && errno == EINTR));

   //printf("... numUpdatd = %d\n", numUpdated);
   return numUpdated;
}

// Assembly:
subq $0x58, %rsp
movl $0x0, 0x50(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x2b0ee(%rip), %edi     # 0x31248
leaq 0x20(%rsp), %rsi
movl $0x20, %edx
callq 0x3200
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jle 0x617c
movl $0x1, 0x1c(%rsp)
jmp 0x617e
movslq 0x4c(%rsp), %rax
cmpq $0x20, %rax
je 0x6154
cmpl $0x0, 0x1c(%rsp)
jne 0x619d
movl $0x0, 0x54(%rsp)
jmp 0x625f
jmp 0x619f
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq 0x48(%rsp), %rsi
movl $0x1, %edx
callq 0x3380
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x44(%rsp)
jle 0x6218
movq 0x2b093(%rip), %rax     # 0x31258
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x6216
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
cmpl 0x44(%rsp), %eax
jne 0x6205
movq 0x10(%rsp), %rax
movl $0x0, 0x8(%rax)
movl 0x48(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x6216
jmp 0x6207
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x61ca
jmp 0x6218
jmp 0x621a
movb $0x1, %al
cmpl $0x0, 0x44(%rsp)
movb %al, 0xf(%rsp)
jg 0x624b
xorl %eax, %eax
cmpl $-0x1, 0x44(%rsp)
movb %al, 0xe(%rsp)
jne 0x6243
callq 0x3060
cmpl $0x4, (%rax)
sete %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x619f
movl 0x50(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: growArray
static void *
growArray(void *ptr, int *plen, size_t size, int lenMin)
{
   void *pNew;
   int len = *plen;
   int lenNew;

   if (lenMin < len) {
      return ptr;
   }

   lenNew = lenMin * 2;
   pNew = malloc(lenNew * size);
   if (!pNew) {
      return ptr;
   }

   memcpy(pNew, ptr, len * size);
   memset(((char*)pNew) + (len*size), 0, (lenNew - len) * size);
   if (ptr) {
      free(ptr);
   }
   *plen = lenNew;
   return pNew;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x62ab
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x6346
movl 0x14(%rsp), %eax
shll %eax
movl %eax, (%rsp)
movslq (%rsp), %rdi
imulq 0x18(%rsp), %rdi
callq 0x32f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x62dc
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x6346
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movslq 0x4(%rsp), %rdx
imulq 0x18(%rsp), %rdx
callq 0x32b0
movq 0x8(%rsp), %rdi
movslq 0x4(%rsp), %rax
imulq 0x18(%rsp), %rax
addq %rax, %rdi
movl (%rsp), %eax
subl 0x4(%rsp), %eax
movslq %eax, %rdx
imulq 0x18(%rsp), %rdx
xorl %esi, %esi
callq 0x31c0
cmpq $0x0, 0x28(%rsp)
je 0x6332
movq 0x28(%rsp), %rdi
callq 0x3040
movl (%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpsocket_dtor
static int xpsocket_dtor(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);

   if (me->s) {
      close(me->s);
      me->s = -1;
   }
   return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x2a506(%rip), %rdx     # 0x308c0
leaq 0x21c84(%rip), %rcx     # 0x28045
callq 0x5450
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
je 0x63ec
movq 0x8(%rsp), %rax
movl (%rax), %edi
callq 0x31e0
movq 0x8(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpsocket_try_connect
static int xpsocket_try_connect(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);
   const char *addr = luaL_checkstring(L, 2);
   struct sockaddr_in sin;
   int e;

   if (addrFromString(&sin, addr)) {
      return pushError(L, "xpio: mal-formed address");
   }
   e = connect(me->s, (struct sockaddr *)&sin, sizeof sin);

   // POSIX fail: Asynchronous connect oddness.  Instead of EAGAIN or
   // EWOULDBLOCK, we may get either EINPROGRESS or EALREADY to indicate
   // "try again later". Finally, success is indicated by another error code
   // EISCONN. Spec is unclear on whether an actual success result (return
   // value of 0) is possible, and on what the state of the sockaddr must be
   // on calls other than the first.

   if (e && errno != EISCONN) {
      return pushError(L, (isRetry(errno) ? "retry" : NULL));
   }

   lua_pushboolean(L, 1);   // success
   return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x2a4a6(%rip), %rdx     # 0x308c0
leaq 0x21c24(%rip), %rcx     # 0x28045
callq 0x5450
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xb350
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x4260
cmpl $0x0, %eax
je 0x6471
movq 0x38(%rsp), %rdi
leaq 0x21eaa(%rip), %rsi     # 0x2830d
callq 0x49a0
movl %eax, 0x44(%rsp)
jmp 0x64f5
movq 0x30(%rsp), %rax
movl (%rax), %edi
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movl $0x10, %edx
callq 0x33f0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x64de
callq 0x3060
cmpl $0x6a, (%rax)
je 0x64de
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
callq 0x3060
movl (%rax), %edi
callq 0x6f80
movq (%rsp), %rdi
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %esi
leaq 0x21d3c(%rip), %rax     # 0x28208
cmpl $0x0, %ecx
cmovneq %rax, %rsi
callq 0x49a0
movl %eax, 0x44(%rsp)
jmp 0x64f5
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x8980
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpsocket_try_read
static int xpsocket_try_read(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);
   size_t size = checkUInt(L, 2);
   luaL_Buffer b;
   int n;

   if (size == 0) {
      // POSIX fail: reading zero bytes may or may not test for error
      //   conditions on the socket (depending on implementation).  Here we
      //   avoid potential portability issues.
      lua_pushinteger(L, 0);
      return 1;
   }

   char *pbuf = luaL_buffinitsize(L, &b, size);

   n = read(me->s, pbuf, size);
   if (n >= (size ? 1 : 0)) {
      // success
      luaL_pushresultsize(&b, n);
      return 1;
   } else if (n == 0) {
      // end of stream
      lua_pushnil(L);
      return 1;
   } if (isRetry(errno)) {
      // wait for more
      return pushError(L, "retry");
   } else {
      // actual error
      return pushError(L, NULL);
   }
}

// Assembly:
subq $0x2058, %rsp           # imm = 0x2058
movq %rdi, 0x2048(%rsp)
movq 0x2048(%rsp), %rdi
movl $0x1, %esi
leaq 0x2a39d(%rip), %rdx     # 0x308c0
leaq 0x21b1b(%rip), %rcx     # 0x28045
callq 0x5450
movq %rax, 0x2040(%rsp)
movq 0x2048(%rsp), %rdi
movl $0x2, %esi
callq 0x4c80
movl %eax, %eax
movq %rax, 0x2038(%rsp)
cmpq $0x0, 0x2038(%rsp)
jne 0x657f
movq 0x2048(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x84c0
movl $0x1, 0x2054(%rsp)
jmp 0x6661
movq 0x2048(%rsp), %rdi
movq 0x2038(%rsp), %rdx
leaq 0x18(%rsp), %rsi
callq 0xba30
movq %rax, 0x8(%rsp)
movq 0x2040(%rsp), %rax
movl (%rax), %edi
movq 0x8(%rsp), %rsi
movq 0x2038(%rsp), %rdx
callq 0x3200
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x2038(%rsp), %rsi
xorl %ecx, %ecx
movl $0x1, %edx
cmpq $0x0, %rsi
cmovnel %edx, %ecx
cmpl %ecx, %eax
jl 0x65f8
movslq 0x14(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xb910
movl $0x1, 0x2054(%rsp)
jmp 0x6661
cmpl $0x0, 0x14(%rsp)
jne 0x6619
movq 0x2048(%rsp), %rdi
callq 0x8440
movl $0x1, 0x2054(%rsp)
jmp 0x6661
jmp 0x661b
callq 0x3060
movl (%rax), %edi
callq 0x6f80
cmpl $0x0, %eax
je 0x6649
movq 0x2048(%rsp), %rdi
leaq 0x21bcd(%rip), %rsi     # 0x28208
callq 0x49a0
movl %eax, 0x2054(%rsp)
jmp 0x6661
movq 0x2048(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x2054(%rsp)
movl 0x2054(%rsp), %eax
addq $0x2058, %rsp           # imm = 0x2058
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpsocket_try_write
static int xpsocket_try_write(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);
   const char *data = luaL_checkstring(L, 2);
   int n;

   n = write(me->s, data, lua_rawlen(L, 2));
   if (n < 0) {
      return pushError(L, isRetry(errno) ? "retry" : NULL);
   }

   lua_pushinteger(L, n);
   return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x2a236(%rip), %rdx     # 0x308c0
leaq 0x219b4(%rip), %rcx     # 0x28045
callq 0x5450
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xb350
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x81a0
movl 0x14(%rsp), %edi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x30f0
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jge 0x672d
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x3060
movl (%rax), %edi
callq 0x6f80
movq 0x8(%rsp), %rdi
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %esi
leaq 0x21aed(%rip), %rax     # 0x28208
cmpl $0x0, %ecx
cmovneq %rax, %rsi
callq 0x49a0
movl %eax, 0x44(%rsp)
jmp 0x6744
movq 0x38(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x84c0
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpsocket_bind
static int xpsocket_bind(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);
   const char *addr = luaL_checkstring(L, 2);
   struct sockaddr_in sin;

   if (addrFromString(&sin, addr)) {
      return pushError(L, "xpio: mal-formed address argument");
   }
   if (bind(me->s, (struct sockaddr *) &sin, sizeof(sin))) {
      return pushError(L, NULL);
   }

   lua_pushboolean(L, 1);   // success
   return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x2a096(%rip), %rdx     # 0x308c0
leaq 0x21814(%rip), %rcx     # 0x28045
callq 0x5450
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xb350
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x4260
cmpl $0x0, %eax
je 0x687e
movq 0x28(%rsp), %rdi
leaq 0x21ab3(%rip), %rsi     # 0x28326
callq 0x49a0
movl %eax, 0x34(%rsp)
jmp 0x68cc
movq 0x20(%rsp), %rax
movl (%rax), %edi
leaq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rsi
movl $0x10, %edx
callq 0x3370
cmpl $0x0, %eax
je 0x68b5
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x34(%rsp)
jmp 0x68cc
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x8980
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpsocket_listen
static int xpsocket_listen(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);

   int nargs = lua_gettop(L);
   int backlog = 10;

   if (nargs > 1) {
      backlog = checkUInt(L, 2);
   }

   if (listen(me->s, backlog)) {
      return pushError(L, NULL);
   }

   lua_pushboolean(L, 1);   // success
   return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x29fc6(%rip), %rdx     # 0x308c0
leaq 0x21744(%rip), %rcx     # 0x28045
callq 0x5450
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7470
movl %eax, 0xc(%rsp)
movl $0xa, 0x8(%rsp)
cmpl $0x1, 0xc(%rsp)
jle 0x693b
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x4c80
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %edi
movl 0x8(%rsp), %esi
callq 0x3310
cmpl $0x0, %eax
je 0x6964
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x24(%rsp)
jmp 0x697b
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x8980
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpsocket_getsockname
static int xpsocket_getsockname(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);
   struct sockaddr_in sin;
   socklen_t len = sizeof(sin);
   if (getsockname(me->s, (struct sockaddr*) &sin, &len))
      return pushError(L, NULL);
   return xpsocket_getXname(L, &sin);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x29f16(%rip), %rdx     # 0x308c0
leaq 0x21694(%rip), %rcx     # 0x28045
callq 0x5450
movq %rax, 0x20(%rsp)
movl $0x10, 0xc(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %edi
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x33b0
cmpl $0x0, %eax
je 0x69fa
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x34(%rsp)
jmp 0x6a0d
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6fd0
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/monoglot/./xpio_c.c
// Function: xpsocket_getpeername
static int xpsocket_getpeername(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);
   struct sockaddr_in sin;
   socklen_t len = sizeof(sin);
   if (getpeername(me->s, (struct sockaddr *) &sin, &len))
      return pushError(L, NULL);
   return xpsocket_getXname(L, &sin);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x29e86(%rip), %rdx     # 0x308c0
leaq 0x21604(%rip), %rcx     # 0x28045
callq 0x5450
movq %rax, 0x20(%rsp)
movl $0x10, 0xc(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %edi
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x3110
cmpl $0x0, %eax
je 0x6a8a
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x34(%rsp)
jmp 0x6a9d
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6fd0
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/monoglot/./xpio_c.c
// Function: xpsocket_getsockopt
static int xpsocket_getsockopt(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);
   const char *psz = luaL_checkstring(L, 2);
   int nOpt;
   void *opt = (void*)&nOpt;
   socklen_t size = sizeof nOpt;
   int err;

   const SockOpt *po = findSockOpt(psz);
   if (!po) {
      lua_pushnil(L);
      lua_pushstring(L, "xpio: unknown socket option");
      return 2;
   }

   if (po->category == SOCKOPT_SO) {
      err = getsockopt(me->s, po->level, po->name, opt, &size);
   } else if (po->category == SOCKOPT_NB) {
      err = getNonBlocking(me->s, &nOpt);
   } else {
      return pushError(L, "getsockopt: internal error");
   }
   if (err) {
      return pushError(L, NULL);
   }

   if (po->type == SOCKOPT_BOOL) {
      lua_pushboolean(L, nOpt);
   } else if (po->type == SOCKOPT_SIZE) {
      lua_pushnumber(L, (lua_Number) nOpt);
   }
   return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x29df6(%rip), %rdx     # 0x308c0
leaq 0x21574(%rip), %rcx     # 0x28045
callq 0x5450
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xb350
movq %rax, 0x28(%rsp)
leaq 0x24(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x4, 0x14(%rsp)
movq 0x28(%rsp), %rdi
callq 0x70b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6b44
movq 0x38(%rsp), %rdi
callq 0x8440
movq 0x38(%rsp), %rdi
leaq 0x21845(%rip), %rsi     # 0x28377
callq 0x8630
movl $0x2, 0x44(%rsp)
jmp 0x6c11
movq 0x8(%rsp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x6b7b
movq 0x30(%rsp), %rax
movl (%rax), %edi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x8(%rsp), %rax
movl 0x14(%rax), %edx
movq 0x18(%rsp), %rcx
leaq 0x14(%rsp), %r8
callq 0x3220
movl %eax, 0x10(%rsp)
jmp 0x6bb6
movq 0x8(%rsp), %rax
cmpl $0x2, 0xc(%rax)
jne 0x6b9d
movq 0x30(%rsp), %rax
movl (%rax), %edi
leaq 0x24(%rsp), %rsi
callq 0x7120
movl %eax, 0x10(%rsp)
jmp 0x6bb4
movq 0x38(%rsp), %rdi
leaq 0x217ea(%rip), %rsi     # 0x28393
callq 0x49a0
movl %eax, 0x44(%rsp)
jmp 0x6c11
jmp 0x6bb6
cmpl $0x0, 0x10(%rsp)
je 0x6bd1
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x44(%rsp)
jmp 0x6c11
movq 0x8(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x6bec
movq 0x38(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x8980
jmp 0x6c09
movq 0x8(%rsp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x6c07
movq 0x38(%rsp), %rdi
cvtsi2sdl 0x24(%rsp), %xmm0
callq 0x8470
jmp 0x6c09
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpsocket_setsockopt
static int xpsocket_setsockopt(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);
   const char *optName = luaL_checkstring(L, 2);
   int nOpt;
   void *opt = (void*)&nOpt;
   int size = sizeof nOpt;
   int err;

   const SockOpt *po = findSockOpt(optName);
   if (!po) {
      lua_pushnil(L);
      lua_pushstring(L, "xpio: unknown socket option");
      return 2;
   }

   if (po->type == SOCKOPT_BOOL) {
      nOpt = lua_toboolean(L, 3);
   } else if (po->type == SOCKOPT_SIZE) {
      nOpt = checkUInt(L, 3);
   }

   if (po->category == SOCKOPT_SO) {
      err = setsockopt(me->s, po->level, po->name, opt, size);
   } else if (po->category == SOCKOPT_NB) {
      err = setNonBlocking(me->s, nOpt);
   } else {
      return pushError(L, "setsockopt: internal error");
   }
   if (err) {
      return pushError(L, NULL);
   }

   lua_pushboolean(L, 1);
   return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x29c86(%rip), %rdx     # 0x308c0
leaq 0x21404(%rip), %rcx     # 0x28045
callq 0x5450
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xb350
movq %rax, 0x28(%rsp)
leaq 0x24(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x4, 0x14(%rsp)
movq 0x28(%rsp), %rdi
callq 0x70b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6cb4
movq 0x38(%rsp), %rdi
callq 0x8440
movq 0x38(%rsp), %rdi
leaq 0x216d5(%rip), %rsi     # 0x28377
callq 0x8630
movl $0x2, 0x44(%rsp)
jmp 0x6d97
movq 0x8(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x6cd4
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x8060
movl %eax, 0x24(%rsp)
jmp 0x6cf4
movq 0x8(%rsp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x6cf2
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x4c80
movl %eax, 0x24(%rsp)
jmp 0x6cf4
movq 0x8(%rsp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x6d2b
movq 0x30(%rsp), %rax
movl (%rax), %edi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x8(%rsp), %rax
movl 0x14(%rax), %edx
movq 0x18(%rsp), %rcx
movl 0x14(%rsp), %r8d
callq 0x30c0
movl %eax, 0x10(%rsp)
jmp 0x6d65
movq 0x8(%rsp), %rax
cmpl $0x2, 0xc(%rax)
jne 0x6d4c
movq 0x30(%rsp), %rax
movl (%rax), %edi
movl 0x24(%rsp), %esi
callq 0x4a20
movl %eax, 0x10(%rsp)
jmp 0x6d63
movq 0x38(%rsp), %rdi
leaq 0x2169b(%rip), %rsi     # 0x283f3
callq 0x49a0
movl %eax, 0x44(%rsp)
jmp 0x6d97
jmp 0x6d65
cmpl $0x0, 0x10(%rsp)
je 0x6d80
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x44(%rsp)
jmp 0x6d97
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x8980
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpsocket_shutdown
static int xpsocket_shutdown(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);
   const char *flags = luaL_checkstring(L, 2);

   // POSIX fail: You might think that SHUT_RDWR == SHUT_RD|SHUT_WR, but you
   // would be wrong.

   int shutr = strchr(flags, 'r') != NULL;
   int shutw = strchr(flags, 'w') != NULL;
   if (shutr || shutw) {
      int shut = (shutr && shutw ? SHUT_RDWR :
                  shutr ? SHUT_RD :
                  SHUT_WR);
      if (shutdown(me->s, shut)) {
         return pushError(L, NULL);
      }
   }
   lua_pushboolean(L, 1);   // success
   return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x29b06(%rip), %rdx     # 0x308c0
leaq 0x21284(%rip), %rcx     # 0x28045
callq 0x5450
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xb350
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x72, %esi
callq 0x3170
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x77, %esi
callq 0x3170
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x6e2f
cmpl $0x0, 0x10(%rsp)
je 0x6e90
cmpl $0x0, 0x14(%rsp)
je 0x6e48
cmpl $0x0, 0x10(%rsp)
je 0x6e48
movl $0x2, %eax
movl %eax, 0x8(%rsp)
jmp 0x6e5d
movl 0x14(%rsp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %edi
movl 0xc(%rsp), %esi
callq 0x3130
cmpl $0x0, %eax
je 0x6e8e
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x34(%rsp)
jmp 0x6ea7
jmp 0x6e90
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x8980
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpsocket_close
static int xpsocket_close(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);
   if (me->s != -1) {
      close(me->s);
      me->s = -1;
      lua_pushboolean(L, 1);
      return 1;
   } else {
      return pushError(L, "already closed");
   }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x299f6(%rip), %rdx     # 0x308c0
leaq 0x21174(%rip), %rcx     # 0x28045
callq 0x5450
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $-0x1, (%rax)
je 0x6f11
movq (%rsp), %rax
movl (%rax), %edi
callq 0x31e0
movq (%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x8980
movl $0x1, 0x14(%rsp)
jmp 0x6f26
movq 0x8(%rsp), %rdi
leaq 0x214f1(%rip), %rsi     # 0x2840e
callq 0x49a0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: isRetry
static int isRetry(int e)
{
   return e == EAGAIN ||
      e == EWOULDBLOCK ||
      e == EINTR ||
      e == EINPROGRESS ||
      e == EALREADY;
}

// Assembly:
movl %edi, -0x4(%rsp)
movb $0x1, %al
cmpl $0xb, -0x4(%rsp)
movb %al, -0x5(%rsp)
je 0x6fc4
movb $0x1, %al
cmpl $0xb, -0x4(%rsp)
movb %al, -0x5(%rsp)
je 0x6fc4
movb $0x1, %al
cmpl $0x4, -0x4(%rsp)
movb %al, -0x5(%rsp)
je 0x6fc4
movb $0x1, %al
cmpl $0x73, -0x4(%rsp)
movb %al, -0x5(%rsp)
je 0x6fc4
cmpl $0x72, -0x4(%rsp)
sete %al
movb %al, -0x5(%rsp)
movb -0x5(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpsocket_getXname
static int xpsocket_getXname(lua_State *L, struct sockaddr_in* psin)
{
   unsigned char *pby = (unsigned char *) &psin->sin_addr;

   if (psin->sin_family != AF_INET) {
      lua_pushnil(L);
      lua_pushfstring(L, "xpio: unknown address family %d", &psin->sin_family);
      return 2;
   }

   lua_pushfstring(L, "%d.%d.%d.%d:%d",
                   (int) pby[0],
                   (int) pby[1],
                   (int) pby[2],
                   (int) pby[3],
                   (int) (unsigned short) htons(psin->sin_port));
   return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movzwl (%rax), %eax
cmpl $0x2, %eax
je 0x7025
movq 0x38(%rsp), %rdi
callq 0x8440
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0x21334(%rip), %rsi     # 0x28348
movb $0x0, %al
callq 0x8740
movl $0x2, 0x44(%rsp)
jmp 0x70a3
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movzbl 0x1(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movzbl 0x2(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movzbl 0x3(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rax
movzwl 0x2(%rax), %edi
callq 0x3150
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %edx
movl 0x1c(%rsp), %ecx
movl 0x20(%rsp), %r8d
movl 0x24(%rsp), %r9d
movzwl %ax, %eax
leaq 0x212d7(%rip), %rsi     # 0x28368
movl %eax, (%rsp)
movb $0x0, %al
callq 0x8740
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: findSockOpt
static const SockOpt *findSockOpt(const char *psz)
{
   const SockOpt *po = &opts[0];

   for (po = &opts[0]; po->str; ++po) {
      if (0 == strcmp(psz, po->str)) {
         return po;
      }
   }
   return NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x29910(%rip), %rax     # 0x309d0
movq %rax, (%rsp)
leaq 0x29905(%rip), %rax     # 0x309d0
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x710d
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
callq 0x3260
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x70fd
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x7116
jmp 0x70ff
movq (%rsp), %rax
addq $0x18, %rax
movq %rax, (%rsp)
jmp 0x70cf
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: getNonBlocking
static int getNonBlocking(int fd, int *pbOn)
{
   int flags = fcntl(fd, F_GETFL);
   if (flags == -1) {
      *pbOn = 0;
      return -1;
   }
   *pbOn = (flags & O_NONBLOCK) && 1;
   return 0;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl 0x10(%rsp), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x30e0
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
jne 0x715d
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x7192
movl 0x4(%rsp), %ecx
andl $0x800, %ecx            # imm = 0x800
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x3(%rsp)
je 0x717a
movb $0x1, %al
movb %al, 0x3(%rsp)
jmp 0x717a
movb 0x3(%rsp), %al
andb $0x1, %al
movzbl %al, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)