LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-exec.c
// Function: timeout
static void timeout(int sig) {
  struct timeval t;
  _u32 i;

  if (timeout_done) return;

  gettimeofday(&t,0);
  
  i = (t.tv_sec - start_time.tv_sec) * 1000 + (t.tv_usec - start_time.tv_usec) / 1000;
  
  if (i > time_limit) exitflags |= EXITF_TIMEOUT; else {
    i = (t.tv_sec - last_time.tv_sec) * 1000 + (t.tv_usec - last_time.tv_usec) / 1000;
      if (i > stuck_limit) exitflags |= EXITF_STUCK; else return;
  }  

  timeout_done = 1;

#ifdef DEBUG_TRACE
    printf("[bunny-exec] Execution timed out (diff = %u), orig_pid = %u, shmreg->lock = %u...\n",
           i, orig_pid, shmreg->lock);
#endif /* DEBUG_TRACE */

  /* Just let report_kids() take its course, it's safer than calling non-reentrant code
     from here. */

  if (orig_pid > 0) kill(orig_pid,SIGKILL);
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
cmpb $0x0, 0x45ef(%rip)      # 0x6191
je 0x1ba9
jmp 0x1c84
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1200
movq -0x18(%rbp), %rax
subq 0x4597(%rip), %rax      # 0x6158
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
subq 0x4589(%rip), %rax      # 0x6160
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x4551(%rip), %eax      # 0x6148
jbe 0x1c0b
movzbl 0x4592(%rip), %eax      # 0x6192
orl $0x1, %eax
movb %al, 0x4589(%rip)       # 0x6192
jmp 0x1c64
movq -0x18(%rbp), %rax
subq 0x4552(%rip), %rax      # 0x6168
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
subq 0x4544(%rip), %rax      # 0x6170
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x4500(%rip), %eax      # 0x614c
jbe 0x1c60
movzbl 0x453d(%rip), %eax      # 0x6192
orl $0x4, %eax
movb %al, 0x4534(%rip)       # 0x6192
jmp 0x1c62
jmp 0x1c84
jmp 0x1c64
movb $0x1, 0x4526(%rip)      # 0x6191
cmpl $0x0, 0x4522(%rip)      # 0x6194
jle 0x1c84
movl 0x451a(%rip), %edi      # 0x6194
movl $0x9, %esi
callq 0x11a0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-exec.c
// Function: handle_kill
static void handle_kill(int sig) {
  _u32 i;

#ifdef DEBUG_TRACE
  printf("[bunny-exec] Received signal %u.\n",sig);
#endif /* DEBUG_TRACE */
  
  shmctl(shmid, IPC_RMID, 0);
  
  if (orig_pid > 0) kill(orig_pid,SIGKILL);
  for (i=0;i<proc_cnt;i++) 
    if (procs[i].pid) kill(procs[i].pid,SIGKILL);

  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x44df(%rip), %edi      # 0x6180
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x10c0
cmpl $0x0, 0x44e1(%rip)      # 0x6194
jle 0x1cc5
movl 0x44d9(%rip), %edi      # 0x6194
movl $0x9, %esi
callq 0x11a0
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x44c3(%rip), %eax      # 0x6198
jae 0x1d17
movq 0x44c2(%rip), %rax      # 0x61a0
movl -0x8(%rbp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
je 0x1d0a
movq 0x44ac(%rip), %rax      # 0x61a0
movl -0x8(%rbp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %edi
movl $0x9, %esi
callq 0x11a0
jmp 0x1d0c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1ccc
movl $0x1, %edi
callq 0x1130
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-exec.c
// Function: register_param
static void register_param(_u32 pid,_u32 val) {
  _s32 rno = get_procentry(pid,0);
  
  if (rno < 0) fatal("MESSAGE_PARAM for non-existent PID %u",pid);
  
  /* Record parameter data */
  ADDINT(procs[rno].paramlist,val);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
xorl %esi, %esi
callq 0x2e10
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x22b4
jmp 0x2263
movq 0x3d76(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x2059(%rip), %rsi      # 0x42d0
movb $0x0, %al
callq 0x11b0
movq 0x3d5b(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
leaq 0x1dd0(%rip), %rsi      # 0x405f
leaq 0x2077(%rip), %rdx      # 0x430d
leaq 0x1dd7(%rip), %rcx      # 0x4074
movl $0x85, %r8d
movb $0x0, %al
callq 0x11b0
movl $0x1, %edi
callq 0x1130
jmp 0x22b6
movq 0x3ee3(%rip), %rax      # 0x61a0
movslq -0xc(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
addq $0x30, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x2369
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x81, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x2, %rsi
callq 0x1210
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2367
jmp 0x2319
movq 0x3cc0(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
leaq 0x1f65(%rip), %rsi      # 0x428f
movb $0x0, %al
callq 0x11b0
movq 0x3ca8(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
leaq 0x1d1d(%rip), %rsi      # 0x405f
leaq 0x1fc4(%rip), %rdx      # 0x430d
leaq 0x1d24(%rip), %rcx      # 0x4074
movl $0x88, %r8d
movb $0x0, %al
callq 0x11b0
movl $0x1, %edi
callq 0x1130
jmp 0x2369
movl -0x8(%rbp), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rsi
movl 0x8(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x8(%rsi)
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-exec.c
// Function: get_procentry
static _s32 get_procentry(_u32 pid,_u8 make_new) {
  _u32 rno;

  for (rno=0;rno<proc_cnt;rno++) 
    if (procs[rno].pid == pid) return rno;

  if (!make_new) return -1;
  
  proc_cnt++;
  
  if ((proc_cnt % ALLOC_CHUNK) == 1) {
    procs = realloc(procs,(proc_cnt + ALLOC_CHUNK) * sizeof(struct proc_state));
    if (!procs) fatal("out of memory");
    memset((void*)(procs+rno),0,sizeof(struct proc_state) * ALLOC_CHUNK);
  }

  procs[rno].pid = pid;
  
  return rno;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x3367(%rip), %eax      # 0x6198
jae 0x2e63
movq 0x3366(%rip), %rax      # 0x61a0
movl -0x10(%rbp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x2e56
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2f4f
jmp 0x2e58
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2e28
cmpb $0x0, -0x9(%rbp)
jne 0x2e75
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f4f
movl 0x331d(%rip), %eax      # 0x6198
addl $0x1, %eax
movl %eax, 0x3314(%rip)      # 0x6198
movl 0x330e(%rip), %eax      # 0x6198
andl $0x7f, %eax
cmpl $0x1, %eax
jne 0x2f33
movq 0x3303(%rip), %rdi      # 0x61a0
movl 0x32f5(%rip), %eax      # 0x6198
addl $0x80, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x6, %rsi
callq 0x1210
movq %rax, 0x32e4(%rip)      # 0x61a0
cmpq $0x0, 0x32dc(%rip)      # 0x61a0
jne 0x2f16
jmp 0x2ec8
movq 0x3111(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
leaq 0x13b6(%rip), %rsi      # 0x428f
movb $0x0, %al
callq 0x11b0
movq 0x30f9(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
leaq 0x116e(%rip), %rsi      # 0x405f
leaq 0x13bc(%rip), %rdx      # 0x42b4
leaq 0x1175(%rip), %rcx      # 0x4074
movl $0x65, %r8d
movb $0x0, %al
callq 0x11b0
movl $0x1, %edi
callq 0x1130
movq 0x3283(%rip), %rdi      # 0x61a0
movl -0x10(%rbp), %eax
shlq $0x6, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x1060
movl -0x8(%rbp), %ecx
movq 0x3263(%rip), %rax      # 0x61a0
movl -0x10(%rbp), %edx
shlq $0x6, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-exec.c
// Function: sure_write
static _s32 sure_write(_s32 fd, void* buf, _u32 len) {
  _u32 total = 0;

  do {
    _s32 cur = write(fd,buf,len);
    if (cur <= 0) return cur;
    total += cur;
    len   -= cur;
    buf   += cur;
  } while (len);

  return total;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x1040
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x2f9b
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2fcc
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2f79
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-exec.c
// Function: reset_state
static void reset_state(void) {
  _u32 rno, i;

  exitflags           = 0;
  shmreg->write_off   = 0;
  shmreg->read_off    = 0;
  shmreg->lock        = 0;
  shmreg->child_crash = 0;

  wait_res = 0;

  for (i=0;i<16;i++)
    shmreg->func_quota[i] = func_limit;

  /* ignore errors */
  lseek(0,0,SEEK_SET);

  for (rno=0;rno<proc_cnt;rno++) {
    DYN_FREE(procs[rno].funclist);
    FREEINT(procs[rno].nestlist);
    FREEINT(procs[rno].paramlist);
  }

  proc_cnt  = 0;
  orig_pid  = 0;
  fault_loc = 0;

  free(procs);
  procs = 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb $0x0, 0x31a3(%rip)      # 0x6192
movq 0x3192(%rip), %rax      # 0x6188
movl $0x0, 0x8(%rax)
movq 0x3184(%rip), %rax      # 0x6188
movl $0x0, 0xc(%rax)
movq 0x3176(%rip), %rax      # 0x6188
movl $0x0, (%rax)
movq 0x3169(%rip), %rax      # 0x6188
movl $0x0, 0x10(%rax)
movl $0x0, 0x317c(%rip)      # 0x61ac
movl $0x0, -0x8(%rbp)
cmpl $0x10, -0x8(%rbp)
jae 0x305c
movl 0x310d(%rip), %edx      # 0x6150
movq 0x313e(%rip), %rax      # 0x6188
movl -0x8(%rbp), %ecx
movl %edx, 0x14(%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3037
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %esi
movl %edx, %edi
callq 0x1230
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x311f(%rip), %eax      # 0x6198
jae 0x31a8
jmp 0x3081
movq 0x3118(%rip), %rax      # 0x61a0
movl -0x4(%rbp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x30de
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x30d1
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1120
jmp 0x30d3
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x30a1
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x30f4
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1120
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x310c
movq 0x308d(%rip), %rax      # 0x61a0
movl -0x4(%rbp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x313b
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x1120
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x3153
movq 0x3046(%rip), %rax      # 0x61a0
movl -0x4(%rbp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
addq $0x30, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3182
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x1120
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x319a
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3070
movl $0x0, 0x2fe6(%rip)      # 0x6198
movl $0x0, 0x2fd8(%rip)      # 0x6194
movq $0x0, 0x2ff1(%rip) # 0x61b8
movq 0x2fd2(%rip), %rdi      # 0x61a0
callq 0x1120
movq $0x0, 0x2fc2(%rip) # 0x61a0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzdata.c
// Function: usage
static void
usage(void)
{
	printf("usage: lzdata [options] <files...>\n");
	printf("	--filesize <size>	file size (MB)\n");
	printf("	--chunksize <size>	chunk size (KB)\n");
	printf("	--minlitlen <len>	minimum literal length\n");
	printf("	--maxlitlen <len>	minimum literal length\n");
	printf("	--minmatchlen <len>	minimum match length\n");
	printf("	--maxmatchlen <len>	minimum match length\n");
	printf("	--minoffset <len>	minimum offset length\n");
	printf("	--maxoffset <len>	minimum offset length\n");
	printf("	--matchprob <prob>	probability of match [0..1]\n");
	printf("	--litlenscale <val>	literal length scale (> 0)\n");
	printf("	--matchlenscale <val>	match length scale (> 0)\n");
	printf("	--randomseed <val>	random number seed\n");
	printf("	--verbose		report details used\n");
	printf("	--help			this help\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1c13(%rip), %rdi      # 0x34ee
movb $0x0, %al
callq 0x1080
leaq 0x1c29(%rip), %rdi      # 0x3512
movb $0x0, %al
callq 0x1080
leaq 0x1c3e(%rip), %rdi      # 0x3535
movb $0x0, %al
callq 0x1080
leaq 0x1c55(%rip), %rdi      # 0x355a
movb $0x0, %al
callq 0x1080
leaq 0x1c72(%rip), %rdi      # 0x3585
movb $0x0, %al
callq 0x1080
leaq 0x1c8f(%rip), %rdi      # 0x35b0
movb $0x0, %al
callq 0x1080
leaq 0x1cac(%rip), %rdi      # 0x35db
movb $0x0, %al
callq 0x1080
leaq 0x1cc9(%rip), %rdi      # 0x3606
movb $0x0, %al
callq 0x1080
leaq 0x1ce5(%rip), %rdi      # 0x3630
movb $0x0, %al
callq 0x1080
leaq 0x1d01(%rip), %rdi      # 0x365a
movb $0x0, %al
callq 0x1080
leaq 0x1d24(%rip), %rdi      # 0x368b
movb $0x0, %al
callq 0x1080
leaq 0x1d47(%rip), %rdi      # 0x36bc
movb $0x0, %al
callq 0x1080
leaq 0x1d6a(%rip), %rdi      # 0x36ed
movb $0x0, %al
callq 0x1080
leaq 0x1d84(%rip), %rdi      # 0x3715
movb $0x0, %al
callq 0x1080
leaq 0x1d97(%rip), %rdi      # 0x3736
movb $0x0, %al
callq 0x1080
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzdata.c
// Function: generate_data
static unsigned int
generate_data(struct lzdata_args * const args,
    unsigned char * const buffer, const unsigned int size)
{
	unsigned int pos = 0;
	int ret = 0;

	while (pos < args->min_offset)
		pos = gen_literal(buffer, pos, size, args);

	while (pos < size - (args->min_match_len - 1)) {
		if (rngd() < args->match_prob)
			pos = gen_match(buffer, pos, size, args);
		else
			pos = gen_literal(buffer, pos, size, args);
	}

	while (pos < size)
		pos = gen_literal(buffer, pos, size, args);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jae 0x1d15
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rcx
callq 0x1e20
movl %eax, -0x18(%rbp)
jmp 0x1cf1
jmp 0x1d17
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rdx
movl 0x1c(%rdx), %edx
subl $0x1, %edx
subl %edx, %ecx
cmpl %ecx, %eax
jae 0x1d74
callq 0x1f50
movaps %xmm0, %xmm1
movq -0x8(%rbp), %rax
movsd 0x30(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1d5c
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rcx
callq 0x1f60
movl %eax, -0x18(%rbp)
jmp 0x1d72
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rcx
callq 0x1e20
movl %eax, -0x18(%rbp)
jmp 0x1d17
jmp 0x1d76
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1d96
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rcx
callq 0x1e20
movl %eax, -0x18(%rbp)
jmp 0x1d76
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzdata.c
// Function: gen_literal
static unsigned int
gen_literal(unsigned char * const buffer, unsigned int pos,
    const unsigned int size, struct lzdata_args * const args)
{
	unsigned int length;
	unsigned int end;

	length = args->lit_len_scale / (1 - rngd()) -
	    args->lit_len_scale + args->min_lit_len;

	if (length > args->max_lit_len)
		length = args->max_lit_len;

	if (pos + length > size)
		length = size - pos;

	LOG("L %d %d\n", pos, length);

	args->literals++;
	args->literal_bytes += length;

	end = pos + length;

	if (end > 3) {
		while (pos < end - 3) {
			writemem32(&buffer[pos], rngl());
			pos += 4;
		}
	}

	while (pos < end)
		buffer[pos++] = rngl();

	return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x1f50
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
movsd 0x11bf(%rip), %xmm1     # 0x3018
subsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd 0x38(%rax), %xmm1
subsd %xmm1, %xmm0
movl 0x14(%rax), %eax
cvtsi2sd %rax, %xmm1
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jbe 0x1e98
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
addl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jbe 0x1eac
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
movl -0xc(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jbe 0x1f16
jmp 0x1ede
movl -0xc(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jae 0x1f14
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
callq 0x2100
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x20e0
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0x1ede
jmp 0x1f16
jmp 0x1f18
movl -0xc(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x1f3d
callq 0x2100
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
jmp 0x1f18
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/sissm.c
// Function: sissmSegfaultSigaction
void sissmSegfaultSigaction( int signal, siginfo_t *si, void *arg )
{
    int j, nptrs;
    void *buffer[BT_BUF_SIZE];
    char **strings;
    time_t curtime;
    struct tm *loctime;

    nptrs = backtrace( buffer, BT_BUF_SIZE );
    // printf("Caught segfault at address %p\n", si->si_addr);
    // printf( "backtrace() returned %d addresses\n", nptrs );

    // The call backtrace_symbols_fd(buffer, nptrs, STDOUT_FILENO) would
    // produce similar output to the following:
    //
    strings = backtrace_symbols(buffer, nptrs);
    if (strings == NULL) {
        perror( "backtrace_symbols" );
        if ( segfaultFPW != NULL ) {
            fprintf( segfaultFPW, "Segfault Backtrace Error\n" );
            fclose( segfaultFPW );
        };
        exit( EXIT_FAILURE );
    }

    curtime = time (NULL);
    loctime = localtime (&curtime);
    if (NULL != segfaultFPW) fprintf( segfaultFPW, "Crash Time: %s\n", asctime(loctime) );
    for ( j = 0; j < nptrs; j++ ) {
        printf( "%s\n", strings[j] );
        fprintf( segfaultFPW, "%s\n", strings[j] );
    }
    if ( segfaultFPW != NULL ) fclose( segfaultFPW );

    free(strings);
    exit( EXIT_FAILURE );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8040, %rsp           # imm = 0x8040
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x8020(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x8120
movl %eax, -0x20(%rbp)
leaq -0x8020(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x80c0
movq %rax, -0x8028(%rbp)
cmpq $0x0, -0x8028(%rbp)
jne 0x85db
leaq 0x1aa8f(%rip), %rdi     # 0x23030
callq 0x8320
cmpq $0x0, 0x2995a(%rip)     # 0x31f08
je 0x85d1
movq 0x29951(%rip), %rdi     # 0x31f08
leaq 0x1aa84(%rip), %rsi     # 0x23042
movb $0x0, %al
callq 0x8230
movq 0x2993c(%rip), %rdi     # 0x31f08
callq 0x80f0
movl $0x1, %edi
callq 0x8360
xorl %eax, %eax
movl %eax, %edi
callq 0x8280
movq %rax, -0x8030(%rbp)
leaq -0x8030(%rbp), %rdi
callq 0x8050
movq %rax, -0x8038(%rbp)
xorl %eax, %eax
cmpq 0x29901(%rip), %rax     # 0x31f08
je 0x863b
movq 0x298f8(%rip), %rax     # 0x31f08
movq %rax, -0x8040(%rbp)
movq -0x8038(%rbp), %rdi
callq 0x8130
movq -0x8040(%rbp), %rdi
movq %rax, %rdx
leaq 0x1aa28(%rip), %rsi     # 0x2305c
movb $0x0, %al
callq 0x8230
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x8696
movq -0x8028(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x1aeb4(%rip), %rdi     # 0x23514
movb $0x0, %al
callq 0x8170
movq 0x2989a(%rip), %rdi     # 0x31f08
movq -0x8028(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x1ae90(%rip), %rsi     # 0x23514
movb $0x0, %al
callq 0x8230
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8642
cmpq $0x0, 0x2986a(%rip)     # 0x31f08
je 0x86ac
movq 0x29861(%rip), %rdi     # 0x31f08
callq 0x80f0
movq -0x8028(%rbp), %rdi
callq 0x8030
movl $0x1, %edi
callq 0x8360
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/sissm.c
// Function: sissmSegfaultInstall
int sissmSegfaultInstall( char *sissmCfgFileName )
{
    struct sigaction sa;
    char crashFilename[256];
    time_t curtime;
    struct tm *loctime;

    memset( &sa, 0, sizeof(struct sigaction) );
    sigemptyset( &sa.sa_mask );
    sa.sa_sigaction = sissmSegfaultSigaction;
    sa.sa_flags = SA_SIGINFO;

    sigaction(SIGSEGV, &sa, NULL);                                       // invalid memory access
    sigaction(SIGFPE,  &sa, NULL);                                              // divide-by-zero
    sigaction(SIGABRT, &sa, NULL);                                              // stack smashing

    strlcpy( crashFilename, sissmCfgFileName, 256 );
    strlcat( crashFilename, ".crashreport", 256 );
    segfaultFPW = fopen( crashFilename, "at" );

    curtime = time (NULL);
    loctime = localtime (&curtime);
    if ( NULL != segfaultFPW ) {
        fprintf( segfaultFPW, "\n\n------\nInitialized Crash Reporter: %s\n", asctime(loctime) );
        fflush( segfaultFPW );
    }

    return (segfaultFPW == NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x81a0
leaq -0xa0(%rbp), %rdi
addq $0x8, %rdi
callq 0x8240
leaq -0x1b9(%rip), %rax      # 0x8550
movq %rax, -0xa0(%rbp)
movl $0x4, -0x18(%rbp)
movl $0xb, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8090
movl $0x8, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8090
movl $0x6, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8090
leaq -0x1a0(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x1a0(%rbp), %rdi
leaq 0x1a8f3(%rip), %rsi     # 0x2306c
movl $0x100, %edx            # imm = 0x100
callq 0x11aa0
leaq -0x1a0(%rbp), %rdi
leaq 0x1d1bf(%rip), %rsi     # 0x25950
callq 0x8310
movq %rax, 0x2976b(%rip)     # 0x31f08
xorl %eax, %eax
movl %eax, %edi
callq 0x8280
movq %rax, -0x1a8(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x8050
movq %rax, -0x1b0(%rbp)
xorl %eax, %eax
cmpq 0x2973f(%rip), %rax     # 0x31f08
je 0x8809
movq 0x29736(%rip), %rax     # 0x31f08
movq %rax, -0x1b8(%rbp)
movq -0x1b0(%rbp), %rdi
callq 0x8130
movq -0x1b8(%rbp), %rdi
movq %rax, %rdx
leaq 0x1a883(%rip), %rsi     # 0x23079
movb $0x0, %al
callq 0x8230
movq 0x29704(%rip), %rdi     # 0x31f08
callq 0x82b0
cmpq $0x0, 0x296f7(%rip)     # 0x31f08
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/sissm.c
// Function: sissmServerRestartPending
int sissmServerRestartPending( void ) {
    int retValue = 0;
    if (_sissmRestartRequest ) {
        _sissmRestartRequest = 0;
	retValue = 1;
    }
    return retValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x0, 0x2b1de(%rip)     # 0x33d30
je 0x8b65
movl $0x0, 0x2b1d2(%rip)     # 0x33d30
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/sissm.c
// Function: sissmInitInternal
int sissmInitInternal( void )
{
    int errCode = 0;

    alarmInit();
    eventsInit();

    return errCode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x12900
callq 0xedf0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/sissm.c
// Function: sissmRestartServer
int sissmRestartServer( void )
{
    char cmdOut[256], statusIn[256];
    int errCode = 0;

    if (0==strlen( sissmConfig.restartScript )) {
        strlcpy( cmdOut, "quit", 256 );
        apiRcon( cmdOut, statusIn );
    }

#if SISSM_RESTRICTED==0
    else {
        system( sissmConfig.restartScript );                       // hard restart from OS
    }
#endif

    sleep( sissmConfig.restartDelay );

    return errCode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movl $0x0, -0x204(%rbp)
leaq 0x2ab60(%rip), %rdi     # 0x3371c
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x8bf8
leaq -0x100(%rbp), %rdi
leaq 0x1a5c6(%rip), %rsi     # 0x2319f
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
leaq -0x100(%rbp), %rdi
leaq -0x200(%rbp), %rsi
callq 0x17fa0
jmp 0x8c0b
leaq 0x29311(%rip), %rdi     # 0x31f10
addq $0x180c, %rdi           # imm = 0x180C
callq 0x8140
movl 0x2af0b(%rip), %edi     # 0x33b1c
callq 0x8380
movl -0x204(%rbp), %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/sissm.c
// Function: sissmSplash
void sissmSplash( void ) 
{
    logPrintf(LOG_LEVEL_INFO, "sissm", "--------------------------------------" );
    logPrintf(LOG_LEVEL_INFO, "sissm", "%s", VERSION);
    logPrintf(LOG_LEVEL_INFO, "sissm", "%s", COPYRIGHT);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x2, %edi
leaq 0x1a564(%rip), %rsi     # 0x231a4
leaq 0x1b410(%rip), %rdx     # 0x24057
movb $0x0, %al
callq 0x21bf0
movl $0x2, %edi
leaq 0x1a54a(%rip), %rsi     # 0x231a4
leaq 0x1e02b(%rip), %rdx     # 0x26c8c
leaq 0x1a51c(%rip), %rcx     # 0x23184
movb $0x0, %al
callq 0x21bf0
movl $0x2, %edi
leaq 0x1a529(%rip), %rsi     # 0x231a4
leaq 0x1e00a(%rip), %rdx     # 0x26c8c
leaq 0x1a521(%rip), %rcx     # 0x231aa
movb $0x0, %al
callq 0x21bf0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/sissm.c
// Function: sissmDiagnostics
int sissmDiagnostics( void )
{
    int errCode = 0;

    // Check RCON configuration
    //
    if ( (sissmConfig.rconPort < 1024) || (sissmConfig.rconPort > 32767) ) {
        printf("\n** CONFIGURATION ERROR: Invalid Rcon Port is set in .cfg\n");
        printf("Please fix rconPort '%d'.\n", sissmConfig.rconPort );
        errCode = 1;
    }
    if (0 == strlen( sissmConfig.rconPassword) ) {
        printf("\n** CONFIGURATION ERROR: Rcon password is not set in .cfg\n");
        printf("Please fix rconPassword\n");
        errCode = 1;
    }
    if ( 0 == strncmp( "000.000.000.000", reformatIP( sissmConfig.rconIP ), 16 ))  {
        printf("\n** CONFIGURATION ERROR: Invalid server IP set in .cfg\n"); 
        printf("Please fix rconIP '%s'\n", sissmConfig.rconIP );
        errCode = 1;
    }

    // Check critical files
    //
    if ( !isReadable( sissmConfig.gameLogFile ) ) {
        printf("\n** CONFIGURATION ERROR: Game log file not found or unable to read in .cfg\n");
        printf("Please fix gameLogFile: '%s'\n", sissmConfig.gameLogFile );
        errCode = 1;
    }

    if ( errCode ) {
        printf("\nPress ^C now, or SISSM will proceed to run in 15 seconds\n");
        sleep( 15 );
    }

    return errCode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x400, 0x29a5f(%rip)   # imm = 0x400
jl 0x8cc7
cmpl $0x7fff, 0x29a53(%rip)  # imm = 0x7FFF
jle 0x8cf0
leaq 0x1a512(%rip), %rdi     # 0x231e0
movb $0x0, %al
callq 0x8170
movl 0x29a3d(%rip), %esi     # 0x32718
leaq 0x1a539(%rip), %rdi     # 0x2321b
movb $0x0, %al
callq 0x8170
movl $0x1, -0x4(%rbp)
leaq 0x29a25(%rip), %rdi     # 0x3271c
callq 0x8110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x8d29
leaq 0x1a529(%rip), %rdi     # 0x23236
movb $0x0, %al
callq 0x8170
leaq 0x1a556(%rip), %rdi     # 0x23271
movb $0x0, %al
callq 0x8170
movl $0x1, -0x4(%rbp)
leaq 0x291e0(%rip), %rdi     # 0x31f10
addq $0xc0c, %rdi            # imm = 0xC0C
callq 0x126a0
movq %rax, %rsi
leaq 0x1a544(%rip), %rdi     # 0x2328a
movl $0x10, %edx
callq 0x8060
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x8d89
leaq 0x1a53b(%rip), %rdi     # 0x2329a
movb $0x0, %al
callq 0x8170
leaq 0x1a565(%rip), %rdi     # 0x232d2
leaq 0x2919c(%rip), %rsi     # 0x31f10
addq $0xc0c, %rsi            # imm = 0xC0C
movb $0x0, %al
callq 0x8170
movl $0x1, -0x4(%rbp)
leaq 0x29180(%rip), %rdi     # 0x31f10
addq $0x100c, %rdi           # imm = 0x100C
callq 0x12750
cmpl $0x0, %eax
jne 0x8dd2
leaq 0x1a542(%rip), %rdi     # 0x232ea
movb $0x0, %al
callq 0x8170
leaq 0x1a580(%rip), %rdi     # 0x23336
leaq 0x29153(%rip), %rsi     # 0x31f10
addq $0x100c, %rsi           # imm = 0x100C
movb $0x0, %al
callq 0x8170
movl $0x1, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x8df0
leaq 0x1a575(%rip), %rdi     # 0x23354
movb $0x0, %al
callq 0x8170
movl $0xf, %edi
callq 0x8380
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/sissm.c
// Function: sissm_terminal
int sissm_terminal( int argc, char *argv[] )
{
    int paramError = 1;
#ifdef _WIN32
    logPrintfInit( 2, "nul", 1 );
#else
    logPrintfInit( 2, "/dev/null", 1 );
#endif
    if ( argc == 5 ) {
        rdrvTerminal( argv[2], argv[3], argv[4] );
    }
    else if ( paramError ) {
        printf("\n\nSISSM RCON Terminal Tool\n./sissm -t [hostname/IP][port#][rconpassword]");
        printf("\nExample  ./sissm -t 127.0.0.1 27015 myRconPassword\n\n");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x2, %edi
leaq 0x1a286(%rip), %rsi     # 0x23518
movl $0x1, %edx
callq 0x21bb0
cmpl $0x5, -0x4(%rbp)
jne 0x92c1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0xa190
jmp 0x92e5
cmpl $0x0, -0x14(%rbp)
je 0x92e3
leaq 0x1a254(%rip), %rdi     # 0x23522
movb $0x0, %al
callq 0x8170
leaq 0x1a28f(%rip), %rdi     # 0x2356b
movb $0x0, %al
callq 0x8170
jmp 0x92e5
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/sissm.c
// Function: main
int main( int argc, char *argv[] ) 
{
    int errCode;
    int terminalMode = 0;

    if ( argc > 1 )  {
        if ( 0 == strncmp( argv[1], "-t", 2 ) )  {
            terminalMode = 1;
            errCode = sissm_terminal( argc, argv );
        }
    }
    if (!terminalMode) 
        errCode = sissm_main( argc, argv );

    return( errCode );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x934c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1a27f(%rip), %rsi     # 0x235a1
movl $0x2, %edx
callq 0x8060
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x934a
movl $0x1, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x9270
movl %eax, -0x14(%rbp)
jmp 0x934c
cmpl $0x0, -0x18(%rbp)
jne 0x9361
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x9120
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/cfs.c
// Function: cfsCreate
cfsPtr cfsCreate( char *fileName ) 
{
    cfsPtr pCfs = NULL;
    FILE    *fpr;

    if ( NULL != (fpr = fopen( fileName, "rt" )) ) {
        if ( NULL != (pCfs = (cfsPtr) calloc ( 1, sizeof( cfsObj )))) {
            strlcpy( pCfs->cfsFilename, fileName, CFS_FILENAME_MAX );
            pCfs->fpr = fpr;
        }
    }
    return( pCfs );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1ab04(%rip), %rsi     # 0x23e93
callq 0x8310
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x93e2
movl $0x1, %edi
movl $0x408, %esi            # imm = 0x408
callq 0x81f0
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x93e0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x400(%rax)
jmp 0x93e2
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/cfs.c
// Function: cfsDestroy
void cfsDestroy( cfsPtr pCfs )
{
    if ( NULL != pCfs )  {
        if ( NULL != pCfs ) fclose( pCfs->fpr );
        free( pCfs );
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x9425
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x941c
movq -0x8(%rbp), %rax
movq 0x400(%rax), %rdi
callq 0x80f0
movq -0x8(%rbp), %rdi
callq 0x8030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/cfs.c
// Function: cfsFetchStr
char *cfsFetchStr( cfsPtr pCfs, char *varName, char *defaultValue )
{
    static char retStr[CFS_FETCH_MAX], lineIn[CFS_FETCH_MAX];
    char *w, *v, *u;

    strlcpy( retStr, defaultValue, CFS_FETCH_MAX );        

    if ( pCfs != NULL ) {
        fseek( pCfs->fpr, 0L, SEEK_SET );

        while ( !feof( pCfs->fpr ) ) {
            if (NULL != fgets( lineIn, CFS_FETCH_MAX, pCfs->fpr )) {
                w = strcasestr( lineIn, varName );
                if ( w == lineIn ) {
                    v = _cfsStrWash( lineIn );
                    u = strstr( v, " " );
                    if (u != NULL) {
                        strTrimInPlace( u );
                        strlcpy( retStr, u, CFS_FETCH_MAX );
                        break;
                    }
                }
            }
        }
        
    }
    return( retStr );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x2a8f1(%rip), %rdi     # 0x33d40
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
cmpq $0x0, -0x8(%rbp)
je 0x9538
movq -0x8(%rbp), %rax
movq 0x400(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x82d0
movq -0x8(%rbp), %rax
movq 0x400(%rax), %rdi
callq 0x8250
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x949b
jmp 0x9536
movq -0x8(%rbp), %rax
movq 0x400(%rax), %rdx
leaq 0x2ac93(%rip), %rdi     # 0x34140
movl $0x400, %esi            # imm = 0x400
callq 0x81e0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x9531
movq -0x10(%rbp), %rsi
leaq 0x2ac74(%rip), %rdi     # 0x34140
callq 0x8340
movq %rax, -0x20(%rbp)
leaq 0x2ac64(%rip), %rax     # 0x34140
cmpq %rax, -0x20(%rbp)
jne 0x952f
leaq 0x2ac57(%rip), %rdi     # 0x34140
callq 0x9550
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x1ac5b(%rip), %rsi     # 0x24158
callq 0x8390
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x952d
movq -0x30(%rbp), %rdi
callq 0x12450
movq -0x30(%rbp), %rsi
leaq 0x2a81f(%rip), %rdi     # 0x33d40
movl $0x400, %edx            # imm = 0x400
callq 0x11bc0
jmp 0x9536
jmp 0x952f
jmp 0x9531
jmp 0x947a
jmp 0x9538
leaq 0x2a801(%rip), %rax     # 0x33d40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/cfs.c
// Function: cfsFetchNum
double cfsFetchNum( cfsPtr pCfs, char *varName, double defaultValue )
{
    double retValue;
    char   defaultValueString[256];
    char   *w;

    snprintf( defaultValueString, 256, "%lf", defaultValue );
    w = cfsFetchStr( pCfs, varName, defaultValueString );

    if ( 1 != sscanf( w, "%lf", &retValue )) retValue = defaultValue;

    return( retValue );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
leaq -0x120(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movl $0x100, %esi            # imm = 0x100
leaq 0x1b8c0(%rip), %rdx     # 0x250c0
movb $0x1, %al
callq 0x8180
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x120(%rbp), %rdx
callq 0x9430
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rdi
leaq 0x1b890(%rip), %rsi     # 0x250c0
leaq -0x20(%rbp), %rdx
movb $0x0, %al
callq 0x82c0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x9850
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/rdrv.c
// Function: rdrvLogFile
void rdrvLogFile( char *buf, int n, char *fileName )
{
    int   i;
    FILE *fpw;

    if (fileName != NULL) {
        if (strlen( fileName ) != 0) {
            if (NULL != (fpw = fopen( fileName, "wb" ))) {
                for ( i = 0; i<n; i++ ) { fprintf( fpw, "%c", buf[i] ); }
                fclose( fpw );
            }
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x98ec
movq -0x18(%rbp), %rdi
callq 0x8110
cmpq $0x0, %rax
je 0x98ea
movq -0x18(%rbp), %rdi
leaq 0x19d10(%rip), %rsi     # 0x235a4
callq 0x8310
movq %rax, %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x98e8
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x98df
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq 0x19cda(%rip), %rsi     # 0x235a7
movb $0x0, %al
callq 0x8230
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x98ae
movq -0x28(%rbp), %rdi
callq 0x80f0
jmp 0x98ea
jmp 0x98ec
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/rdrv.c
// Function: rdrvSend
int rdrvSend( rdrvObj *rPtr, int msgtype, char *rconcmd )
{
    char buf[BUFSIZE_T];
    int  errCode, outlen;
    // int  i;

    // bzero( buf, BUFSIZE_T );
    memset( buf, 0, BUFSIZE_T );
    buf[8] = msgtype;
    strlcpy( &buf[12], rconcmd, BUFSIZE_T-12 );
    buf[ strlen( rconcmd ) + 13 ] = 0 ;
    buf[ strlen( rconcmd ) + 14 ] = 0 ;
    outlen = (int) strlen( rconcmd ) + 14;
    buf[0] = outlen - 4;
    buf[4] = 1; buf[5] = 2; buf[6] = 3; buf[7] = 4;

    rPtr->serverlen = sizeof( rPtr->serveraddr );
    // sendto(fd, buf, outlen, 0, (const struct sockaddr *) &serveraddr, serverlen);
#ifdef _WIN32
    errCode = 0;
    // send( rPtr->sockfd, buf, outlen, 0);
    errCode = (-1 == send( rPtr->sockfd, buf, outlen, 0 ));
#else
    // errCode = write( rPtr->sockfd, buf, outlen );
    errCode = (-1 == send( rPtr->sockfd, buf, outlen, MSG_NOSIGNAL));
#endif

#if RDRV_DEBUGPRINT
    printf("Sent: ");
    for (i=0; i<outlen; i++) printf("%02x ", 0xff & buf[i]);  // printf("%03d %02x\n", i, buf[i]);
    printf("\n");
#endif

    return( errCode == -1 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x420(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x81a0
movl -0xc(%rbp), %eax
movb %al, -0x418(%rbp)
leaq -0x420(%rbp), %rdi
addq $0xc, %rdi
movq -0x18(%rbp), %rsi
movl $0x3f4, %edx            # imm = 0x3F4
callq 0x11bc0
movq -0x18(%rbp), %rdi
callq 0x8110
movb $0x0, -0x413(%rbp,%rax)
movq -0x18(%rbp), %rdi
callq 0x8110
movb $0x0, -0x412(%rbp,%rax)
movq -0x18(%rbp), %rdi
callq 0x8110
addl $0xe, %eax
movl %eax, -0x428(%rbp)
movl -0x428(%rbp), %eax
subl $0x4, %eax
movb %al, -0x420(%rbp)
movb $0x1, -0x41c(%rbp)
movb $0x2, -0x41b(%rbp)
movb $0x3, -0x41a(%rbp)
movb $0x4, -0x419(%rbp)
movq -0x8(%rbp), %rax
movl $0x10, 0x168(%rax)
movq -0x8(%rbp), %rax
movl 0x154(%rax), %edi
leaq -0x420(%rbp), %rsi
movslq -0x428(%rbp), %rdx
movl $0x4000, %ecx           # imm = 0x4000
callq 0x8160
movq %rax, %rcx
movq $-0x1, %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x424(%rbp)
cmpl $-0x1, -0x424(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/rdrv.c
// Function: rdrvReceive
int rdrvReceive( rdrvObj *rPtr, char *bufin )
{
    int n, i;

    for ( i = 0; i<20; i++ ) {
#ifdef _WIN32
        n = recv( rPtr->sockfd, bufin, BUFSIZE_R, 0);
#else
        n = read( rPtr->sockfd, bufin, BUFSIZE_R );
#endif
        if ( n != -1 ) break;
        usleep( RDRV_DELAY_RCVPOLL20 ); 
   }
    if ( n != -1 ) {

#if RDRV_DEBUGPRINT
        printf("Rcvd: ");
        for (i=0; i<n; i++) printf("%02x ", 0xff & bufin[i]);  // printf("%03d %02x\n", i, bufin[i]);
        printf("\n");
#endif

        if ( n < RCVHDRSIZE ) {
            n = -1;
        }
        else {
            n = n - RCVHDRSIZE;
            if ( n != 0 ) {
                for (i = 0; i<n; i++) {
                    bufin[i] = bufin[i+RCVHDRSIZE];
                }
            }
        }
    }
    return( n );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x14, -0x18(%rbp)
jge 0x9a65
movq -0x8(%rbp), %rax
movl 0x154(%rax), %edi
movq -0x10(%rbp), %rsi
movl $0x4000, %edx           # imm = 0x4000
callq 0x81d0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x9a50
jmp 0x9a65
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x83c0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9a27
cmpl $-0x1, -0x14(%rbp)
je 0x9ac4
cmpl $0xc, -0x14(%rbp)
jge 0x9a7a
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x9ac2
movl -0x14(%rbp), %eax
subl $0xc, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x9ac0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9abe
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0xc, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9a90
jmp 0x9ac0
jmp 0x9ac2
jmp 0x9ac4
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/rdrv.c
// Function: SetSocketBlockingEnabled
static int SetSocketBlockingEnabled(int fd, int blocking)
{
    /** Returns true on success, or false if there was an error */
    if (fd < 0) return 0;

#ifdef _WIN32
    unsigned long mode = blocking ? 0 : 1;
    return (ioctlsocket(fd, FIONBIO, &mode) == 0) ? true : false;
#else
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags < 0) return 0 ;
    flags = blocking ? (flags&~O_NONBLOCK) : (flags|O_NONBLOCK);
    return (fcntl(fd, F_SETFL, flags) == 0) ? 1 : 0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x9cfd
movl $0x0, -0x4(%rbp)
jmp 0x9d68
movl -0x8(%rbp), %edi
movl $0x3, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x80e0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x9d20
movl $0x0, -0x4(%rbp)
jmp 0x9d68
cmpl $0x0, -0xc(%rbp)
je 0x9d33
movl -0x10(%rbp), %eax
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
movl %eax, -0x14(%rbp)
jmp 0x9d3e
movl -0x10(%rbp), %eax
orl $0x800, %eax            # imm = 0x800
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %edi
movl -0x10(%rbp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x80e0
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/rdrv.c
// Function: rdrvInit
rdrvObj *rdrvInit( char *hostName, int portNo, char *rconPassword )
{
#ifdef _WIN32
    WSADATA  wsaData;
#endif
    rdrvObj *rPtr;

    rPtr = (rdrvObj *) calloc( 1, sizeof( rdrvObj ) );
    rPtr->isConnected = 0;
    if (NULL != rPtr) {
        rPtr->sockfd = -1;
        strlcpy(rPtr->rconPassword, rconPassword, RCONPASSMAX);
        rPtr->portNo = portNo;
        strlcpy(rPtr->hostName, hostName, RCONHOSTMAX);
#ifdef _WIN32
        WSAStartup(MAKEWORD(2,2), &wsaData);
#endif
    }
    return( rPtr );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x81f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, 0x16c(%rax)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x9e02
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x154(%rax) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rdi
addq $0x104, %rdi            # imm = 0x104
movq -0x18(%rbp), %rsi
movl $0x50, %edx
callq 0x11bc0
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x100(%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x11bc0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/rdrv.c
// Function: rdrvDisconnect
int rdrvDisconnect( rdrvObj *rPtr )
{
#ifdef _WIN32
    closesocket( rPtr->sockfd );
#else
    close( rPtr->sockfd );
#endif
    rPtr->sockfd = -1;
    rPtr->isConnected = 0;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x154(%rax), %edi
callq 0x81c0
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x154(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x16c(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/rdrv.c
// Function: rdrvXmtRcv
int rdrvXmtRcv( rdrvObj *rPtr, int msgType, char *rconCmd, char *rconResp )
{
    int n, errCode = 0, retryCount = 0;

    while ( retryCount++ < 5 ) {
        if ( 0 == (errCode = rdrvSend( rPtr, msgType, rconCmd ))) {
            usleep( RDRV_DELAY_XMT2RCV );
            n = rdrvReceive( rPtr, rconResp );
            if ( n >= 0 ) break;
            if ( n <  0 ) usleep( RDRV_DELAY_RETRANSMIT );
        }
    }
    if ( errCode || ( retryCount >= 5) ) n = -1;
    
    return( n );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x2c(%rbp)
cmpl $0x5, %eax
jge 0x9ef6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x9900
movl %eax, %ecx
movl %ecx, -0x28(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x9ef4
movl $0x2710, %edi           # imm = 0x2710
callq 0x83c0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9a10
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x9ee2
jmp 0x9ef6
cmpl $0x0, -0x24(%rbp)
jge 0x9ef2
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x83c0
jmp 0x9ef4
jmp 0x9e95
cmpl $0x0, -0x28(%rbp)
jne 0x9f02
cmpl $0x5, -0x2c(%rbp)
jl 0x9f09
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)