LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-main.c
// Function: do_param_cksum
static void do_param_cksum(struct bunny_traceitem* t) {
  MD5_CTX ctx;
  _u8  res[16];

  MD5_Init(&ctx);
  MD5_Update(&ctx,t->param_range,sizeof(_u64) * t->param_count);
  MD5_Final((char*)res,&ctx);

  t->param_cksum = *(_u64*)res;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x64(%rbp), %rdi
callq 0x2160
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, %edx
shlq $0x3, %rdx
leaq -0x64(%rbp), %rdi
callq 0x2390
leaq -0x80(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x2260
movq -0x80(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq 0x6fb7(%rip), %rdi      # 0x122d0
movq -0x8(%rbp), %rsi
callq 0x22a0
cmpl $0x0, %eax
je 0xb330
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xb335
jmp 0xb478
movq -0x8(%rbp), %rdi
callq 0x2300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb3f6
jmp 0xb34f
jmp 0xb351
movq -0x8(%rbp), %rsi
leaq 0x4d5c(%rip), %rdi      # 0x100b8
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0x6f6d(%rip)      # 0x122d8
je 0xb386
movq 0x6f64(%rip), %rdi      # 0x122d8
movq -0x8(%rbp), %rdx
leaq 0x4d39(%rip), %rsi      # 0x100b8
movb $0x0, %al
callq 0x22d0
jmp 0xb388
jmp 0xb38a
leaq 0x2e20(%rip), %rdi      # 0xe1b1
leaq 0x5286(%rip), %rsi      # 0x1061e
leaq 0x2e22(%rip), %rdx      # 0xe1c1
movl $0x33b, %ecx            # imm = 0x33B
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0x6f25(%rip)      # 0x122d8
je 0xb3de
movq 0x6f1c(%rip), %rdi      # 0x122d8
leaq 0x2dee(%rip), %rsi      # 0xe1b1
leaq 0x5254(%rip), %rdx      # 0x1061e
leaq 0x2df0(%rip), %rcx      # 0xe1c1
movl $0x33b, %r8d            # imm = 0x33B
movb $0x0, %al
callq 0x22d0
jmp 0xb3e0
leaq 0x3bc9(%rip), %rdi      # 0xefb0
callq 0x2190
movl $0x1, %edi
callq 0x2250
jmp 0xb3f8
movq -0x18(%rbp), %rdi
callq 0x2320
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xb435
movq -0x20(%rbp), %rax
movsbl 0x13(%rax), %eax
cmpl $0x2e, %eax
jne 0xb41a
jmp 0xb3f8
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x13, %rsi
callq 0x7010
movq %rax, %rdi
callq 0x2110
jmp 0xb3f8
movq -0x18(%rbp), %rdi
callq 0x2340
cmpb $0x0, -0x9(%rbp)
je 0xb478
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x2210
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20e0
cmpq $0x0, -0x28(%rbp)
je 0xb476
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x20e0
jmp 0xb478
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-main.c
// Function: sure_read
static _s32 sure_read(_s32 fd, void* buf, _u32 len) {
  _u32 total = 0;

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

  return total;
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x22e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0xbe8b
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xbebc
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xbe69
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-main.c
// Function: lookup_exec
static struct bunny_traceitem* lookup_exec(_u64 cksum) {
  _u32 pos = cksum & 0xFFF;
  _u32 i;

  for (i=0;i<known_exec[pos].c;i++)
    if (known_exec[pos].v[i] == cksum) 
      return (struct bunny_traceitem*)known_exti[pos].v[i];
  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0xfff, %rax            # imm = 0xFFF
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
leaq 0x64d5(%rip), %rcx      # 0x123d0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jae 0xbf5a
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x64bd(%rip), %rax      # 0x123d0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0xbf4d
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x1649a(%rip), %rax     # 0x223d0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xbf62
jmp 0xbf4f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbeec
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/./range.h
// Function: RANGE64
static inline _u64 RANGE64(_s32 num) {
  _u32 i = 30;

  if (!num) return (1LL << 31);

  if (num < 0) {
    if (num == -0x80000000) return (1LL << 0);
      while (--i && !((-num) & (1 << i)));
    return (1LL << (31 - i));
  }

  if (num == 0x7FFFFFFF) return (1LL << 62);
  while (--i && !(num & (1 << i)));
  return (1LL << (32 + i));

  /* Bit 63 is not used / reserved for RANGE64_VOLATILE */

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl $0x1e, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xbf92
movl $0x80000000, %eax       # imm = 0x80000000
movq %rax, -0x8(%rbp)
jmp 0xc071
cmpl $0x0, -0xc(%rbp)
jge 0xc006
cmpl $0x80000000, -0xc(%rbp) # imm = 0x80000000
jne 0xbfae
movq $0x1, -0x8(%rbp)
jmp 0xc071
jmp 0xbfb0
movl -0x10(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0xbfe1
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xbfea
jmp 0xbfec
jmp 0xbfb0
movl $0x1f, %eax
subl -0x10(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x8(%rbp)
jmp 0xc071
cmpl $0x7fffffff, -0xc(%rbp) # imm = 0x7FFFFFFF
jne 0xc01f
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, -0x8(%rbp)
jmp 0xc071
jmp 0xc021
movl -0x10(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
je 0xc050
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0xc059
jmp 0xc05b
jmp 0xc021
movl -0x10(%rbp), %eax
addl $0x20, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/./range.h
// Function: RANGE8
static inline _u64 RANGE8(_s32 num) {

  if (num < 0) return (1LL << 0);
  if (!num) return (1LL << 1);
  if (num < 128) return (1LL << 2);
  if (num < 256) return (1LL << 3);
  if (num < 32768) return (1LL << 4);
  if (num < 65536) return (1LL << 5);
  return (1LL << 6);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0xc097
movq $0x1, -0x8(%rbp)
jmp 0xc0fb
cmpl $0x0, -0xc(%rbp)
jne 0xc0a7
movq $0x2, -0x8(%rbp)
jmp 0xc0fb
cmpl $0x80, -0xc(%rbp)
jge 0xc0ba
movq $0x4, -0x8(%rbp)
jmp 0xc0fb
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0xc0cd
movq $0x8, -0x8(%rbp)
jmp 0xc0fb
cmpl $0x8000, -0xc(%rbp)     # imm = 0x8000
jge 0xc0e0
movq $0x10, -0x8(%rbp)
jmp 0xc0fb
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jge 0xc0f3
movq $0x20, -0x8(%rbp)
jmp 0xc0fb
movq $0x40, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x24d1
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
je 0x249e
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
setg %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x24a7
jmp 0x24c4
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
movl -0x14(%rbp), %edx
callq 0x24e0
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2474
jmp 0x24c6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2466
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x28e0
xorl %eax, %eax
movl %eax, %edi
callq 0x2070
movl %eax, %edi
callq 0x2050
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jge 0x2744
callq 0x2080
cltd
idivl -0xc(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x2930
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2704
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0xb/isort1_test.c
// Function: is_sorted
static bool is_sorted(const int x[], int nr)
{
	int i;
	for (i = 1; i < nr; i++)
		if (x[i-1] > x[i])
			return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x285a
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x284d
movb $0x0, -0x1(%rbp)
jmp 0x285e
jmp 0x284f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2822
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0xb/isort1_test.c
// Function: dump_array
static void dump_array(const int x[], int nr)
{
	int i;

	for (i = 0; i < nr; i++) {
		if (!(i&0x7))
			printf("\n"); /* every eight entries */
		printf("%7d ", x[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x28cb
movl -0x10(%rbp), %eax
andl $0x7, %eax
cmpl $0x0, %eax
jne 0x28a7
leaq 0x3777(%rip), %rdi      # 0x6017
movb $0x0, %al
callq 0x2040
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x38ba(%rip), %rdi      # 0x6173
movb $0x0, %al
callq 0x2040
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2886
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0xb/isort1_test.c
// Function: init_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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x292e
cmpl $0x0, -0x10(%rbp)
je 0x2913
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2921
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2923
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x28f5
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x2a2a
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x19(%rbp)
je 0x29ce
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
setg %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x29d7
jmp 0x2a1a
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x29a4
jmp 0x2a1c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2992
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x2f28
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x19(%rbp)
je 0x2ee0
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
setg %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2ee9
jmp 0x2f0d
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2ebd
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2ea2
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
cmpl $0x1, %eax
ja 0x33e2
jmp 0x3462
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x3432
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
jge 0x3425
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movl -0x18(%rbp), %edx
callq 0x3470
jmp 0x3427
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x33f1
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x3470
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x33c0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x33c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
cmpl $0x1, %eax
ja 0x3962
jmp 0x3a02
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x39d2
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
jge 0x39c5
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x39c7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3971
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3a10
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3940
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x3940
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
cmpl $0x1, %eax
ja 0x3f12
jmp 0x3fe8
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
callq 0x2080
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x10(%rbp), %ecx
subl -0xc(%rbp), %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %eax
movl -0x20(%rbp), %edx
addl %eax, %edx
callq 0x3ff0
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x3fb8
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
jge 0x3fab
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x3fad
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3f57
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3ff0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3ef0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x3ef0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
cmpl $0x1, %eax
ja 0x44e2
jmp 0x45ce
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x44f6
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl -0x10(%rbp), %ecx
movb %al, -0x19(%rbp)
jae 0x451e
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x4527
jmp 0x4532
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x44f6
jmp 0x4534
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x1a(%rbp)
jbe 0x455c
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
setg %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x4565
jmp 0x4570
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4534
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x457a
jmp 0x459e
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %edx
movl %edx, %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
callq 0x45e0
jmp 0x44f4
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x45e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x44c0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x44c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
cmpl $0x1, %eax
ja 0x50f2
jmp 0x523b
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
callq 0x2080
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x10(%rbp), %ecx
subl -0xc(%rbp), %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %eax
movl -0x20(%rbp), %edx
addl %eax, %edx
callq 0x5250
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x513c
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl -0x10(%rbp), %ecx
movb %al, -0x31(%rbp)
jae 0x5164
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x516d
jmp 0x5178
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x513c
jmp 0x517a
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x32(%rbp)
jbe 0x51a2
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
cmpl (%rcx,%rdx,4), %eax
setg %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x51ab
jmp 0x51b6
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x517a
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x51c0
jmp 0x520b
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $-0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x513a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x5250
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x50d0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x50d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/joltikeq80112v13/ref/joltik.c
// Function: set_block_number_in_tweak
static void set_block_number_in_tweak(uint8_t *tweak, const uint64_t block_no) {
    tweak[ 6] = ((block_no >> 56ULL) & 0x0f);
    tweak[ 7] = ((block_no >> 48ULL) & 0xff);
    tweak[ 8] = ((block_no >> 40ULL) & 0xff);
    tweak[ 9] = ((block_no >> 32ULL) & 0xff);
    tweak[10] = ((block_no >> 24ULL) & 0xff);
    tweak[11] = ((block_no >> 16ULL) & 0xff);
    tweak[12] = ((block_no >>  8ULL) & 0xff);
    tweak[13] = ((block_no >>  0ULL) & 0xff);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
shrq $0x38, %rax
andq $0xf, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rsp), %rax
shrq $0x30, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x7(%rax)
movq -0x10(%rsp), %rax
shrq $0x28, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x8(%rax)
movq -0x10(%rsp), %rax
shrq $0x20, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x9(%rax)
movq -0x10(%rsp), %rax
shrq $0x18, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xa(%rax)
movq -0x10(%rsp), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xb(%rax)
movq -0x10(%rsp), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xc(%rax)
movq -0x10(%rsp), %rax
shrq $0x0, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xd(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Patch/patch.c
// Function: checksig
int checksig(FILE *infile)
{
	char buf[0x100];

	fseek(infile, 0x8FCA0, SEEK_SET);
	fread(buf, 0x20, 1, infile);
	if (strcmp(buf, "\\HEROES\\SOUND\\"))
	{
		fprintf(stderr, "[-] Sig fail\n");
		return 0;
	}
	fseek(infile, 0x8FB40, SEEK_SET);
	fread(buf, 0x20, 1, infile);
	if (strcmp(buf, "\\HEROES\\ANIM\\"))
	{
		fprintf(stderr, "[-] Sig fail\n");
		return 0;
	}
	fseek(infile, 0, SEEK_SET);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x8fca0, %esi          # imm = 0x8FCA0
xorl %edx, %edx
callq 0x1090
leaq -0x110(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x20, %esi
movl $0x1, %edx
callq 0x1040
leaq -0x110(%rbp), %rdi
leaq 0xddd(%rip), %rsi       # 0x2004
callq 0x1060
cmpl $0x0, %eax
je 0x1252
movq 0x2dc0(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xdd1(%rip), %rsi       # 0x2013
movb $0x0, %al
callq 0x1070
movl $0x0, -0x4(%rbp)
jmp 0x12cb
movq -0x10(%rbp), %rdi
movl $0x8fb40, %esi          # imm = 0x8FB40
xorl %edx, %edx
callq 0x1090
leaq -0x110(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x20, %esi
movl $0x1, %edx
callq 0x1040
leaq -0x110(%rbp), %rdi
leaq 0xd97(%rip), %rsi       # 0x2021
callq 0x1060
cmpl $0x0, %eax
je 0x12b5
movq 0x2d5d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd6e(%rip), %rsi       # 0x2013
movb $0x0, %al
callq 0x1070
movl $0x0, -0x4(%rbp)
jmp 0x12cb
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1090
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Patch/patch.c
// Function: copyfile
void copyfile(FILE *infile, FILE *outfile)
{
	int numr, numw;
	char buffer[100];

	while (feof(infile) == 0)
	{
		if ((numr = fread(buffer, 1, 100, infile)) != 100)
		{
			if (ferror(infile) != 0)
			{
				fprintf(stderr, "[-] Read file error.\n");
				exit(EXIT_FAILURE);
			}
		}
		if ((numw = fwrite(buffer, 1, numr, outfile)) != numr)
		{
			fprintf(stderr, "[-] Write file error.\n");
			exit(EXIT_FAILURE);
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1080
cmpl $0x0, %eax
jne 0x139b
leaq -0x80(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x1, %esi
movl $0x64, %edx
callq 0x1040
movl %eax, -0x14(%rbp)
cmpl $0x64, %eax
je 0x1356
movq -0x8(%rbp), %rdi
callq 0x1030
cmpl $0x0, %eax
je 0x1354
movq 0x2cbf(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xcec(%rip), %rsi       # 0x202f
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x10c0
jmp 0x1356
leaq -0x80(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x10d0
movl %eax, -0x18(%rbp)
cmpl -0x14(%rbp), %eax
je 0x1396
movq 0x2c7d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xcc0(%rip), %rsi       # 0x2045
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x10c0
jmp 0x12f3
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Patch/patch.c
// Function: patch
void patch(FILE *patchfile, FILE *outfile)
{
	unsigned char CallPatchFunc[] = {0xE8, 0xD7, 0xAF, 0x03, 0x00};
	unsigned char JmpRest[] = {0xEB, 0x25};

	fseek(outfile, 0x8A4A0, SEEK_SET);
	copyfile(patchfile, outfile);
	fseek(outfile, 0x4F4C4, SEEK_SET);
	if (fwrite(CallPatchFunc, 1, sizeof (CallPatchFunc), outfile) != sizeof (CallPatchFunc))
	{
		fprintf(stderr, "[-] Write file error.\n");
		exit(EXIT_FAILURE);
	}
	if (fwrite(JmpRest, 1, sizeof (JmpRest), outfile) != sizeof (JmpRest))
	{
		fprintf(stderr, "[-] Write file error.\n");
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0xc96(%rip), %eax       # 0x205c
movl %eax, -0x15(%rbp)
movb 0xc91(%rip), %al        # 0x2060
movb %al, -0x11(%rbp)
movw 0xc88(%rip), %ax        # 0x2061
movw %ax, -0x17(%rbp)
movq -0x10(%rbp), %rdi
movl $0x8a4a0, %esi          # imm = 0x8A4A0
xorl %edx, %edx
callq 0x1090
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12e0
movq -0x10(%rbp), %rdi
movl $0x4f4c4, %esi          # imm = 0x4F4C4
xorl %edx, %edx
callq 0x1090
leaq -0x15(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x5, %edx
callq 0x10d0
cmpq $0x5, %rax
je 0x1449
movq 0x2bca(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xc0d(%rip), %rsi       # 0x2045
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x10c0
leaq -0x17(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x2, %edx
callq 0x10d0
cmpq $0x2, %rax
je 0x1488
movq 0x2b8b(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xbce(%rip), %rsi       # 0x2045
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x10c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/w4kfu[P]HommI/Patch/main.c
// Function: main
int main(int argc, char *argv[])
{
        char *s = NULL;
        FILE *infile;
        FILE *patchfile;
        FILE *outfile;

        if (argc != 4)
        {
                fprintf(stderr, "%s <HEROES.EXE> <PATCH.BIN> <OUTPUT.EXE>\n", argv[0]);
                return EXIT_FAILURE;
        }
        if ((s = argv[1], (infile  = fopen(s, "rb")) == NULL)
         || (s = argv[2], (patchfile = fopen(s, "rb")) == NULL)
         || (s = argv[3], (outfile = fopen(s, "wb")) == NULL))
        {
                perror("fopen()");
                return EXIT_FAILURE;
        }
        if (checksig(infile))
        {
                copyfile(infile, outfile);
                patch(patchfile, outfile);
        }
        fclose(infile);
        fclose(patchfile);
        fclose(outfile);
        return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x4, -0x8(%rbp)
je 0x14df
movq 0x2b3d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xb97(%rip), %rsi       # 0x2063
movb $0x0, %al
callq 0x1070
movl $0x1, -0x4(%rbp)
jmp 0x15b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xb97(%rip), %rsi       # 0x208d
callq 0x10a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1551
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xb71(%rip), %rsi       # 0x208d
callq 0x10a0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1551
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xb4e(%rip), %rsi       # 0x2090
callq 0x10a0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x1566
leaq 0xb3b(%rip), %rdi       # 0x2093
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x15b0
movq -0x20(%rbp), %rdi
callq 0x11e0
cmpl $0x0, %eax
je 0x158e
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x12e0
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x13b0
movq -0x20(%rbp), %rdi
callq 0x1050
movq -0x28(%rbp), %rdi
callq 0x1050
movq -0x30(%rbp), %rdi
callq 0x1050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_kfunc.c
// Function: test_fisher
void test_fisher(int n11, int n12, int n21, int n22,
                 double eleft, double eright, double etwo, double eprob)
{
    double prob, left, right, two;
    prob = kt_fisher_exact(n11, n12, n21, n22, &left, &right, &two);
    if (differ(left, eleft)) fail("LEFT", left, eleft, n11, n12, n21, n22);
    if (differ(right, eright)) fail("RIGHT", right, eright, n11, n12, n21, n22);
    if (differ(two, etwo)) fail("TWO-TAIL", two, etwo, n11, n12, n21, n22);
    if (differ(prob, eprob)) fail("RESULT", prob, eprob, n11, n12, n21, n22);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
leaq -0x40(%rbp), %r8
leaq -0x48(%rbp), %r9
leaq -0x50(%rbp), %rax
movq %rax, (%rsp)
callq 0x2420
movsd %xmm0, -0x38(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x1170
cmpl $0x0, %eax
je 0x12a5
movsd -0x40(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
leaq 0x1e16(%rip), %rdi      # 0x30b6
callq 0x11b0
movsd -0x48(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x1170
cmpl $0x0, %eax
je 0x12dc
movsd -0x48(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
leaq 0x1de4(%rip), %rdi      # 0x30bb
callq 0x11b0
movsd -0x50(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x1170
cmpl $0x0, %eax
je 0x1313
movsd -0x50(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
leaq 0x1db3(%rip), %rdi      # 0x30c1
callq 0x11b0
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
callq 0x1170
cmpl $0x0, %eax
je 0x134a
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
leaq 0x1d85(%rip), %rdi      # 0x30ca
callq 0x11b0
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/kfunc.c
// Function: kf_gammap
static double _kf_gammap(double s, double z)
{
	double sum, x;
	int k;
	for (k = 1, sum = x = 1.; k < 100; ++k) {
		sum += (x *= z / (s + k));
		if (x / sum < KF_GAMMA_EPS) break;
	}
	return exp(s * log(z) - z - kf_lgamma(s + 1.) + log(sum));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movl $0x1, -0x24(%rbp)
movsd 0x132f(%rip), %xmm0     # 0x3010
movsd %xmm0, -0x20(%rbp)
movsd 0x1322(%rip), %xmm0     # 0x3010
movsd %xmm0, -0x18(%rbp)
cmpl $0x64, -0x24(%rbp)
jge 0x1d4b
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
cvtsi2sdl -0x24(%rbp), %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm1
divsd -0x18(%rbp), %xmm1
movsd 0x14ea(%rip), %xmm0     # 0x3220
ucomisd %xmm1, %xmm0
jbe 0x1d3e
jmp 0x1d4b
jmp 0x1d40
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1cf3
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x1040
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x1278(%rip), %xmm0     # 0x3010
addsd -0x8(%rbp), %xmm0
callq 0x16b0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x1040
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
callq 0x1060
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/kfunc.c
// Function: kf_gammaq
static double _kf_gammaq(double s, double z)
{
	int j;
	double C, D, f;
	f = 1. + z - s; C = f; D = 0.;
	// Modified Lentz's algorithm for computing continued fraction
	// See Numerical Recipes in C, 2nd edition, section 5.2
	for (j = 1; j < 100; ++j) {
		double a = j * (s - j), b = (j<<1) + 1 + z - s, d;
		D = b + a * D;
		if (D < KF_TINY) D = KF_TINY;
		C = b + a / C;
		if (C < KF_TINY) C = KF_TINY;
		D = 1. / D;
		d = C * D;
		f *= d;
		if (fabs(d - 1.) < KF_GAMMA_EPS) break;
	}
	return exp(s * log(z) - z - kf_lgamma(s) - log(f));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd 0x1216(%rip), %xmm0     # 0x3010
addsd -0x10(%rbp), %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0x1f3b
cvtsi2sdl -0x14(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
cvtsi2sdl -0x14(%rbp), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x14(%rbp), %eax
shll %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
addsd -0x10(%rbp), %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x13a1(%rip), %xmm0     # 0x3228
ucomisd -0x28(%rbp), %xmm0
jbe 0x1e9b
movsd 0x1392(%rip), %xmm0     # 0x3228
movsd %xmm0, -0x28(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
divsd -0x20(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x136d(%rip), %xmm0     # 0x3228
ucomisd -0x20(%rbp), %xmm0
jbe 0x1ecf
movsd 0x135e(%rip), %xmm0     # 0x3228
movsd %xmm0, -0x20(%rbp)
movsd 0x1139(%rip), %xmm0     # 0x3010
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x48(%rbp), %xmm1
movsd 0x1104(%rip), %xmm0     # 0x3010
subsd %xmm0, %xmm1
movaps 0x1169(%rip), %xmm0     # 0x3080
pand %xmm0, %xmm1
movsd 0x12fd(%rip), %xmm0     # 0x3220
ucomisd %xmm1, %xmm0
jbe 0x1f2b
jmp 0x1f3b
jmp 0x1f2d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1e22
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x1040
movaps %xmm0, %xmm2
movsd -0x60(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x16b0
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x1040
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
subsd %xmm1, %xmm0
callq 0x1060
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
je 0x509d
movl $0x2, %edi
leaq 0x1878(%rip), %rsi      # 0x6910
callq 0x1310
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x14d0
cmpl $0x0, %eax
je 0x50c8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movl $0x1, %edi
leaq 0x1889(%rip), %rsi      # 0x694c
callq 0x1370
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x30(%rbp), %rsi
movl $0x20, %edx
callq 0x1510
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1580
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rdi
callq 0x10b0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x50(%rbp), %rsi
callq 0x44e0
movl %eax, -0x54(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1030
cmpl $-0x1, -0x54(%rbp)
jne 0x513c
movl $0x1, %edi
leaq 0x1826(%rip), %rsi      # 0x695d
callq 0x1310
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x1830(%rip), %rsi      # 0x697b
callq 0x1080
cmpl $0x0, %eax
je 0x5187
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1470
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rcx
movl $0x1, %edx
callq 0x1130
movq -0x60(%rbp), %rdi
callq 0x1050
jmp 0x51a3
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq 0x3e42(%rip), %rax      # 0x8fd8
movq (%rax), %rcx
movl $0x1, %edx
callq 0x1130
movq -0x48(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/tst/address.c
// Function: main
int main() {
    address_t address = AddressFromHex40("123456789a123456789a123456789a123456789a");
    address_t equal = AddressFromHex42("0x123456789a123456789a123456789a123456789a");
    assert(AddressEqual(&address, &equal));
    assert(address.address[0] == 0x12);
    assert(address.address[9] == 0x9a);
    assert(address.address[10] == 0x12);
    assert(address.address[19] == 0x9a);
    uint256_t stacked;
    AddressToUint256(&stacked, &address);
    address_t unstacked = AddressFromUint256(&stacked);
    assert(AddressEqual(&address, &unstacked));

    address_t precompile = AddressFromHex42("0x0000000000000000000000000000000000000001");
    assert(AddressToPrecompile(precompile) == ECRECOVER);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
leaq 0x3e99(%rip), %rsi      # 0x5006
callq 0x1320
leaq -0x2c(%rbp), %rdi
leaq 0x3e87(%rip), %rsi      # 0x5004
addq $0x2, %rsi
callq 0x1320
leaq -0x18(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x1380
cmpl $0x0, %eax
je 0x119a
jmp 0x11b9
leaq 0x3e8e(%rip), %rdi      # 0x502f
leaq 0x3ea6(%rip), %rsi      # 0x504e
movl $0x8, %edx
leaq 0x3ea8(%rip), %rcx      # 0x505c
callq 0x1030
movzbl -0x18(%rbp), %eax
cmpl $0x12, %eax
jne 0x11c4
jmp 0x11e3
leaq 0x3e9c(%rip), %rdi      # 0x5067
leaq 0x3e7c(%rip), %rsi      # 0x504e
movl $0x9, %edx
leaq 0x3e7e(%rip), %rcx      # 0x505c
callq 0x1030
movzbl -0xf(%rbp), %eax
cmpl $0x9a, %eax
jne 0x11f0
jmp 0x120f
leaq 0x3e8b(%rip), %rdi      # 0x5082
leaq 0x3e50(%rip), %rsi      # 0x504e
movl $0xa, %edx
leaq 0x3e52(%rip), %rcx      # 0x505c
callq 0x1030
movzbl -0xe(%rbp), %eax
cmpl $0x12, %eax
jne 0x121a
jmp 0x1239
leaq 0x3e7c(%rip), %rdi      # 0x509d
leaq 0x3e26(%rip), %rsi      # 0x504e
movl $0xb, %edx
leaq 0x3e28(%rip), %rcx      # 0x505c
callq 0x1030
movzbl -0x5(%rbp), %eax
cmpl $0x9a, %eax
jne 0x1246
jmp 0x1265
leaq 0x3e6c(%rip), %rdi      # 0x50b9
leaq 0x3dfa(%rip), %rsi      # 0x504e
movl $0xc, %edx
leaq 0x3dfc(%rip), %rcx      # 0x505c
callq 0x1030
leaq -0x4c(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x13e0
leaq -0x60(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x1530
leaq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1380
cmpl $0x0, %eax
je 0x1293
jmp 0x12b2
leaq 0x3e3b(%rip), %rdi      # 0x50d5
leaq 0x3dad(%rip), %rsi      # 0x504e
movl $0x10, %edx
leaq 0x3daf(%rip), %rcx      # 0x505c
callq 0x1030
leaq -0x78(%rbp), %rdi
leaq 0x3e3b(%rip), %rsi      # 0x50f8
addq $0x2, %rsi
callq 0x1320
leaq -0x78(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x1630
cmpl $0x1, %eax
jne 0x12ed
jmp 0x130c
leaq 0x3e2f(%rip), %rdi      # 0x5123
leaq 0x3d53(%rip), %rsi      # 0x504e
movl $0x13, %edx
leaq 0x3d55(%rip), %rcx      # 0x505c
callq 0x1030
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x38a0b(%rip), %rsi     # 0x42e52
movb $0x0, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x3899b(%rip), %rsi     # 0x42df4
leaq 0x3568b(%rip), %rdx     # 0x3faeb
movb $0x0, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x38d1e(%rip), %rsi     # 0x43190
leaq 0x3899b(%rip), %rdx     # 0x42e14
movb $0x0, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x38997(%rip), %rsi     # 0x42e22
movb $0x0, %al
callq 0x21b0
movq -0x8(%rbp), %rdi
leaq 0x389b4(%rip), %rsi     # 0x42e51
movb $0x0, %al
callq 0x21b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)