LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/dubeyalok7[P]crypto-algo/des/feistal_algo/feistal_decrypt.c
// Function: decrypt_ecb
void decrypt_ecb(FILE *infile, FILE *outfile, uint32_t keys[])
{
  uint32_t left, right;
  size_t ret;
  uint64_t sblock;
  memset(&sblock, 0, sizeof(sblock));
  while(fread(&sblock, sizeof(sblock), 1, infile)){
    left = (sblock>>32);
    right = (sblock<<32)>>32;
    sblock = decrypt(left, right, keys);
    fwrite(&sblock, 1, sizeof(sblock), outfile);
    memset(&sblock, 0, sizeof(sblock));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x1050
testq %rax, %rax
je 0x14fd
leaq 0x8(%rsp), %r12
movq 0x8(%rsp), %rcx
movq %rcx, %r14
shrq $0x20, %r14
movl $0xf, %r13d
movl %ecx, %ebp
movl (%rbx,%r13,4), %esi
movl %ecx, %edi
callq 0x1534
xorl %r14d, %eax
subq $0x1, %r13
movl %eax, %ecx
cmovbl %ebp, %ecx
movl %ebp, %r14d
cmovbl %eax, %r14d
cmpq $-0x1, %r13
jne 0x148f
shlq $0x20, %rax
movl %ebp, %ecx
orq %rax, %rcx
movq %rcx, 0x8(%rsp)
movl $0x1, %esi
movl $0x8, %edx
movq %r12, %rdi
movq 0x10(%rsp), %rcx
callq 0x10e0
movq $0x0, 0x8(%rsp)
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
callq 0x1050
testq %rax, %rax
jne 0x147d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dubeyalok7[P]crypto-algo/des/feistal_algo/keymgmt.c
// Function: generateSubKeys
int generateSubKeys(char *key, uint32_t keys[]){
  int k=0;
  if(key==NULL)
    return 0;
  for(int i=0;(i<ROUNDS) &&((key[k] != '\0')||(key[k] != '\n'));i+=2, k++){
    keys[i] = (uint32_t)key[k]^keys[i];
    keys[i+1] = (uint32_t)key[k]^keys[i+1];
  }
  return 1;
}

// Assembly:
testq %rdi, %rdi
je 0x1531
xorl %eax, %eax
movsbl (%rdi,%rax), %ecx
xorl %ecx, (%rsi,%rax,8)
movsbl (%rdi,%rax), %ecx
xorl %ecx, 0x4(%rsi,%rax,8)
incq %rax
cmpq $0x8, %rax
jne 0x1513
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/dubeyalok7[P]crypto-algo/des/feistal_algo/main.c
// Function: main
int main(int argc, char *argv[])
{
  FILE *infile, *outfile;
  char *key;
  int op;
  if((argc==2)&&(!strcmp(argv[1],"-g"))){
    generateKey();
    return 0;
  }

  if((argc < 5)){
    help();
    return 0;
  }

  for(int i=1; i< argc ; i+=2){
    if(!strcmp(argv[i],"-i")){
      printf("Input file: %s\n", argv[i+1]);
      infile = fopen(argv[i+1],"r");
      if(!infile){
        printf("Error: in-valid file name\n");
        help();
        return 0;
      }
    }
    else if(!strcmp(argv[i],"-o")){
      printf("Output File: %s\n",argv[i+1]);
      outfile = fopen(argv[i+1],"w+");
    }
    else if(!strcmp(argv[i],"-e")|| !strcmp(argv[i],"-d")){
      if(argv[i][1] =='e'){
        printf("Encrypting the file...\n");
        op = ENCRYPT;
      }else if(argv[i][1] =='d'){
        op = DECRYPT;
        printf("Decrypting the file...\n");
      }else{
        help();
        return 0;
      }
    }
  }
  fesital(infile, outfile, op);
  fclose(infile);
  fclose(outfile);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x2, %edi
jne 0x15be
movq 0x8(%rbx), %rax
cmpb $0x2d, (%rax)
jne 0x15c5
cmpb $0x67, 0x1(%rax)
jne 0x15c5
cmpb $0x0, 0x2(%rax)
jne 0x15c5
callq 0x1539
jmp 0x16cf
movl %edi, %ebp
cmpl $0x5, %edi
jge 0x15d1
xorl %eax, %eax
callq 0x11fc
jmp 0x16cf
movl $0x1, %r15d
movq (%rbx,%r15,8), %rax
cmpb $0x2d, (%rax)
jne 0x16a4
cmpb $0x69, 0x1(%rax)
jne 0x15f0
cmpb $0x0, 0x2(%rax)
je 0x163b
cmpb $0x6f, 0x1(%rax)
jne 0x15fc
cmpb $0x0, 0x2(%rax)
je 0x1669
cmpb $0x65, 0x1(%rax)
jne 0x1608
cmpb $0x0, 0x2(%rax)
je 0x161c
cmpb $0x64, 0x1(%rax)
jne 0x16a4
cmpb $0x0, 0x2(%rax)
jne 0x16a4
movzbl 0x1(%rax), %eax
cmpl $0x64, %eax
je 0x1692
cmpl $0x65, %eax
jne 0x15c5
leaq 0xc29(%rip), %rdi       # 0x225a
callq 0x1040
xorl %r14d, %r14d
jmp 0x16a4
movq 0x8(%rbx,%r15,8), %rsi
leaq 0xbbc(%rip), %rdi       # 0x2203
xorl %eax, %eax
callq 0x1080
movq 0x8(%rbx,%r15,8), %rdi
leaq 0xbb9(%rip), %rsi       # 0x2213
callq 0x10c0
movq %rax, %r13
testq %rax, %rax
jne 0x16a4
jmp 0x16e0
movq 0x8(%rbx,%r15,8), %rsi
leaq 0xba0(%rip), %rdi       # 0x2215
xorl %eax, %eax
callq 0x1080
movq 0x8(%rbx,%r15,8), %rdi
leaq 0xb9e(%rip), %rsi       # 0x2226
callq 0x10c0
movq %rax, %r12
jmp 0x16a4
leaq 0xbaa(%rip), %rdi       # 0x2243
callq 0x1040
movl $0x1, %r14d
addq $0x2, %r15
cmpl %ebp, %r15d
jl 0x15d7
movq %r13, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x1230
movq %r13, %rdi
callq 0x1060
movq %r12, %rdi
callq 0x1060
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb42(%rip), %rdi       # 0x2229
callq 0x1040
jmp 0x15c5
// File: /workspace/github_c_makefile_star2_O3/cyb70289[P]tt/tests/stack_queue.c
// Function: main
int main(void)
{
	struct tt_stack stack = {
		.cap	= LEN,
		.esize	= sizeof(int),
	};

	printf("Testing static stack...\n");
	tt_stack_init(&stack);
	test_stack(&stack);
	tt_stack_free(&stack);
	printf("\n");

	printf("Testing dynamic stack...\n");
	stack.cap = 0;
	tt_stack_init(&stack);
	test_stack(&stack);
	tt_stack_free(&stack);
	printf("\n");

	struct tt_queue queue = {
		.cap	= LEN,
		.esize	= sizeof(int),
	};

	printf("Testing static queue...\n");
	tt_queue_init(&queue);
	test_queue(&queue);
	tt_queue_free(&queue);
	printf("\n");

	printf("Testing dynamic queue...\n");
	queue.cap = 0;
	tt_queue_init(&queue);
	test_queue(&queue);
	tt_queue_free(&queue);
	printf("\n");

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rbx
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x28(%rbx)
movabsq $0x400000010, %r14      # imm = 0x400000010
movq %r14, (%rbx)
leaq 0x2bd8(%rip), %rdi      # 0x4008
callq 0x1060
movq %rbx, %rdi
callq 0x2408
movq %rbx, %rdi
callq 0x1509
movq %rbx, %rdi
callq 0x2610
movl $0xa, %edi
callq 0x1040
leaq 0x2bc2(%rip), %rdi      # 0x4020
callq 0x1060
xorl %ebp, %ebp
movl %ebp, (%rbx)
movq %rbx, %rdi
callq 0x2408
movq %rbx, %rdi
callq 0x1509
movq %rbx, %rdi
callq 0x2610
movl $0xa, %edi
callq 0x1040
leaq 0x38(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
movq %r14, (%rbx)
leaq 0x2b92(%rip), %rdi      # 0x4039
callq 0x1060
movq %rbx, %rdi
callq 0x2674
movq %rbx, %rdi
callq 0x1573
movq %rbx, %rdi
callq 0x28b2
movl $0xa, %edi
callq 0x1040
leaq 0x2b7c(%rip), %rdi      # 0x4051
callq 0x1060
movl %ebp, (%rbx)
movq %rbx, %rdi
callq 0x2674
movq %rbx, %rdi
callq 0x1573
movq %rbx, %rdi
callq 0x28b2
movl $0xa, %edi
callq 0x1040
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mabdi[P]bunney/bunny-main.c
// Function: handle_sig
static void handle_sig(int sig) {
  if (flow_pid != -1) kill(flow_pid,SIGTERM);
  if (exec_pid != -1) kill(exec_pid,SIGTERM);
  outf("+++ Fuzzing stopped on signal %d +++\n", sig);
  fclose(outfile);
  exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl 0x9052(%rip), %edi      # 0x10234
cmpl $-0x1, %edi
je 0x71f1
movl $0xf, %esi
callq 0x22c0
movl 0x9041(%rip), %edi      # 0x10238
cmpl $-0x1, %edi
je 0x7206
movl $0xf, %esi
callq 0x22c0
leaq 0x45bb(%rip), %rdi      # 0xb7c8
xorl %r14d, %r14d
movl %ebx, %esi
xorl %eax, %eax
callq 0x2030
movq 0x9048(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x723c
leaq 0x459c(%rip), %rsi      # 0xb7c8
movl %ebx, %edx
xorl %eax, %eax
callq 0x22d0
movq 0x902c(%rip), %r14      # 0x10268
movq %r14, %rdi
callq 0x21d0
movl $0x1, %edi
callq 0x2230
// File: /workspace/github_c_makefile_star2_O3/mabdi[P]bunney/bunny-main.c
// Function: par_atou
static _u32 par_atou(_u8* txt,_u8 opt,_u8 takezero) {
  _u32 ret;
  if (sscanf(txt,"%u",&ret) != 1) fatal("malformed -%c option",opt);
  if (!takezero && !ret) fatal("-%c option must not be zero",opt);
  /* A crude sanity check - 100M oughta be enough for everyone */
  if (ret > 100000000) fatal("excessive -%c value",opt);
  return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
leaq 0x4221(%rip), %rsi      # 0xb47d
leaq 0x4(%rsp), %rdx
xorl %eax, %eax
callq 0x21c0
cmpl $0x1, %eax
jne 0x7296
testb %bpl, %bpl
setne %cl
movl 0x4(%rsp), %eax
testl %eax, %eax
setne %dl
orb %cl, %dl
je 0x7316
cmpl $0x5f5e101, %eax        # imm = 0x5F5E101
jae 0x7393
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movzbl %bl, %ebx
leaq 0x454e(%rip), %rdi      # 0xb7ee
movl %ebx, %esi
xorl %eax, %eax
callq 0x2030
movq 0x8fb8(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x72c5
leaq 0x4532(%rip), %rsi      # 0xb7ee
movl %ebx, %edx
xorl %eax, %eax
callq 0x22d0
leaq 0x3f71(%rip), %rdi      # 0xb23d
leaq 0x4547(%rip), %rsi      # 0xb81a
leaq 0x3f73(%rip), %rdx      # 0xb24d
movl $0x716, %ecx            # imm = 0x716
xorl %eax, %eax
callq 0x2030
movq 0x8f7b(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x7411
leaq 0x3f40(%rip), %rsi      # 0xb23d
leaq 0x4516(%rip), %rdx      # 0xb81a
leaq 0x3f42(%rip), %rcx      # 0xb24d
movl $0x716, %r8d            # imm = 0x716
jmp 0x740a
movzbl %bl, %ebx
leaq 0x4503(%rip), %rdi      # 0xb823
movl %ebx, %esi
xorl %eax, %eax
callq 0x2030
movq 0x8f38(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x7345
leaq 0x44e7(%rip), %rsi      # 0xb823
movl %ebx, %edx
xorl %eax, %eax
callq 0x22d0
leaq 0x3ef1(%rip), %rdi      # 0xb23d
leaq 0x44c7(%rip), %rsi      # 0xb81a
leaq 0x3ef3(%rip), %rdx      # 0xb24d
movl $0x717, %ecx            # imm = 0x717
xorl %eax, %eax
callq 0x2030
movq 0x8efb(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x7411
leaq 0x3ec0(%rip), %rsi      # 0xb23d
leaq 0x4496(%rip), %rdx      # 0xb81a
leaq 0x3ec2(%rip), %rcx      # 0xb24d
movl $0x717, %r8d            # imm = 0x717
jmp 0x740a
movzbl %bl, %ebx
leaq 0x44b9(%rip), %rdi      # 0xb856
movl %ebx, %esi
xorl %eax, %eax
callq 0x2030
movq 0x8ebb(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x73c2
leaq 0x449d(%rip), %rsi      # 0xb856
movl %ebx, %edx
xorl %eax, %eax
callq 0x22d0
leaq 0x3e74(%rip), %rdi      # 0xb23d
leaq 0x444a(%rip), %rsi      # 0xb81a
leaq 0x3e76(%rip), %rdx      # 0xb24d
movl $0x719, %ecx            # imm = 0x719
xorl %eax, %eax
callq 0x2030
movq 0x8e7e(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x7411
leaq 0x3e47(%rip), %rsi      # 0xb23d
leaq 0x441d(%rip), %rdx      # 0xb81a
leaq 0x3e49(%rip), %rcx      # 0xb24d
movl $0x719, %r8d            # imm = 0x719
xorl %eax, %eax
callq 0x22d0
movl $0x1, %edi
callq 0x2230
// File: /workspace/github_c_makefile_star2_O3/mabdi[P]bunney/bunny-main.c
// Function: N
static _u8* N(_u8* dir, _u8* file) {
  static _u8* fn = 0;
  
  if (fn) free(fn);
  fn = malloc(strlen(dir) + strlen(file) + 2);
  if (!fn) fatal("out of memory");
  
  sprintf(fn,"%s/%s",dir,file);

  return fn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38cc2(%rip), %rdi     # 0x40370
testq %rdi, %rdi
je 0x76b8
callq 0x2220
movq %r14, %rdi
callq 0x20e0
movq %rax, %r15
movq %rbx, %rdi
callq 0x20e0
leaq (%r15,%rax), %rdi
addq $0x2, %rdi
callq 0x2270
movq %rax, 0x38c91(%rip)     # 0x40370
testq %rax, %rax
je 0x7708
leaq 0x4d1c(%rip), %rsi      # 0xc407
movq %rax, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2050
movq 0x38c6e(%rip), %rax     # 0x40370
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3e89(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x8b4b(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x7738
leaq 0x3e6f(%rip), %rdi      # 0xb598
movl $0x24, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x3afe(%rip), %rdi      # 0xb23d
leaq 0x5f6d(%rip), %rsi      # 0xd6b3
leaq 0x3b00(%rip), %rdx      # 0xb24d
movl $0x100, %ecx            # imm = 0x100
xorl %eax, %eax
callq 0x2030
movq 0x8b08(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x7787
leaq 0x3ad1(%rip), %rsi      # 0xb23d
leaq 0x5f40(%rip), %rdx      # 0xd6b3
leaq 0x3ad3(%rip), %rcx      # 0xb24d
movl $0x100, %r8d            # imm = 0x100
xorl %eax, %eax
callq 0x22d0
movl $0x1, %edi
callq 0x2230
// File: /workspace/github_c_makefile_star2_O3/mabdi[P]bunney/bunny-main.c
// Function: purge_outflow
static void purge_outflow(void) {
  DIR* d;
  struct dirent* dent;
  _u8 wbuf[MAXTOKEN];
  
  if (!outflow_dir) fatal("inflow_dir is NULL");
  
  if (!(d = opendir(outflow_dir))) pfatal("unable to open %s",outflow_dir);
  
  while ((dent = readdir(d))) {
    if (dent->d_name[0] == '.') continue;
    snprintf(wbuf,MAXTOKEN,"%s/%s",outflow_dir,dent->d_name);
    if (unlink(wbuf)) pfatal("unable to unlink %s\n",wbuf);
  }
  
  closedir(d);
  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq 0x8903(%rip), %rdi      # 0x10310
testq %rdi, %rdi
je 0x7a99
callq 0x2300
testq %rax, %rax
je 0x7b22
movq %rax, %rbx
movq %rax, %rdi
callq 0x2320
testq %rax, %rax
je 0x7a7d
leaq 0x49cc(%rip), %r14      # 0xc407
movq %rsp, %r15
cmpb $0x2e, 0x13(%rax)
je 0x7a70
addq $0x13, %rax
movq 0x88c1(%rip), %rcx      # 0x10310
movl $0x1000, %esi           # imm = 0x1000
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %r8
xorl %eax, %eax
callq 0x2340
movq %r15, %rdi
callq 0x2100
testl %eax, %eax
jne 0x7a91
movq %rbx, %rdi
callq 0x2320
testq %rax, %rax
jne 0x7a3e
movq %rbx, %rdi
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
jmp 0x2350
movq %rsp, %rdi
callq 0x27d3
leaq 0x48f8(%rip), %rdi      # 0xc398
xorl %eax, %eax
callq 0x2030
movq 0x87ba(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x7ac9
leaq 0x48de(%rip), %rdi      # 0xc398
movl $0x29, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x376d(%rip), %rdi      # 0xb23d
leaq 0x4936(%rip), %rsi      # 0xc40d
leaq 0x376f(%rip), %rdx      # 0xb24d
movl $0x19a, %ecx            # imm = 0x19A
xorl %eax, %eax
callq 0x2030
movq 0x8777(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x7b18
leaq 0x3740(%rip), %rsi      # 0xb23d
leaq 0x4909(%rip), %rdx      # 0xc40d
leaq 0x3742(%rip), %rcx      # 0xb24d
movl $0x19a, %r8d            # imm = 0x19A
xorl %eax, %eax
callq 0x22d0
movl $0x1, %edi
callq 0x2230
callq 0x2868
// File: /workspace/github_c_makefile_star2_O3/mabdi[P]bunney/bunny-main.c
// Function: discard_context
static void discard_context(struct bunny_traceitem* t, _u8 free_t) {
  _u32 i;

  if (!t->param_data) fatal("context freed more than once");

  free(t->param_data);
  free(t->param_range);
  free(t->param_chgmap);
    
  /* To detect access... */
  t->param_data  = 0;
  t->param_range = 0;

  for (i=0;i<t->param_count;i++) FREEINT2(t->eff[i]);

  free(t->eff);
  t->eff = 0;

  FREEINT(t->has_eff);

  if (t->fault_loc) free(t->fault_loc);

  if (free_t) free(t);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x8b11
movl %esi, %ebp
callq 0x2220
movq 0x40(%rbx), %rdi
callq 0x2220
movq 0x48(%rbx), %rdi
callq 0x2220
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movq %rax, 0x40(%rbx)
cmpl $0x0, 0x28(%rbx)
je 0x8ab7
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x58(%rbx), %r12
movq (%r12,%r14), %rdi
testq %rdi, %rdi
je 0x8a85
callq 0x2220
movq 0x8(%r12,%r14), %rdi
testq %rdi, %rdi
je 0x8a94
callq 0x2220
addq %r14, %r12
incq %r15
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movl $0x0, 0x10(%r12)
movl 0x28(%rbx), %eax
addq $0x18, %r14
cmpq %rax, %r15
jb 0x8a73
movq 0x58(%rbx), %rdi
callq 0x2220
movq $0x0, 0x58(%rbx)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x8ad6
callq 0x2220
movq $0x0, 0x60(%rbx)
movl $0x0, 0x68(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x8af3
callq 0x2220
testb %bpl, %bpl
je 0x8b08
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4534(%rip), %rdi      # 0xd04c
xorl %eax, %eax
callq 0x2030
movq 0x7742(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x8b41
leaq 0x451a(%rip), %rdi      # 0xd04c
movl $0x33, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x26f5(%rip), %rdi      # 0xb23d
leaq 0x4531(%rip), %rsi      # 0xd080
leaq 0x26f7(%rip), %rdx      # 0xb24d
movl $0x31b, %ecx            # imm = 0x31B
xorl %eax, %eax
callq 0x2030
movq 0x76ff(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x8b90
leaq 0x26c8(%rip), %rsi      # 0xb23d
leaq 0x4504(%rip), %rdx      # 0xd080
leaq 0x26ca(%rip), %rcx      # 0xb24d
movl $0x31b, %r8d            # imm = 0x31B
xorl %eax, %eax
callq 0x22d0
movl $0x1, %edi
callq 0x2230
// File: /workspace/github_c_makefile_star2_O3/mabdi[P]bunney/bunny-main.c
// Function: free_input
static void free_input(_u8* dir,_u8 deldir) {
  DIR* d;
  struct dirent* dent;

  if (!strcmp(in_dir,dir) || !dir[0]) return;

  d = opendir(dir);
  if (!d) pfatal("cannot open '%s' for reading",dir);

  while ((dent = readdir(d))) {
    if (dent->d_name[0] == '.') continue;
    unlink(N(dir,dent->d_name));
  }

  closedir(d);
  if (deldir) {
    _u8* x = strrchr(dir,'/');
    rmdir(dir);
    if (x) { *x = 0; rmdir(dir); }
  }

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x6341(%rip), %rdi      # 0x10260
movq %rbx, %rsi
callq 0x22a0
testl %eax, %eax
je 0x9fa6
cmpb $0x0, (%rbx)
je 0x9fa6
movq %rbx, %rdi
callq 0x2300
testq %rax, %rax
je 0x9fab
movq %rax, %r14
movq %r14, %rdi
callq 0x2320
testq %rax, %rax
je 0x9f6c
cmpb $0x2e, 0x13(%rax)
je 0x9f40
addq $0x13, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x769c
movq %rax, %rdi
callq 0x2100
jmp 0x9f40
movq %r14, %rdi
callq 0x2350
testb %bpl, %bpl
je 0x9fa6
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x21f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
testq %r14, %r14
je 0x9fa6
movb $0x0, (%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x20d0
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x2d28
// File: /workspace/github_c_makefile_star2_O3/keithnoguchi[P]pearls-in-action/0xb/isort1.c
// Function: isort1
void isort1(int x[], unsigned int nr)
{
	unsigned int i, j;

	for (i = 1; i < nr; i++)
		for (j = i; j && x[j-1] > x[j]; j--)
			swap(x, j-1, j);
}

// Assembly:
cmpl $0x2, %esi
jb 0x251f
movl $0x1, %eax
xorl %ecx, %ecx
movl %eax, %edx
movl (%rdi,%rdx,4), %edx
movq %rcx, %r8
movl %r8d, %r9d
movl (%rdi,%r9,4), %r10d
cmpl %edx, %r10d
jle 0x2516
movl %edx, (%rdi,%r9,4)
movl %r10d, 0x4(%rdi,%r8,4)
decq %r8
cmpl $-0x1, %r8d
jne 0x24f8
incl %eax
incq %rcx
cmpl %esi, %eax
jne 0x24f0
retq
// File: /workspace/github_c_makefile_star2_O3/keithnoguchi[P]pearls-in-action/0xb/isort1_test.c
// Function: generate_random_array
static void generate_random_array(int x[], int nr)
{
	int i;

	init_array(x, nr, 0);
	srand(time(0));
	for (i = 0; i < nr/2; i++) {
		int j = rand()%nr;
		swap(x, i, j);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x2708
movl %ebx, %ecx
leal 0x1(%rbx), %eax
andl $-0x2, %eax
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x29aa(%rip), %xmm1     # 0x5040
xorl %ecx, %ecx
movdqa 0x29b0(%rip), %xmm2     # 0x5050
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x29b0(%rip), %xmm4     # 0x5060
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0x26e5
movl %ecx, (%r14,%rcx,4)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x26fb
leal 0x1(%rcx), %edx
movl %edx, 0x4(%r14,%rcx,4)
addq $0x2, %rcx
paddq %xmm4, %xmm1
cmpq %rcx, %rax
jne 0x26b0
xorl %edi, %edi
callq 0x2080
movl %eax, %edi
callq 0x2070
cmpl $0x2, %ebx
jl 0x2747
movl %ebx, %r15d
shrl %r15d
xorl %r12d, %r12d
callq 0x2090
cltd
idivl %ebx
movl (%r14,%r12,4), %eax
movslq %edx, %rcx
movl (%r14,%rcx,4), %edx
movl %edx, (%r14,%r12,4)
movl %eax, (%r14,%rcx,4)
incq %r12
cmpq %r12, %r15
jne 0x2724
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/keithnoguchi[P]pearls-in-action/0xb/isort2.c
// Function: isort2
void isort2(int x[], unsigned int nr)
{
	unsigned int i, j;

	for (i = 1; i < nr; i++)
		for (j = i; j && x[j-1] > x[j]; j--) {
			/* see how much we can get from swap() call */
			int tmp = x[j-1];
			x[j-1] = x[j];
			x[j] = tmp;
		}
}

// Assembly:
cmpl $0x2, %esi
jb 0x294f
movl $0x1, %eax
xorl %ecx, %ecx
movl %eax, %edx
movl (%rdi,%rdx,4), %edx
movq %rcx, %r8
movl %r8d, %r9d
movl (%rdi,%r9,4), %r10d
cmpl %edx, %r10d
jle 0x2946
movl %edx, (%rdi,%r9,4)
movl %r10d, 0x4(%rdi,%r8,4)
decq %r8
cmpl $-0x1, %r8d
jne 0x2928
incl %eax
incq %rcx
cmpl %esi, %eax
jne 0x2920
retq
// File: /workspace/github_c_makefile_star2_O3/keithnoguchi[P]pearls-in-action/0xb/isort3.c
// Function: isort3
void isort3(int x[], unsigned int nr)
{
	unsigned int i, j;

	for (i = 1; i < nr; i++) {
		int tmp = x[i];
		for (j = i; j && x[j-1] > tmp; j--)
			x[j] = x[j-1];
		x[j] = tmp;
	}
}

// Assembly:
cmpl $0x2, %esi
jb 0x2d81
movl %esi, %eax
movl $0x1, %ecx
movl (%rdi,%rcx,4), %edx
movq %rcx, %rsi
leaq -0x1(%rsi), %r8
movl %r8d, %r9d
movl (%rdi,%r9,4), %r9d
cmpl %edx, %r9d
jle 0x2d74
movl %r9d, (%rdi,%rsi,4)
movq %r8, %rsi
testl %r8d, %r8d
jne 0x2d56
xorl %esi, %esi
movl %esi, %esi
movl %edx, (%rdi,%rsi,4)
incq %rcx
cmpq %rax, %rcx
jne 0x2d50
retq
nop
// File: /workspace/github_c_makefile_star2_O3/keithnoguchi[P]pearls-in-action/0xb/qsort1.c
// Function: _qsort
static void __qsort(int x[], unsigned int l, unsigned int u)
{
	unsigned int m;
	int i;

	if (u-l <= 1)
		return;
	m = l;
	for (i = l+1; i < u; i++)
		if (x[i] < x[l])
			swap(x, ++m, i);
	swap(x, l, m);
	__qsort(x, l, m);
	__qsort(x, m+1, u);
}

// Assembly:
movl %edx, %eax
subl %esi, %eax
cmpl $0x2, %eax
jb 0x31fa
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
leal 0x1(%rsi), %ebp
movl %esi, %eax
cmpl %ebx, %ebp
jae 0x31ce
movl %ebp, %ecx
leaq (%r14,%rcx,4), %rcx
movl %esi, %edx
movslq %ebp, %rdi
movl (%r14,%rdi,4), %edi
cmpl (%r14,%rax,4), %edi
jge 0x31bd
incl %edx
movl (%r14,%rdx,4), %edi
movl (%rcx), %r8d
movl %r8d, (%r14,%rdx,4)
movl %edi, (%rcx)
incl %ebp
addq $0x4, %rcx
cmpl %ebp, %ebx
jne 0x31a1
leal 0x1(%rdx), %ebp
movl %edx, %ecx
jmp 0x31d3
movq %rax, %rcx
movl %esi, %edx
movl (%r14,%rax,4), %edi
movl (%r14,%rcx,4), %r8d
movl %r8d, (%r14,%rax,4)
movl %edi, (%r14,%rcx,4)
movq %r14, %rdi
callq 0x317e
movl %ebx, %eax
subl %ebp, %eax
movl %ebp, %esi
cmpl $0x1, %eax
ja 0x3190
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/keithnoguchi[P]pearls-in-action/0xb/qsort2.c
// Function: _qsort
static void __qsort(int x[], unsigned int l, unsigned int u)
{
	unsigned int i, m;

	if (u-l <= 1)
		return;

	m = l;
	for (i = l+1; i < u; i++)
		if (x[i] < x[l]) {
			/* see how much faster than swap() */
			int tmp = x[++m]; x[m] = x[i]; x[i] = tmp;
		}
	swap(x, l, m);
	__qsort(x, l, m);
	__qsort(x, m+1, u);
}

// Assembly:
movl %edx, %eax
subl %esi, %eax
cmpl $0x2, %eax
jb 0x3689
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
leal -0x1(%rbx), %ebp
leal 0x1(%rsi), %r15d
movl %esi, %eax
cmpl %ebx, %r15d
jae 0x3655
movl %r15d, %ecx
leaq (%r14,%rcx,4), %rcx
movl %ebp, %edi
subl %esi, %edi
xorl %r8d, %r8d
movl %esi, %edx
movl (%rcx,%r8,4), %r9d
cmpl (%r14,%rax,4), %r9d
jge 0x3645
incl %edx
movl (%r14,%rdx,4), %r10d
movl %r9d, (%r14,%rdx,4)
movl %r10d, (%rcx,%r8,4)
incq %r8
cmpl %r8d, %edi
jne 0x362d
leal 0x1(%rdx), %r15d
movl %edx, %ecx
jmp 0x365a
movq %rax, %rcx
movl %esi, %edx
movl (%r14,%rax,4), %edi
movl (%r14,%rcx,4), %r8d
movl %r8d, (%r14,%rax,4)
movl %edi, (%r14,%rcx,4)
movq %r14, %rdi
callq 0x35f6
movl %ebx, %eax
subl %r15d, %eax
movl %r15d, %esi
cmpl $0x1, %eax
ja 0x3612
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/keithnoguchi[P]pearls-in-action/0xb/qsort2_test.c
// Function: generate_identical_array
static void init_array(int x[], int nr, int v)
{
	int i;

	for (i = 0; i < nr; i++) {
		if (v)
			x[i] = v;
		else
			x[i] = i;
	}
}

// Assembly:
testl %esi, %esi
jle 0x39d4
movl %esi, %eax
addl $0x3, %esi
decq %rax
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl $0x2, %esi
shlq $0x4, %rsi
movdqa 0x1775(%rip), %xmm1     # 0x5070
movdqa 0x173d(%rip), %xmm2     # 0x5040
xorl %eax, %eax
movdqa 0x1743(%rip), %xmm3     # 0x5050
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x1763(%rip), %xmm5     # 0x5080
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %ecx
notl %ecx
testb $0x1, %cl
je 0x3958
movl $0x1, (%rdi,%rax)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %ecx
testb $0x1, %cl
je 0x396e
movl $0x1, 0x4(%rdi,%rax)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %ecx
testb $0x1, %cl
je 0x39ad
movl $0x1, 0x8(%rdi,%rax)
pextrw $0x4, %xmm6, %ecx
testb $0x1, %cl
je 0x39bf
movl $0x1, 0xc(%rdi,%rax)
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0x10, %rax
cmpq %rax, %rsi
jne 0x391d
retq
// File: /workspace/github_c_makefile_star2_O3/keithnoguchi[P]pearls-in-action/0xb/qsort3.c
// Function: _qsort
static void __qsort(int x[], unsigned int l, unsigned int u)
{
	unsigned int i, m;

	if (u-l <= 1)
		return;

	/* pick the random pivot */
	swap(x, l, l+rand()%(u-l));
	m = l;
	for (i = l+1; i < u; i++)
		if (x[i] < x[l]) {
			int tmp = x[++m]; x[m] = x[i]; x[i] = tmp;
		}
	swap(x, l, m);
	__qsort(x, l, m);
	__qsort(x, m+1, u);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r13d
subl %esi, %r13d
cmpl $0x2, %r13d
jb 0x3b62
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
leal -0x1(%rbx), %ebp
callq 0x2090
xorl %edx, %edx
divl %r13d
addl %r15d, %edx
movl %r15d, %eax
movl (%r14,%rax,4), %ecx
movl (%r14,%rdx,4), %esi
movl %esi, (%r14,%rax,4)
movl %ecx, (%r14,%rdx,4)
leal 0x1(%r15), %r12d
cmpl %ebx, %r12d
jae 0x3b2e
movl %r12d, %ecx
leaq (%r14,%rcx,4), %rcx
movl %ebp, %esi
subl %r15d, %esi
xorl %edi, %edi
movl %r15d, %edx
movl (%rcx,%rdi,4), %r8d
cmpl (%r14,%rax,4), %r8d
jge 0x3b1f
incl %edx
movl (%r14,%rdx,4), %r9d
movl %r8d, (%r14,%rdx,4)
movl %r9d, (%rcx,%rdi,4)
incq %rdi
cmpl %edi, %esi
jne 0x3b07
movl %edx, %ecx
leal 0x1(%rdx), %r12d
jmp 0x3b34
movq %rax, %rcx
movl %r15d, %edx
movl (%r14,%rax,4), %esi
movl (%r14,%rcx,4), %edi
movl %edi, (%r14,%rax,4)
movl %esi, (%r14,%rcx,4)
movq %r14, %rdi
movl %r15d, %esi
callq 0x3aa7
movl %ebx, %r13d
subl %r12d, %r13d
movl %r12d, %r15d
cmpl $0x1, %r13d
ja 0x3acd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/keithnoguchi[P]pearls-in-action/0xb/qsort4.c
// Function: _qsort
static void __qsort(int x[], unsigned int l, unsigned int u)
{
	int i, j;

	if (u-l <= 1)
		return;

	i = l+1, j = u-1;
	while (1) {
		while (i < u && x[i] < x[l]) i++;
		while (j > l && x[j] > x[l]) j--;
		if (i >= j) break;
		swap(x, i++, j--);
	}
	swap(x, l, j);
	__qsort(x, l, j);
	__qsort(x, j+1, u);
}

// Assembly:
movl %edx, %eax
subl %esi, %eax
cmpl $0x2, %eax
jb 0x4019
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movl %esi, %eax
movl %esi, %ecx
movl %ebx, %edx
leal 0x1(%rcx), %edi
cmpl %edi, %ebx
cmoval %ebx, %edi
leal -0x1(%rdi), %r8d
cmpl %ecx, %r8d
je 0x3fac
incl %ecx
movslq %ecx, %r9
movl (%r14,%r9,4), %r9d
cmpl (%r14,%rax,4), %r9d
jl 0x3f96
jmp 0x3fae
movl %edi, %ecx
leal -0x1(%rdx), %edi
cmpl %edi, %esi
cmovbl %esi, %edi
leal 0x1(%rdi), %ebp
decl %edx
cmpl %esi, %edx
jbe 0x3fd1
movslq %edx, %r8
movl (%r14,%r8,4), %r8d
cmpl (%r14,%rax,4), %r8d
jg 0x3fb9
leal 0x1(%rdx), %ebp
jmp 0x3fd3
movl %edi, %edx
movl %edx, %edi
cmpl %edx, %ecx
jge 0x3fee
movl %ecx, %r8d
movl (%r14,%r8,4), %r9d
movl (%r14,%rdi,4), %r10d
movl %r10d, (%r14,%r8,4)
movl %r9d, (%r14,%rdi,4)
jmp 0x3f8a
movl (%r14,%rax,4), %ecx
movl (%r14,%rdi,4), %r8d
movl %r8d, (%r14,%rax,4)
movl %ecx, (%r14,%rdi,4)
movq %r14, %rdi
callq 0x3f6e
movl %ebx, %eax
subl %ebp, %eax
movl %ebp, %esi
cmpl $0x1, %eax
ja 0x3f84
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/keithnoguchi[P]pearls-in-action/0xb/qsort6.c
// Function: _qsort
static void __qsort(int x[], unsigned int l, unsigned int u)
{
	int i, j;

	if (u-l <= 1)
		return;

	/* pick the random pivot */
	swap(x, l, l+rand()%(u-l));
	i = l+1, j = u-1;
	while (1) {
		int tmp;
		while (i < u && x[i] < x[l]) i++;
		while (j > l && x[j] > x[l]) j--;
		if (i >= j) break;
		tmp = x[i];
		x[i++] = x[j];
		x[j--] = tmp;
	}
	swap(x, l, j);
	__qsort(x, l, j);
	__qsort(x, j+1, u);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
subl %esi, %r12d
cmpl $0x2, %r12d
jb 0x49ac
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x2090
xorl %edx, %edx
divl %r12d
movl %edx, %eax
addl %ebp, %eax
movl %ebp, %ecx
leaq (%r14,%rcx,4), %rcx
movq %rcx, %rdi
movl %ebx, %edx
movl %ebp, %esi
movl (%rdi), %r8d
movl (%r14,%rax,4), %r9d
movl %r9d, (%rdi)
movl %r8d, (%r14,%rax,4)
leal 0x1(%rsi), %eax
cmpl %eax, %ebx
cmoval %ebx, %eax
leal -0x1(%rax), %edi
cmpl %esi, %edi
je 0x494a
incl %esi
movslq %esi, %r8
movl (%r14,%r8,4), %r8d
cmpl (%rcx), %r8d
jl 0x4936
jmp 0x494c
movl %eax, %esi
leal -0x1(%rdx), %eax
cmpl %eax, %ebp
cmovbl %ebp, %eax
leal 0x1(%rax), %r15d
decl %edx
cmpl %ebp, %edx
jbe 0x496f
movslq %edx, %rdi
movl (%r14,%rdi,4), %edi
cmpl (%rcx), %edi
jg 0x4958
leal 0x1(%rdx), %r15d
jmp 0x4971
movl %eax, %edx
cmpl %edx, %esi
jge 0x4981
movslq %esi, %rax
leaq (%r14,%rax,4), %rdi
movslq %edx, %rax
jmp 0x491d
movl (%rcx), %eax
movl %edx, %esi
movl (%r14,%rsi,4), %edi
movl %edi, (%rcx)
movl %eax, (%r14,%rsi,4)
movq %r14, %rdi
movl %ebp, %esi
callq 0x48e3
movl %ebx, %r12d
subl %r15d, %r12d
movl %r15d, %ebp
cmpl $0x1, %r12d
ja 0x4902
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/sbp[P]tweetnacl-tools/tweetnacl-verify.c
// Function: main
int main(int argc, char *argv[]) {
    if (argc != 4) error(2,
        "Usage: tweetnacl-verify sign.pub message.signed message.txt");

    // This will also erroneously fail if the file "-" exists
    if (file_exists(argv[3])) errorf(1, "File <%s> exists", argv[3]);

    unsigned char public_key[crypto_sign_PUBLICKEYBYTES];
    read_key(argv[1], public_key, crypto_sign_PUBLICKEYBYTES);

    Content c = read_file(argv[2]);
    unsigned char *m = malloc(c.size);
    // printf("%zu\n", c.size);
    unsigned long long msize;
    int result = crypto_sign_open(m, &msize, c.bytes, c.size, public_key);
    free(c.bytes);
    // printf("%i\n", result);
    if (result == -1) error(1, "Signature failed verification");

    if (strcmp(argv[3], "-") != 0) {
        FILE *out = create_file(argv[3]);
        fwrite(m, msize, 1, out);
        fclose(out);
    } else {
        fwrite(m, msize, 1, stdout);
    }

    free(m);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
cmpl $0x4, %edi
je 0x39af
leaq 0xefb(%rip), %rsi       # 0x48a0
movl $0x2, %edi
callq 0x1318
movq 0x18(%rbx), %rdi
callq 0x146c
testl %eax, %eax
je 0x39d1
movq 0x18(%rbx), %rdx
leaq 0xf15(%rip), %rsi       # 0x48dc
movl $0x1, %edi
callq 0x1360
movq 0x8(%rbx), %rdi
leaq 0x10(%rsp), %r15
movq %r15, %rsi
movl $0x20, %edx
callq 0x1480
movq 0x10(%rbx), %rdi
callq 0x14de
movq %rax, %r12
movq %rdx, %r13
movq %rax, %rdi
callq 0x10d0
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x3032
movl %eax, %ebp
movq %r13, %rdi
callq 0x1030
cmpl $-0x1, %ebp
jne 0x3a37
leaq 0xec0(%rip), %rsi       # 0x48ed
movl $0x1, %edi
callq 0x1318
movq 0x18(%rbx), %rdi
cmpb $0x2d, (%rdi)
jne 0x3a46
cmpb $0x0, 0x1(%rdi)
je 0x3a84
callq 0x1430
movq %rax, %rbx
movq 0x8(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x1150
movq %rbx, %rdi
callq 0x1050
movq %r14, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rsi
movq 0x3548(%rip), %rax      # 0x6fd8
movq (%rax), %rcx
movl $0x1, %edx
movq %r14, %rdi
callq 0x1150
jmp 0x3a6b
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: PrintHeader
static void PrintHeader(FILE *fp)
    {
	fprintf (fp, "______________________________________________________________________\n\n");
    fprintf (fp,"Cell coalescent simulation - %s", PROGRAM_NAME);
    fprintf (fp,"  %s", VERSION_NUMBER);
    fprintf (fp,"\n(c) 2016-2022 David Posada - dposada@uvigo.es");
	fprintf (fp, "\n______________________________________________________________________\n\n");
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x1398b(%rip), %rdi     # 0x26d4d
movl $0x48, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x22b0
leaq 0x13914(%rip), %rsi     # 0x26cef
leaq 0x10922(%rip), %rdx     # 0x23d04
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21c0
leaq 0x13c98(%rip), %rsi     # 0x2708b
leaq 0x13915(%rip), %rdx     # 0x26d0f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21c0
leaq 0x13912(%rip), %rdi     # 0x26d1d
movl $0x2e, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x22b0
leaq 0x13928(%rip), %rdi     # 0x26d4c
movl $0x49, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
jmp 0x22b0
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: MakeTreeNonClock
void MakeTreeNonClock (TreeNode *p, long int *seed)
    {
    if (p != NULL)
        {
        p->branchLength *=  RandomGamma (alphaBranches, seed) / alphaBranches;
        MakeTreeNonClock (p->left, seed);
        MakeTreeNonClock (p->right, seed);
        }
    }

// Assembly:
testq %rdi, %rdi
je 0x13c57
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x22750(%rip), %xmm0    # 0x36370
movq %rbx, %rdi
callq 0x169ab
divsd 0x22740(%rip), %xmm0    # 0x36370
mulsd 0x40(%r14), %xmm0
movsd %xmm0, 0x40(%r14)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x13c09
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x13c18
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: SumBranches
double SumBranches (TreeNode *p)
   {
	double totalSum, leftSum, rightSum;
	totalSum = leftSum = rightSum = 0;
	
	if (p == NULL)
	   return 0;
	else
		{
		leftSum  = SumBranches(p->left);
		rightSum = SumBranches(p->right);
		totalSum =  p->branchLength + leftSum + rightSum;
		return totalSum;
		}
   }

// Assembly:
testq %rdi, %rdi
je 0x13c95
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x13c58
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
callq 0x13c58
movsd 0x8(%rsp), %xmm1
addsd 0x40(%rbx), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: ChooseTrinucMutation
int ChooseTrinucMutation (double ***prob, long int *seed)
	{
	int		i, j = 0, k = 0;
	double	ran, cumProb;
	
	cumProb = 0;
	ran = RandomUniform(seed);
	for (i=0; i<4; i++)
		for (j=0; j<6; j++)
			for (k=0; k<4; k++)
				{
				cumProb += prob[i][j][k];
				if (ran <= cumProb)
					break;
				}
	return trimut(i,j,k);
	}

// Assembly:
movq (%rsi), %rcx
movabsq $0x41a705af1fe3fb79, %rdx # imm = 0x41A705AF1FE3FB79
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $0x1f31d, %rdx, %rax    # imm = 0x1F31D
subq %rax, %rcx
imulq $0x41a7, %rcx, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rcx     # imm = 0xF4EC
leaq (%rcx,%rax), %rdx
testq %rdx, %rdx
leaq 0x7fffffff(%rcx,%rax), %rax
cmovgq %rdx, %rax
movq %rax, (%rsi)
cvtsi2sd %rax, %xmm0
divsd 0xc8e5(%rip), %xmm0     # 0x23120
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
movq (%rdi,%rcx,8), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %r8
xorl %eax, %eax
addsd (%r8,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jae 0x16869
incq %rax
cmpq $0x4, %rax
jne 0x1684d
movl $0x7c, %eax
jmp 0x1686c
addl $0x78, %eax
incq %rsi
cmpq $0x6, %rsi
jne 0x16847
incq %rcx
cmpq $0x4, %rcx
jne 0x16841
retq
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: RandomExponential
double RandomExponential (double lambda, long int *seed)
	{
		
    double 	exponentialNumber, U;
		
    do
		U = RandomUniform (seed);
	while (U == 0);
		
    exponentialNumber = -log (U) / lambda;
		
    return exponentialNumber;
	}

// Assembly:
pushq %rax
movsd %xmm0, (%rsp)
movq (%rdi), %rcx
movabsq $0x41a705af1fe3fb79, %rsi # imm = 0x41A705AF1FE3FB79
movsd 0xc886(%rip), %xmm1     # 0x23120
xorpd %xmm2, %xmm2
movq %rcx, %rax
imulq %rsi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $0x1f31d, %rdx, %rax    # imm = 0x1F31D
subq %rax, %rcx
imulq $0x41a7, %rcx, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rcx     # imm = 0xF4EC
leaq (%rcx,%rax), %rdx
testq %rdx, %rdx
leaq 0x7fffffff(%rcx,%rax), %rcx
cmovgq %rdx, %rcx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
divsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jne 0x168f1
jnp 0x1689e
movq %rcx, (%rdi)
callq 0x2160
xorpd 0xc73f(%rip), %xmm0     # 0x23040
divsd (%rsp), %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: RelabelNodes
void RelabelNodes (TreeNode *p)
    {
    if (p != NULL)
        {
        RelabelNodes (p->left);
        RelabelNodes (p->right);
        if (p->left == NULL && p->right == NULL && p->isHealthyTip == NO) /* is cell tip */
            p->label = p->index;
        else if (p->left == NULL && p->right == NULL && p->isHealthyTip == YES) /* is outgroup tip */
                p->label = tipLabel++;
        else
            p->label = intLabel++; /* is internal */
        }
    }

// Assembly:
testq %rdi, %rdi
je 0x16942
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x16908
movq 0x8(%rbx), %rdi
callq 0x16908
cmpq $0x0, (%rbx)
jne 0x1692f
cmpq $0x0, 0x8(%rbx)
je 0x16943
movl 0x20e17(%rip), %eax     # 0x3774c
leal 0x1(%rax), %ecx
movl %ecx, 0x20e0e(%rip)     # 0x3774c
movl %eax, 0x1c(%rbx)
popq %rbx
retq
movl 0x20(%rbx), %eax
cmpl $0x1, %eax
je 0x16954
testl %eax, %eax
jne 0x1692f
movl 0x18(%rbx), %eax
jmp 0x1693e
movl 0x20dee(%rip), %eax     # 0x37748
leal 0x1(%rax), %ecx
movl %ecx, 0x20de5(%rip)     # 0x37748
jmp 0x1693e
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: RelabelUserTree
void RelabelUserTree (TreeNode *p)
	{
    if (p != NULL)
        {
		RelabelUserTree (p->left);
		RelabelUserTree (p->right);
		if (p->left == NULL && p->right == NULL)
			p->index = TipNodeNum++;
		else
			p->index = IntNodeNum++;
		p->label = p->index;
		}
	}

// Assembly:
testq %rdi, %rdi
je 0x169a1
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x16965
movq 0x8(%rbx), %rdi
callq 0x16965
cmpq $0x0, (%rbx)
jne 0x1698c
cmpq $0x0, 0x8(%rbx)
je 0x169a2
leaq 0x20dd1(%rip), %rax     # 0x37764
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movl %ecx, 0x18(%rbx)
movl %ecx, 0x1c(%rbx)
popq %rbx
retq
leaq 0x20db7(%rip), %rax     # 0x37760
jmp 0x16993
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: BranchRateSwitch
void BranchRateSwitch (TreeNode *p, float multiplier, int *numTips, long int *seed)
	{
	if (p != NULL)
		{
		p->branchLength *= multiplier;
		if (p->left == NULL && p->right == NULL)
			{
			(*numTips)++;
			char *concat;
			concat = (char *) calloc(20, sizeof(char));
			sprintf (concat, "%d ", p->label+1);
			strcat (treeRateInfo, concat);
			free (concat);
			}
		BranchRateSwitch (p->left, multiplier, numTips, seed);
		BranchRateSwitch (p->right, multiplier, numTips, seed);
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movss %xmm0, 0xc(%rsp)
testq %rdi, %rdi
je 0x16fe8
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0xc89d(%rip), %r15      # 0x23808
movsd 0x40(%r14), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x40(%r14)
movq (%r14), %rdi
testq %rdi, %rdi
jne 0x16fd1
cmpq $0x0, 0x8(%r14)
je 0x16f90
xorl %edi, %edi
jmp 0x16fd1
incl (%rbx)
movl $0x14, %edi
movl $0x1, %esi
callq 0x21a0
movq %rax, %r12
movl 0x1c(%r14), %edx
incl %edx
movq %rax, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2290
movq 0x205d2(%rip), %rdi     # 0x37590
movq %r12, %rsi
callq 0x2280
movq %r12, %rdi
callq 0x2030
movq (%r14), %rdi
movss 0xc(%rsp), %xmm0
movq %rbx, %rsi
callq 0x16f35
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x16f6b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: WhichNucChar
int WhichNucChar (char nucleotide)
    {
    if (nucleotide == 'A')
        return (A);
    else if (nucleotide == 'C')
        return (C);
    else if (nucleotide == 'G')
        return (G);
    else if (nucleotide == 'T')
        return (T);
    else if (nucleotide == '?')
        return (ADO);
    else if (nucleotide == '-')
        return (DELETION);
    else
        {
 		fprintf (stderr, "\nERROR in WhicNucChar: nucleotide = %c\n",  nucleotide);
		exit(-1);
        }
    }

// Assembly:
leal -0x3f(%rdi), %eax
cmpl $0x8, %eax
ja 0x17012
leaq 0xc4d5(%rip), %rcx      # 0x234d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x9, %eax
retq
cmpl $0x2d, %edi
je 0x17031
cmpl $0x54, %edi
jne 0x17037
movl $0x3, %eax
retq
xorl %eax, %eax
retq
movl $0x1, %eax
retq
movl $0x2, %eax
retq
movl $0x7, %eax
retq
pushq %rax
movzbl %dil, %edi
callq 0x5450
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: ChooseUniformState
int ChooseUniformState (double *prob, long int *seed)
	{
	int			chosenState;
	double		ran, cumProb;
	
	chosenState = 0;
	cumProb = prob[chosenState];
	ran = RandomUniform(seed);

	while (ran > cumProb)
		cumProb += prob[++chosenState];
	
	return chosenState;
	}

// Assembly:
movsd (%rdi), %xmm0
movq (%rsi), %rcx
movabsq $0x41a705af1fe3fb79, %rdx # imm = 0x41A705AF1FE3FB79
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $0x1f31d, %rdx, %rax    # imm = 0x1F31D
subq %rax, %rcx
imulq $0x41a7, %rcx, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rcx     # imm = 0xF4EC
leaq (%rcx,%rax), %rdx
testq %rdx, %rdx
leaq 0x7fffffff(%rcx,%rax), %rax
cmovgq %rdx, %rax
cvtsi2sd %rax, %xmm1
divsd 0xc082(%rip), %xmm1     # 0x23120
movq %rax, (%rsi)
xorl %eax, %eax
ucomisd %xmm0, %xmm1
jbe 0x170ba
xorl %eax, %eax
addsd 0x8(%rdi,%rax,8), %xmm0
incq %rax
ucomisd %xmm0, %xmm1
ja 0x170ab
retq
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: RandomBinomial
int RandomBinomial (double prob, int numTrials, long int *seed)
	{
	int i, sum;
	sum = 0;
	
	for(i=0; i<numTrials; i++)
		{
		if(RandomUniform(seed) < prob)
			sum++;
		}
	return sum;
	}

// Assembly:
testl %edi, %edi
jle 0x176e6
movq (%rsi), %r8
xorl %ecx, %ecx
movabsq $0x41a705af1fe3fb79, %r9 # imm = 0x41A705AF1FE3FB79
movsd 0xba99(%rip), %xmm1     # 0x23120
movq %r8, %rax
imulq %r9
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $0x1f31d, %rdx, %rax    # imm = 0x1F31D
subq %rax, %r8
imulq $0x41a7, %r8, %rax      # imm = 0x41A7
imulq $-0xb14, %rdx, %rdx     # imm = 0xF4EC
leaq (%rdx,%rax), %r10
testq %r10, %r10
leaq 0x7fffffff(%rdx,%rax), %r8
cmovgq %r10, %r8
xorps %xmm2, %xmm2
cvtsi2sd %r8, %xmm2
divsd %xmm1, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm0
seta %al
addl %eax, %ecx
decl %edi
jne 0x17687
movq %r8, (%rsi)
jmp 0x176e8
xorl %ecx, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: RandomBetaMeanVar
double RandomBetaMeanVar (double mean, double var, long int *seed)
	{
	double sample_size, shape1, shape2, gamma1, gamma2, randBeta;
	
	/* assuming variance < mean (1-mean) */
	sample_size = (mean * (1.0 - mean) / var) - 1.0;
	
	shape1 = mean * sample_size;
	shape2 = (1.0 - mean) * sample_size;
	
	gamma1 = RandomGamma(shape1, seed);
	gamma2 = RandomGamma(shape2, seed);
	randBeta = gamma1 / (gamma1 + gamma2);
	
	return randBeta;
	}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0xa769(%rip), %xmm2     # 0x23100
subsd %xmm0, %xmm2
movapd %xmm2, %xmm3
mulsd %xmm0, %xmm3
divsd %xmm1, %xmm3
addsd 0xa791(%rip), %xmm3     # 0x23140
mulsd %xmm3, %xmm0
mulsd %xmm2, %xmm3
movsd %xmm3, 0x8(%rsp)
callq 0x169ab
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
callq 0x169ab
movsd (%rsp), %xmm1
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: RandomNegativeBinomial
int RandomNegativeBinomial (double mean, double dispersion, long int *seed)
	{
	int		poissonRand;
	double	gammaRand;
	
	/* the RandomGamma function here has mean 1, so we need to scale it ourselves */
	gammaRand = mean/dispersion * RandomGamma (dispersion, seed);
	poissonRand = RandomPoisson (gammaRand, seed);
		
	return poissonRand;
	}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x169ab
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x1687f
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incl %ebp
movsd 0x8e1e(%rip), %xmm1     # 0x23100
ucomisd %xmm0, %xmm1
jae 0x1a2ae
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: WriteTree
void WriteTree (TreeNode *p, FILE *fp)
    {
    if (p != NULL)
        {
        if(p->isHealthyTip == YES)
            {
           // fprintf (fp, "healthycell:%8.6f",p->branchLength);
			fprintf (fp, "%s:%8.6f",outCellName, p->branchLength);
			}
        else if (p->left == NULL && p->right == NULL)
            {
			if (doUserTree == NO)
				//fprintf (fp, "tumcell%04d:%8.6f", Index(p),p->branchLength);
				fprintf (fp, "%s%04d:%8.6f", inCellName, Index(p),p->branchLength);
			else
				fprintf (fp, "%s:%8.6f", p->name,p->branchLength);
            }
        else
            {
            fprintf (fp, "(");
            WriteTree (p->left, fp);
            fprintf (fp, ",");
            WriteTree (p->right, fp);
            if (p->anc !=NULL)
				{
				fprintf (fp, "):%8.6f",p->branchLength);
				//TODO: anotate tree?
				/*if (p->rateSwitch > 0)
					fprintf (fp, "[&rate_switch=%e]",p->rateSwitch);*/
				}
            }
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a3fc
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, 0x20(%rdi)
jne 0x1a399
movsd 0x40(%r14), %xmm0
leaq 0xc54b(%rip), %rsi      # 0x268cc
leaq 0x1c3c8(%rip), %rdx     # 0x36750
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21c0
cmpq $0x0, (%r14)
jne 0x1a3a6
cmpq $0x0, 0x8(%r14)
je 0x1a404
movl $0x28, %edi
movq %rbx, %rsi
callq 0x2180
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1a35b
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x2180
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x1a35b
cmpq $0x0, 0x10(%r14)
je 0x1a3fc
movsd 0x40(%r14), %xmm0
leaq 0xc4f7(%rip), %rsi      # 0x268e2
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpb $0x0, 0x1bf79(%rip)     # 0x36384
je 0x1a423
movq 0x58(%r14), %rdx
movsd 0x40(%r14), %xmm0
leaq 0xc4ae(%rip), %rsi      # 0x268cc
jmp 0x1a388
movl 0x18(%r14), %ecx
incl %ecx
movsd 0x40(%r14), %xmm0
leaq 0xc49f(%rip), %rsi      # 0x268d5
leaq 0x1c293(%rip), %rdx     # 0x366d0
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21c0
// File: /workspace/github_c_makefile_star2_O3/dapogon[P]cellcoal/src/cellcoal.c
// Function: Unlink_callback
int Unlink_callback(const char *fpath, const struct stat *sb, int typeflag, struct FTW *ftwbuf)
	{
    int rv = remove(fpath);

    if (rv)
        perror(fpath);

    return rv;
	}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2060
movl %eax, %ebp
testl %eax, %eax
jne 0x1a4b6
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x2250
jmp 0x1a4ad