LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/proctree.c
// Function: handle_fork
void handle_fork(double elapsed,unsigned int pid,char *child){
  debug("handle_fork(%d,%s)\n",elapsed,pid,child);  
  unsigned int child_pid = atoi(child);
  struct process_info *pinfo,*parent_pinfo;
  struct proc_table_entry *pentry = lookup_pid(child_pid,1);
  struct proc_table_entry *parent_pentry = lookup_pid(pid,0);
  if (pentry) pentry->pinfo->start = elapsed;
  if (pentry && parent_pentry){
    pinfo = pentry->pinfo;
    parent_pinfo = parent_pentry->pinfo;
    
    pinfo->parent = parent_pinfo;
    
    if (parent_pinfo->children){
      pinfo->older_sibling = parent_pinfo->children;
      pinfo->older_sibling->younger_sibling = pinfo;
    }
    parent_pinfo->children = pinfo;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0x1ba2(%rip), %rdi      # 0x30e9
movb $0x1, %al
callq 0x2970
movq -0x18(%rbp), %rdi
callq 0x1160
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movl $0x1, %esi
callq 0x1290
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %edi
xorl %esi, %esi
callq 0x1290
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x1592
movsd -0x8(%rbp), %xmm0
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x18(%rax)
cmpq $0x0, -0x38(%rbp)
je 0x15fb
cmpq $0x0, -0x40(%rbp)
je 0x15fb
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x15ef
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x28(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x50(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/proctree.c
// Function: handle_exit
void handle_exit(double elapsed,unsigned int pid,char *stat){
  debug("handle_exit(%d,%s)\n",elapsed,pid,stat);

  int status;
  struct proc_table_entry *pentry = lookup_pid(pid,0);
  if (pentry){
    pentry->pinfo->finish = elapsed;
    parse_stat(stat,pentry->pinfo);
    status = remove_pid(pid);
    if (status) warning("unable to remove process %d?\n",pid);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0x1922(%rip), %rdi      # 0x3119
movb $0x1, %al
callq 0x2970
movl -0xc(%rbp), %edi
xorl %esi, %esi
callq 0x1290
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x185a
movsd -0x8(%rbp), %xmm0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movsd %xmm0, 0x20(%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1610
movl -0xc(%rbp), %edi
callq 0x13e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1858
movl -0xc(%rbp), %esi
leaq 0x18dc(%rip), %rdi      # 0x312d
movb $0x0, %al
callq 0x26a0
jmp 0x185a
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/proctree.c
// Function: handle_comm
void handle_comm(double elapsed,unsigned int pid,char *comm){
  debug("handle_comm(%d,%s)\n",elapsed,pid,comm);

  struct proc_table_entry *pentry = lookup_pid(pid,0);
  if (pentry){
    pentry->pinfo->comm = strdup(comm);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0x18c4(%rip), %rdi      # 0x314b
movb $0x1, %al
callq 0x2970
movl -0xc(%rbp), %edi
xorl %esi, %esi
callq 0x1290
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x18bb
movq -0x18(%rbp), %rdi
callq 0x1180
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/proctree.c
// Function: handle_cmdline
void handle_cmdline(double elapsed,unsigned int pid,char *cmdline){
  debug("handle_cmdline(%d,%s)\n",elapsed,pid,cmdline);

  struct proc_table_entry *pentry = lookup_pid(pid,0);
  if (pentry){
    pentry->pinfo->cmdline = strdup(cmdline);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0x1868(%rip), %rdi      # 0x315f
movb $0x1, %al
callq 0x2970
movl -0xc(%rbp), %edi
xorl %esi, %esi
callq 0x1290
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x192b
movq -0x18(%rbp), %rdi
callq 0x1180
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/proctree.c
// Function: comm_compare
int comm_compare(const void *c1,const void *c2){
  const struct comm_info *comm1 = c1;
  const struct comm_info *comm2 = c2;
  if (comm1->total_utime > comm2->total_utime) return -1;
  else if (comm1->total_utime < comm2->total_utime) return 1;
  else if (comm1->total_stime > comm2->total_stime) return -1;
  else if (comm1->total_stime < comm2->total_stime) return 1;
  else if (comm1->count > comm2->count) return -1;
  else if (comm1->count < comm2->count) return 1;
  else return strcmp(comm1->comm,comm2->comm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0x197c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a0f
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x1995
movl $0x1, -0x4(%rbp)
jmp 0x1a0f
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jbe 0x19ae
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a0f
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x19c7
movl $0x1, -0x4(%rbp)
jmp 0x1a0f
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jbe 0x19e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a0f
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x19f9
movl $0x1, -0x4(%rbp)
jmp 0x1a0f
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x10d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/proctree.c
// Function: print_statistics
static void print_statistics(){
  int count;
  int i;

  printf("%d processes\n",total_processes);
  
  struct comm_info *ci;
  collect_process_totals(root_process);
  // format and sort
  struct comm_info *comm_table = malloc(num_comm_info*sizeof(struct comm_info));
  count = 0;
  for (ci=comm_totals;ci;ci=ci->next){
    *(&comm_table[count]) = *ci;
    count++;
  }
  qsort(comm_table,num_comm_info,sizeof(struct comm_info),comm_compare);
  for (i=0;i<num_comm_info;i++){
    printf("\t%3d %-20s %8.2f %8.2f\n",
	   comm_table[i].count,
	   comm_table[i].comm,
	   (double) comm_table[i].total_utime / clocks_per_second,
	   (double) comm_table[i].total_stime / clocks_per_second);    
  }
  
  printf("%d processes running\n",num_processes);
  printf("%d maximum processes\n",max_num_processes);
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x2fd6(%rip), %esi      # 0x5124
leaq 0x12ca(%rip), %rdi      # 0x341f
movb $0x0, %al
callq 0x1080
movq 0x2fb5(%rip), %rdi      # 0x5118
callq 0x22a0
movslq 0x32f5(%rip), %rdi      # 0x5464
shlq $0x5, %rdi
callq 0x10f0
movq %rax, -0x18(%rbp)
movl $0x0, -0x4(%rbp)
movq 0x32ce(%rip), %rax      # 0x5458
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x21dd
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x218e
movq -0x18(%rbp), %rdi
movslq 0x327c(%rip), %rsi      # 0x5464
movl $0x20, %edx
leaq -0x8b4(%rip), %rcx      # 0x1940
callq 0x1050
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x325b(%rip), %eax      # 0x5464
jge 0x2262
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
shlq $0x5, %rcx
movl 0x8(%rax,%rcx), %esi
movq (%rax,%rcx), %rdx
movl 0xc(%rax,%rcx), %edi
cvtsi2sd %rdi, %xmm0
cvtsi2sdl 0x3230(%rip), %xmm1 # 0x5460
divsd %xmm1, %xmm0
movl 0x10(%rax,%rcx), %eax
cvtsi2sd %rax, %xmm1
cvtsi2sdl 0x321b(%rip), %xmm2 # 0x5460
divsd %xmm2, %xmm1
leaq 0x11dd(%rip), %rdi      # 0x342d
movb $0x2, %al
callq 0x1080
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2200
movl 0x2eb8(%rip), %esi      # 0x5120
leaq 0x11d6(%rip), %rdi      # 0x3445
movb $0x0, %al
callq 0x1080
movl 0x2eac(%rip), %esi      # 0x5128
leaq 0x11d8(%rip), %rdi      # 0x345b
movb $0x0, %al
callq 0x1080
leaq 0xe7d(%rip), %rdi       # 0x310e
movb $0x0, %al
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/proctree.c
// Function: collect_process_totals
static void collect_process_totals(struct process_info *pinfo){
  struct comm_info *ci;
  struct process_info *child;

  // look for this process
  int found = 0;
  for (ci = comm_totals;ci;ci=ci->next){
    if (pinfo->comm && !strcmp(pinfo->comm,ci->comm)){
      ci->total_utime += pinfo->utime;
      ci->total_stime += pinfo->stime;
      ci->count++;
      found = 1;
      break;
    }
  }
  // not found, so add an entry
  if (!found && pinfo->comm){
    ci = calloc(1,sizeof(struct comm_info));
    ci->comm = strdup(pinfo->comm);
    ci->next = comm_totals;
    ci->total_utime = pinfo->utime;
    ci->total_stime = pinfo->stime;
    ci->count = 1;
    comm_totals = ci;
    num_comm_info++;
  }
  
  // walk the tree of children (the particular order doesn't matter so go from youngest to oldest
  for (child=pinfo->children;child;child=child->older_sibling)
    collect_process_totals(child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
movq 0x319e(%rip), %rax      # 0x5458
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2331
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2321
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x10d0
cmpl $0x0, %eax
jne 0x2321
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl $0x1, -0x1c(%rbp)
jmp 0x2331
jmp 0x2323
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x22be
cmpl $0x0, -0x1c(%rbp)
jne 0x23c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x23c0
movl $0x1, %edi
movl $0x20, %esi
callq 0x10b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1180
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x30e1(%rip), %rcx      # 0x5458
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x30a7(%rip)      # 0x5458
movl 0x30ad(%rip), %eax      # 0x5464
addl $0x1, %eax
movl %eax, 0x30a4(%rip)      # 0x5464
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x23ea
movq -0x18(%rbp), %rdi
callq 0x22a0
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x23cc
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/error.c
// Function: initialize_error_subsystem
void initialize_error_subsystem(char *prog,char *filename){
  FILE *new_stream;
  program = prog;
  initialized = 1;
  if (!strcmp(filename,"-")){
    error_stream = stderr;
  } else {
    if (new_stream = fopen(filename,"a+")){
      error_stream = new_stream;
    } else {
      /* avoid looping in call to fatal */
      fatal("can not open error file: %s\n",filename);
    }
  }
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x3065(%rip)      # 0x5470
movl $0x1, 0x3063(%rip)      # 0x5478
movq -0x10(%rbp), %rdi
leaq 0xd56(%rip), %rsi       # 0x3176
callq 0x10d0
cmpl $0x0, %eax
jne 0x243d
movq 0x2bc7(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, 0x3045(%rip)      # 0x5480
jmp 0x2478
movq -0x10(%rbp), %rdi
leaq 0x108c(%rip), %rsi      # 0x34d4
callq 0x1110
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2464
movq -0x18(%rbp), %rax
movq %rax, 0x301e(%rip)      # 0x5480
jmp 0x2476
movq -0x10(%rbp), %rsi
leaq 0x1068(%rip), %rdi      # 0x34d7
movb $0x0, %al
callq 0x2480
jmp 0x2478
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/error.c
// Function: fatal
void fatal(char *message,...){
  va_list ap;
  if (elevel >= ERROR_LEVEL_FATAL){
    if (!initialized) initialize_error_subsystem(NULL,"-");
    va_start(ap,message);
    if (program != NULL) fprintf(error_stream,"%s: ",program);
    fprintf(error_stream,"fatal error: ");
    vfprintf(error_stream,message,ap);
    va_end(ap);
  }
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x24b5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x2c05(%rip)      # 0x50e8
jb 0x2579
cmpl $0x0, 0x2f88(%rip)      # 0x5478
jne 0x2502
xorl %eax, %eax
movl %eax, %edi
leaq 0xc79(%rip), %rsi       # 0x3176
callq 0x23f0
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
cmpq $0x0, 0x2f42(%rip)      # 0x5470
je 0x254c
movq 0x2f49(%rip), %rdi      # 0x5480
movq 0x2f32(%rip), %rdx      # 0x5470
leaq 0xfaf(%rip), %rsi       # 0x34f4
movb $0x0, %al
callq 0x10e0
movq 0x2f2d(%rip), %rdi      # 0x5480
leaq 0xf9f(%rip), %rsi       # 0x34f9
movb $0x0, %al
callq 0x10e0
movq 0x2f18(%rip), %rdi      # 0x5480
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1150
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x1170
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/error.c
// Function: error
void error(char *message,...){
  va_list ap;
  if (elevel >= ERROR_LEVEL_ERROR){
    if (!initialized) initialize_error_subsystem(NULL,"-");
    va_start(ap,message);
    if (program != NULL) fprintf(error_stream,"%s: ",program);
    fprintf(error_stream,"error: ");
    vfprintf(error_stream,message,ap);
    va_end(ap);
  }
  n_error++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x25c5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x1, 0x2af5(%rip)      # 0x50e8
jb 0x2689
cmpl $0x0, 0x2e78(%rip)      # 0x5478
jne 0x2612
xorl %eax, %eax
movl %eax, %edi
leaq 0xb69(%rip), %rsi       # 0x3176
callq 0x23f0
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
cmpq $0x0, 0x2e32(%rip)      # 0x5470
je 0x265c
movq 0x2e39(%rip), %rdi      # 0x5480
movq 0x2e22(%rip), %rdx      # 0x5470
leaq 0xe9f(%rip), %rsi       # 0x34f4
movb $0x0, %al
callq 0x10e0
movq 0x2e1d(%rip), %rdi      # 0x5480
leaq 0xe95(%rip), %rsi       # 0x34ff
movb $0x0, %al
callq 0x10e0
movq 0x2e08(%rip), %rdi      # 0x5480
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1150
leaq -0x20(%rbp), %rax
movl 0x2dd9(%rip), %eax      # 0x5468
incl %eax
movl %eax, 0x2dd1(%rip)      # 0x5468
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/error.c
// Function: warning
void warning(char *message,...){
  va_list ap;
  if (elevel >= ERROR_LEVEL_WARNING){
    if (!initialized) initialize_error_subsystem(NULL,"-");
    va_start(ap,message);
    if (program != NULL) fprintf(error_stream,"%s: ",program);
    fprintf(error_stream,"warning: ");
    vfprintf(error_stream,message,ap);
    va_end(ap);
  }
  n_warning++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x26d5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x2, 0x29e5(%rip)      # 0x50e8
jb 0x2799
cmpl $0x0, 0x2d68(%rip)      # 0x5478
jne 0x2722
xorl %eax, %eax
movl %eax, %edi
leaq 0xa59(%rip), %rsi       # 0x3176
callq 0x23f0
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
cmpq $0x0, 0x2d22(%rip)      # 0x5470
je 0x276c
movq 0x2d29(%rip), %rdi      # 0x5480
movq 0x2d12(%rip), %rdx      # 0x5470
leaq 0xd8f(%rip), %rsi       # 0x34f4
movb $0x0, %al
callq 0x10e0
movq 0x2d0d(%rip), %rdi      # 0x5480
leaq 0xd8d(%rip), %rsi       # 0x3507
movb $0x0, %al
callq 0x10e0
movq 0x2cf8(%rip), %rdi      # 0x5480
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1150
leaq -0x20(%rbp), %rax
movl 0x2ccd(%rip), %eax      # 0x546c
incl %eax
movl %eax, 0x2cc5(%rip)      # 0x546c
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/error.c
// Function: notice
void notice(char *message,...){
  va_list ap;
  if (elevel >= ERROR_LEVEL_NOTICE){
    if (!initialized) initialize_error_subsystem(NULL,"-");
    va_start(ap,message);
    if (program != NULL) fprintf(error_stream,"%s: ",program);
    vfprintf(error_stream,message,ap);
    va_end(ap);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x27e5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x3, 0x28d5(%rip)      # 0x50e8
jb 0x2890
cmpl $0x0, 0x2c5c(%rip)      # 0x5478
jne 0x282e
xorl %eax, %eax
movl %eax, %edi
leaq 0x94d(%rip), %rsi       # 0x3176
callq 0x23f0
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
cmpq $0x0, 0x2c16(%rip)      # 0x5470
je 0x2878
movq 0x2c1d(%rip), %rdi      # 0x5480
movq 0x2c06(%rip), %rdx      # 0x5470
leaq 0xc83(%rip), %rsi       # 0x34f4
movb $0x0, %al
callq 0x10e0
movq 0x2c01(%rip), %rdi      # 0x5480
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1150
leaq -0x20(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/error.c
// Function: debug
void debug(char *message,...){
  va_list ap;
  if (elevel >= ERROR_LEVEL_DEBUG){
    if (!initialized) initialize_error_subsystem(NULL,"-");
    va_start(ap,message);
    if (program != NULL) fprintf(error_stream,"%s: ",program);
    fprintf(error_stream,"debug: ");
    vfprintf(error_stream,message,ap);
    va_end(ap);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x29a5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x4, 0x2715(%rip)      # 0x50e8
jb 0x2a69
cmpl $0x0, 0x2a98(%rip)      # 0x5478
jne 0x29f2
xorl %eax, %eax
movl %eax, %edi
leaq 0x789(%rip), %rsi       # 0x3176
callq 0x23f0
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
cmpq $0x0, 0x2a52(%rip)      # 0x5470
je 0x2a3c
movq 0x2a59(%rip), %rdi      # 0x5480
movq 0x2a42(%rip), %rdx      # 0x5470
leaq 0xabf(%rip), %rsi       # 0x34f4
movb $0x0, %al
callq 0x10e0
movq 0x2a3d(%rip), %rdi      # 0x5480
leaq 0xac7(%rip), %rsi       # 0x3511
movb $0x0, %al
callq 0x10e0
movq 0x2a28(%rip), %rdi      # 0x5480
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1150
leaq -0x20(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/error.c
// Function: debug2
void debug2(char *message,...){
  va_list ap;
  if (elevel >= ERROR_LEVEL_DEBUG2){
    if (!initialized) initialize_error_subsystem(NULL,"-");
    va_start(ap,message);
    if (program != NULL) fprintf(error_stream,"%s: ",program);
    fprintf(error_stream,"debug: ");
    vfprintf(error_stream,message,ap);
    va_end(ap);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2ab5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x5, 0x2605(%rip)      # 0x50e8
jb 0x2b79
cmpl $0x0, 0x2988(%rip)      # 0x5478
jne 0x2b02
xorl %eax, %eax
movl %eax, %edi
leaq 0x679(%rip), %rsi       # 0x3176
callq 0x23f0
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
cmpq $0x0, 0x2942(%rip)      # 0x5470
je 0x2b4c
movq 0x2949(%rip), %rdi      # 0x5480
movq 0x2932(%rip), %rdx      # 0x5470
leaq 0x9af(%rip), %rsi       # 0x34f4
movb $0x0, %al
callq 0x10e0
movq 0x292d(%rip), %rdi      # 0x5480
leaq 0x9b7(%rip), %rsi       # 0x3511
movb $0x0, %al
callq 0x10e0
movq 0x2918(%rip), %rdi      # 0x5480
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1150
leaq -0x20(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/spinner.c
// Function: init_spinner
int init_spinner(SPINNER** spinner)
{
    SPINNER*    sp  = NULL;

    if ((sp = (SPINNER*)
                malloc(sizeof(SPINNER))) == NULL)
        return -1;
    {
        sp->pid             = 0;
        sp->delay           = DEFAULT_DELAY_TIME;
        sp->symbl           = NULL;
        sp->msg             = NULL;
        sp->config          = config_spinner;
        sp->until           = until_spinner;
        sp->done            = done_spinner;
        sp->chg_delay_time  = change_delay_time;
        sp->release         = release_spinner;
    }
    *spinner = sp;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x40, %edi
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1214
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x129e
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x186a0, 0x4(%rax)     # imm = 0x186A0
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
leaq 0x64(%rip), %rcx        # 0x12b0
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
leaq 0x155(%rip), %rcx       # 0x13b0
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
leaq 0x216(%rip), %rcx       # 0x1480
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
leaq 0x277(%rip), %rcx       # 0x14f0
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
leaq 0x288(%rip), %rcx       # 0x1510
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/spinner.c
// Function: config_spinner
static
int config_spinner(SPINNER** spinner, const char* msg, const char* symbl)
{
    int     status  = 0;

    if (msg != NULL) {
        if ((*spinner)->msg != NULL) {
            release_msg(*spinner);
            (*spinner)->msg = NULL;
        }
        if (copy_message(spinner, msg) < 0) {
            status = -1; goto ERR;
        }
    }
    if (symbl != NULL) {
        if ((*spinner)->symbl != NULL) {
            release_symbl(*spinner);
            (*spinner)->symbl = NULL;
        }
        if (copy_symbol(spinner, symbl) < 0) {
            status = -2; goto ERR;
        }
    }

    return 0;

ERR:
    switch (status) {
        case    -1:
            break;
        case    -2:
            release_msg(*spinner);
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1318
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x12fb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1550
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1590
cmpl $0x0, %eax
jge 0x1316
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
jmp 0x136e
jmp 0x1318
cmpq $0x0, -0x20(%rbp)
je 0x1365
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x1348
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1620
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1660
cmpl $0x0, %eax
jge 0x1363
movl $0xfffffffe, -0x24(%rbp) # imm = 0xFFFFFFFE
jmp 0x136e
jmp 0x1365
movl $0x0, -0x4(%rbp)
jmp 0x1399
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $-0x2, %eax
je 0x1387
jmp 0x137b
movl -0x28(%rbp), %eax
subl $-0x1, %eax
jne 0x1393
jmp 0x1385
jmp 0x1393
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1550
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/spinner.c
// Function: until_spinner
static
int until_spinner(SPINNER** spinner, const char* msg, const char* symbl)
{
    if ((msg == NULL && (*spinner)->msg == NULL) ||
            (symbl == NULL && (*spinner)->symbl == NULL))
        return -1;

    if (msg != NULL || symbl != NULL)
        if ((*spinner)->config(spinner, msg, symbl) < 0)
            return -2;

    switch ((*spinner)->pid = fork()) {
        case    -1:
            return -3;
        case    0:
            do_animation(*spinner);
            exit(0);
        default:
            break;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x13d9
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x13ee
cmpq $0x0, -0x20(%rbp)
jne 0x13f7
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x13f7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1476
cmpq $0x0, -0x18(%rbp)
jne 0x1405
cmpq $0x0, -0x20(%rbp)
je 0x142e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
jge 0x142c
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1476
jmp 0x142e
callq 0x10f0
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl %eax, (%rcx)
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
subl $-0x1, %eax
je 0x1451
jmp 0x1448
movl -0x24(%rbp), %eax
testl %eax, %eax
je 0x145a
jmp 0x146d
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x1476
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x16f0
xorl %edi, %edi
callq 0x10e0
jmp 0x146f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/spinner.c
// Function: done_spinner
static
int done_spinner(SPINNER* spinner)
{
    if (spinner->pid < 0)
        return -1;

    kill(spinner->pid, SIGKILL);
    waitpid(spinner->pid, NULL, 0);
    fprintf(stdout, "\x1b[2K\r");

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x149e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14de
movq -0x10(%rbp), %rax
movl (%rax), %edi
movl $0x9, %esi
callq 0x1090
movq -0x10(%rbp), %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10d0
movq 0x2b1a(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0xb38(%rip), %rsi       # 0x2008
movb $0x0, %al
callq 0x1070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/spinner.c
// Function: release_spinner
static
void release_spinner(SPINNER* spinner)
{
    if (spinner != NULL) {
        release_msg(spinner);
        release_symbl(spinner);
        free(spinner);
        spinner = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1546
movq -0x8(%rbp), %rdi
callq 0x1550
movq -0x8(%rbp), %rdi
callq 0x1620
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/spinner.c
// Function: release_msg
static
void release_msg(SPINNER* spinner)
{
    if (spinner->msg != NULL) {
        free(spinner->msg);
        spinner->msg = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1580
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/spinner.c
// Function: copy_message
static
int copy_message(SPINNER** spinner, const char* msg)
{
    size_t  len     = 0;

    len = strlen(msg);
    if (((*spinner)->msg = (char*)
                malloc(sizeof(char) * (len + 1))) == NULL) {
        return -1;
    } else {
        memcpy((*spinner)->msg, msg, len);
        *((*spinner)->msg + len) = '\0';
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x10a0
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x15e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1612
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1080
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/spinner.c
// Function: release_symbl
static
void release_symbl(SPINNER* spinner)
{
    if (spinner->symbl != NULL) {
        free(spinner->symbl);
        spinner->symbl = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1650
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/spinner.c
// Function: copy_symbol
static
int copy_symbol(SPINNER** spinner, const char* symbl)
{
    size_t  len     = 0;

    len = strlen(symbl);
    if (((*spinner)->symbl = (char*)
                malloc(sizeof(char) * (len + 1))) == NULL) {
        return -1;
    } else {
        memcpy((*spinner)->symbl, symbl, len);
        *((*spinner)->symbl + len) = '\0';
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x10a0
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x16b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x16e2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1080
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/spinner.c
// Function: do_animation
static
void do_animation(SPINNER* spinner)
{
    int     size    = 0;

    char*   symbl   = NULL;

    setlocale(LC_CTYPE, "");
    mblen(NULL, 0);
    while (1) {
        symbl = spinner->symbl;
        while (*symbl) {
            size = mblen(symbl, MB_CUR_MAX);
            fprintf(stdout, "%.*s %s",
                    size, symbl, spinner->msg);
            fflush(stdout);
            usleep(spinner->delay);
            fprintf(stdout, "\r");
            symbl += size;
        }
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
xorl %edi, %edi
leaq 0x8f9(%rip), %rsi       # 0x200d
callq 0x10c0
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x17ca
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x1050
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1040
movl %eax, -0xc(%rbp)
movq 0x287f(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
leaq 0x886(%rip), %rsi       # 0x2000
movb $0x0, %al
callq 0x1070
movq 0x2858(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x1100
movq 0x283d(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0x85f(%rip), %rsi       # 0x200c
movb $0x0, %al
callq 0x1070
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x1731
jmp 0x1725
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/kvserver.c
// Function: main
int
main(int argc, char ** argv)
{
  if (argc < 4) {
    fprintf(stderr, "Usage: %s <host> <port> api ...\n", argv[0]);
    kvmap_api_helper_message();
    exit(0);
  }

  const char * const host = argv[1];
  const int pn = atoi(argv[2]);
  struct kvmap_api * api = NULL;
  struct kvmap_mm mm = {};
  mm.af = kv_alloc_malloc;
  mm.rf = kv_retire_free;
  argc -= 3;
  argv += 3;
  const int n1 = kvmap_api_helper(argc, argv, &api, &mm, false);
  if (n1 < 0 || api == NULL) {
    fprintf(stderr, "kvmap_api_helper() failed\n");
    exit(0);
  }
  struct server * const ser = server_create(host, pn, kv_worker, api);
  if (ser == NULL) {
    fprintf(stderr, "server_create() failed\n");
    exit(0);
  }
  //fclose(stdin);
  //fclose(stdout);
  //fclose(stderr);
  server_wait(ser);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
jge 0x674a
movq 0x1b8d2(%rip), %rax     # 0x21ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x14911(%rip), %rsi     # 0x1b048
movb $0x0, %al
callq 0x62e0
callq 0xe460
xorl %edi, %edi
callq 0x6500
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x64b0
movl %eax, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x6200
leaq 0x794b(%rip), %rax      # 0xe0d0
movq %rax, -0x78(%rbp)
leaq 0x7960(%rip), %rax      # 0xe0f0
movq %rax, -0x68(%rbp)
movl -0x8(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x78(%rbp), %rcx
xorl %r8d, %r8d
callq 0xe540
movl %eax, -0x7c(%rbp)
cmpl $0x0, -0x7c(%rbp)
jl 0x67d0
cmpq $0x0, -0x28(%rbp)
jne 0x67ef
movq 0x1b821(%rip), %rax     # 0x21ff8
movq (%rax), %rdi
leaq 0x14888(%rip), %rsi     # 0x1b069
movb $0x0, %al
callq 0x62e0
xorl %edi, %edi
callq 0x6500
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rcx
leaq 0x4f(%rip), %rdx        # 0x6850
callq 0xd580
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x88(%rbp)
jne 0x6836
movq 0x1b7da(%rip), %rax     # 0x21ff8
movq (%rax), %rdi
leaq 0x1485c(%rip), %rsi     # 0x1b084
movb $0x0, %al
callq 0x62e0
xorl %edi, %edi
callq 0x6500
movq -0x88(%rbp), %rdi
callq 0xd900
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/kvserver.c
// Function: kv_worker
static void *
kv_worker(void * const ptr)
{
  if (ptr == NULL) return NULL;
  struct server_wi * const wi = (typeof(wi))ptr;
  struct stream2 * const s2 = server_wi_stream2(wi);
  struct kvmap_api * const api = (typeof(api))server_wi_private(wi);
  while ((!feof(s2->r)) && (!ferror(s2->r)) && (!ferror(s2->w))) {
    char opcode;
    if (fread(&opcode, sizeof(opcode), 1, s2->r) != 1) break;
    bool r = false;
    switch(opcode) {
    case 'G':
      r = kv_get(s2, api); break;
    case 'P':
      r = kv_probe(s2, api); break;
    case 'S':
      r = kv_set(s2, api); break;
    case 'D':
      r = kv_del(s2, api); break;
    case 'C':
      r = kv_clean(s2, api); break;
    default:
      break;
    }
    if (r == false) break;
  }
  server_wi_destroy(wi);
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6870
movq $0x0, -0x8(%rbp)
jmp 0x69c0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd980
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd9a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6310
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2b(%rbp)
jne 0x68db
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x60c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2b(%rbp)
jne 0x68db
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x60c0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
testb $0x1, %al
jne 0x68e7
jmp 0x69af
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
leaq -0x29(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x60f0
cmpq $0x1, %rax
je 0x690b
jmp 0x69af
movb $0x0, -0x2a(%rbp)
movsbl -0x29(%rbp), %eax
addl $-0x43, %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x10, %eax
ja 0x6999
movq -0x38(%rbp), %rax
leaq 0x146d8(%rip), %rcx     # 0x1b004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x69d0
andb $0x1, %al
movb %al, -0x2a(%rbp)
jmp 0x699b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6ae0
andb $0x1, %al
movb %al, -0x2a(%rbp)
jmp 0x699b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6b70
andb $0x1, %al
movb %al, -0x2a(%rbp)
jmp 0x699b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6c00
andb $0x1, %al
movb %al, -0x2a(%rbp)
jmp 0x699b
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6c90
andb $0x1, %al
movb %al, -0x2a(%rbp)
jmp 0x699b
jmp 0x699b
movb -0x2a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x69aa
jmp 0x69af
jmp 0x6892
movq -0x18(%rbp), %rdi
callq 0xd9c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/kvserver.c
// Function: kv_get
static bool
kv_get(struct stream2 * const s2, struct kvmap_api * const api)
{
  struct kv * key = __read_kv(s2, false);
  if (key == NULL) return false;

  struct kv * const r = api->get(api->map, key, NULL);
  free(key);

  if (__write_ack(s2, r ? true : false) == false) {
    if (r) free(r);
    return false;
  }
  if (r) {
    if (fwrite(r, kv_size(r), 1, s2->w) != 1) {
      free(r);
      return false;
    }
    free(r);
  }
  fflush(s2->w);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x6d00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x69ff
movb $0x0, -0x1(%rbp)
jmp 0x6aca
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq -0x20(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq *%rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6060
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x6de0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6a6c
cmpq $0x0, -0x28(%rbp)
je 0x6a66
movq -0x28(%rbp), %rdi
callq 0x6060
movb $0x0, -0x1(%rbp)
jmp 0x6aca
cmpq $0x0, -0x28(%rbp)
je 0x6aba
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xdbe0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %edx
callq 0x6520
cmpq $0x1, %rax
je 0x6ab1
movq -0x28(%rbp), %rdi
callq 0x6060
movb $0x0, -0x1(%rbp)
jmp 0x6aca
movq -0x28(%rbp), %rdi
callq 0x6060
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6390
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/kvserver.c
// Function: kv_probe
static bool
kv_probe(struct stream2 * const s2, struct kvmap_api * const api)
{
  struct kv * key = __read_kv(s2, false);
  if (key == NULL) return false;

  const bool r = api->probe(api->map, key);
  free(key);

  if (__write_ack(s2, r) == false) {
    return false;
  }
  fflush(s2->w);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x6d00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6b0c
movb $0x0, -0x1(%rbp)
jmp 0x6b60
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6060
movq -0x10(%rbp), %rdi
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x6de0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6b50
movb $0x0, -0x1(%rbp)
jmp 0x6b60
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6390
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/kvserver.c
// Function: kv_set
static bool
kv_set(struct stream2 * const s2, struct kvmap_api * const api)
{
  struct kv * kv = __read_kv(s2, true);
  if (kv == NULL) return false;

  const bool r = api->set(api->map, kv);
  free(kv);

  if (__write_ack(s2, r) == false) {
    return false;
  }
  fflush(s2->w);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6d00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6b9f
movb $0x0, -0x1(%rbp)
jmp 0x6bf3
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6060
movq -0x10(%rbp), %rdi
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x6de0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6be3
movb $0x0, -0x1(%rbp)
jmp 0x6bf3
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6390
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/kvserver.c
// Function: kv_del
static bool
kv_del(struct stream2 * const s2, struct kvmap_api * const api)
{
  struct kv * key = __read_kv(s2, false);
  if (key == NULL) return false;

  const bool r = api->del(api->map, key);
  free(key);

  if (__write_ack(s2, r) == false) {
    return false;
  }
  fflush(s2->w);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x6d00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6c2c
movb $0x0, -0x1(%rbp)
jmp 0x6c80
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6060
movq -0x10(%rbp), %rdi
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x6de0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6c70
movb $0x0, -0x1(%rbp)
jmp 0x6c80
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6390
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/kvserver.c
// Function: kv_clean
static bool
kv_clean(struct stream2 * const s2, struct kvmap_api * const api)
{
  api->clean(api->map);
  bool r = true;
  if (__write_ack(s2, r) == false) {
    return false;
  }
  fflush(s2->w);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x6de0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6cd6
movb $0x0, -0x1(%rbp)
jmp 0x6ce6
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6390
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)