LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/chrispanag[P]operating-systems-scheduler/sigchld-example.c
// Function: child
void child(void)
{
	pid_t pid = getpid();

	for (;;) {
		printf("I am child %ld, sleeping for %d sec...\n",
			(long)pid, SLEEP_SEC);
		sleep(SLEEP_SEC);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1040
movslq %eax, %rbx
leaq 0xc35(%rip), %r14       # 0x2004
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
xorl %eax, %eax
callq 0x1070
movl $0x1, %edi
callq 0x1130
jmp 0x13cf
// File: /workspace/github_c_makefile_star2_O1/chrispanag[P]operating-systems-scheduler/sigchld-example.c
// Function: sigchld_handler
void sigchld_handler(int signum)
{
	pid_t p;
	int status;

	if (signum != SIGCHLD) {
		fprintf(stderr, "Internal error: Called for signum %d, not SIGCHLD\n",
			signum);
		exit(1);
	}

	/*
	 * Something has happened to one of the children.
	 * We use waitpid() with the WUNTRACED flag, instead of wait(), because
	 * SIGCHLD may have been received for a stopped, not dead child.
	 *
	 * A single SIGCHLD may be received if many processes die at the same time.
	 * We use waitpid() with the WNOHANG flag in a loop, to make sure all
	 * children are taken care of before leaving the handler.
	 */

	for (;;) {
		p = waitpid(-1, &status, WUNTRACED | WNOHANG);
		if (p < 0) {
			perror("waitpid");
			exit(1);
		}
		if (p == 0)
			break;

		explain_wait_status(p, status);

		if (WIFEXITED(status) || WIFSIGNALED(status)) {
			/* A child has died */
			printf("Parent: Received SIGCHLD, child is dead. Exiting.\n");
			exit(0);
		}
		if (WIFSTOPPED(status)) {
			/* A child has stopped due to SIGSTOP/SIGTSTP, etc... */
			printf("Parent: Child has been stopped. Moving right along...\n");
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x11, %edi
jne 0x14b8
leaq 0x4(%rsp), %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x3, %edx
callq 0x10f0
testl %eax, %eax
js 0x1498
leaq 0xcc3(%rip), %rbx       # 0x2105
leaq 0x4(%rsp), %r14
testl %eax, %eax
je 0x149d
movl 0x4(%rsp), %esi
movl %eax, %edi
callq 0x157a
movl 0x4(%rsp), %eax
movl %eax, %ecx
andl $0x7f, %ecx
je 0x14a5
shll $0x18, %ecx
addl $0x1000000, %ecx        # imm = 0x1000000
cmpl $0x2000000, %ecx        # imm = 0x2000000
jge 0x14a5
movzbl %al, %eax
cmpl $0x7f, %eax
jne 0x1482
movq %rbx, %rdi
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
movl $0x3, %edx
callq 0x10f0
testl %eax, %eax
jns 0x1447
callq 0x11a6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xc8f(%rip), %rdi       # 0x213b
callq 0x1030
xorl %edi, %edi
callq 0x1120
callq 0x1183
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsp, %rbx
movaps %xmm0, (%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movabsq $0x400000010, %r14      # imm = 0x400000010
movq %r14, (%rbx)
leaq 0x2bdf(%rip), %rdi      # 0x4008
callq 0x1060
movq %rbx, %rdi
callq 0x23e4
movq %rbx, %rdi
callq 0x1509
movq %rbx, %rdi
callq 0x25f3
movl $0xa, %edi
callq 0x1040
leaq 0x2bc9(%rip), %rdi      # 0x4020
callq 0x1060
xorl %ebp, %ebp
movl %ebp, (%rbx)
movq %rbx, %rdi
callq 0x23e4
movq %rbx, %rdi
callq 0x1509
movq %rbx, %rdi
callq 0x25f3
movl $0xa, %edi
callq 0x1040
leaq 0x30(%rsp), %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movq $0x0, 0x30(%rbx)
movq %r14, (%rbx)
leaq 0x2b92(%rip), %rdi      # 0x4039
callq 0x1060
movq %rbx, %rdi
callq 0x2658
movq %rbx, %rdi
callq 0x1573
movq %rbx, %rdi
callq 0x289d
movl $0xa, %edi
callq 0x1040
leaq 0x2b7c(%rip), %rdi      # 0x4051
callq 0x1060
movl %ebp, (%rbx)
movq %rbx, %rdi
callq 0x2658
movq %rbx, %rdi
callq 0x1573
movq %rbx, %rdi
callq 0x289d
movl $0xa, %edi
callq 0x1040
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/tests/stack_queue.c
// Function: test_stack
static void test_stack(struct tt_stack *stack)
{
	for (int i = 0; i < LEN + 1; i++) {
		int t = i + 1;
		tt_stack_push(stack, &t);
	}
	for (int i = 0; i < LEN + 1; i++) {
		int t;
		if (tt_stack_pop(stack, &t) == 0)
			printf("%d ", t);
	}
	printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
leaq 0x4(%rsp), %r14
movl %ebp, 0x4(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rbx)
incl %ebp
cmpl $0x12, %ebp
jne 0x151d
movl $0x11, %ebp
movq %rsp, %r14
leaq 0x2ac4(%rip), %r15      # 0x4004
movq %rbx, %rdi
movq %r14, %rsi
callq *0x28(%rbx)
testl %eax, %eax
jne 0x155a
movl (%rsp), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
decl %ebp
jne 0x1540
movl $0xa, %edi
callq 0x1040
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/tests/stack_queue.c
// Function: test_queue
static void test_queue(struct tt_queue *queue)
{
	int t;
	for (int i = 0; i < LEN + 1; i++) {
		t = i + 1;
		tt_queue_enque(queue, &t);
	}
	for (int i = 0; i < LEN - 1; i++)
		tt_queue_deque(queue, &t);
	for (int i = LEN - 2; i >= 0; i--) {
		t = i + 1;
		tt_queue_enque(queue, &t);
	}

	for (int i = 0; i < LEN + 1; i++) {
		if (tt_queue_deque(queue, &t) == 0)
			printf("%d ", t);
	}
	printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
leaq 0x4(%rsp), %r14
movl %ebp, 0x4(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq *0x28(%rbx)
incl %ebp
cmpl $0x12, %ebp
jne 0x1587
movl $0xf, %ebp
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq *0x30(%rbx)
decl %ebp
jne 0x15a5
movl $0xf, %ebp
leaq 0x4(%rsp), %r14
movl %ebp, 0x4(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq *0x28(%rbx)
decl %ebp
jne 0x15bc
movl $0x11, %ebp
leaq 0x4(%rsp), %r14
leaq 0x2a26(%rip), %r15      # 0x4004
movq %rbx, %rdi
movq %r14, %rsi
callq *0x30(%rbx)
testl %eax, %eax
jne 0x15f9
movl 0x4(%rsp), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
decl %ebp
jne 0x15de
movl $0xa, %edi
callq 0x1040
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %ebx
movl 0x90b8(%rip), %edi      # 0x10234
cmpl $-0x1, %edi
je 0x718b
movl $0xf, %esi
callq 0x22c0
movl 0x90a7(%rip), %edi      # 0x10238
cmpl $-0x1, %edi
je 0x71a0
movl $0xf, %esi
callq 0x22c0
leaq 0x4621(%rip), %rdi      # 0xb7c8
movl %ebx, %esi
xorl %eax, %eax
callq 0x2030
movq 0x90b1(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x71cc
leaq 0x4605(%rip), %rsi      # 0xb7c8
movl %ebx, %edx
xorl %eax, %eax
callq 0x22d0
movq 0x9095(%rip), %rdi      # 0x10268
callq 0x21d0
movl $0x1, %edi
callq 0x2230
// File: /workspace/github_c_makefile_star2_O1/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 0x428d(%rip), %rsi      # 0xb47d
leaq 0x4(%rsp), %rdx
xorl %eax, %eax
callq 0x21c0
cmpl $0x1, %eax
jne 0x722a
testb %bpl, %bpl
setne %cl
movl 0x4(%rsp), %eax
testl %eax, %eax
setne %dl
orb %cl, %dl
je 0x72aa
cmpl $0x5f5e101, %eax        # imm = 0x5F5E101
jae 0x7327
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movzbl %bl, %ebx
leaq 0x45ba(%rip), %rdi      # 0xb7ee
movl %ebx, %esi
xorl %eax, %eax
callq 0x2030
movq 0x9024(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x7259
leaq 0x459e(%rip), %rsi      # 0xb7ee
movl %ebx, %edx
xorl %eax, %eax
callq 0x22d0
leaq 0x3fdd(%rip), %rdi      # 0xb23d
leaq 0x45b3(%rip), %rsi      # 0xb81a
leaq 0x3fdf(%rip), %rdx      # 0xb24d
movl $0x716, %ecx            # imm = 0x716
xorl %eax, %eax
callq 0x2030
movq 0x8fe7(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x73a5
leaq 0x3fac(%rip), %rsi      # 0xb23d
leaq 0x4582(%rip), %rdx      # 0xb81a
leaq 0x3fae(%rip), %rcx      # 0xb24d
movl $0x716, %r8d            # imm = 0x716
jmp 0x739e
movzbl %bl, %ebx
leaq 0x456f(%rip), %rdi      # 0xb823
movl %ebx, %esi
xorl %eax, %eax
callq 0x2030
movq 0x8fa4(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x72d9
leaq 0x4553(%rip), %rsi      # 0xb823
movl %ebx, %edx
xorl %eax, %eax
callq 0x22d0
leaq 0x3f5d(%rip), %rdi      # 0xb23d
leaq 0x4533(%rip), %rsi      # 0xb81a
leaq 0x3f5f(%rip), %rdx      # 0xb24d
movl $0x717, %ecx            # imm = 0x717
xorl %eax, %eax
callq 0x2030
movq 0x8f67(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x73a5
leaq 0x3f2c(%rip), %rsi      # 0xb23d
leaq 0x4502(%rip), %rdx      # 0xb81a
leaq 0x3f2e(%rip), %rcx      # 0xb24d
movl $0x717, %r8d            # imm = 0x717
jmp 0x739e
movzbl %bl, %ebx
leaq 0x4525(%rip), %rdi      # 0xb856
movl %ebx, %esi
xorl %eax, %eax
callq 0x2030
movq 0x8f27(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x7356
leaq 0x4509(%rip), %rsi      # 0xb856
movl %ebx, %edx
xorl %eax, %eax
callq 0x22d0
leaq 0x3ee0(%rip), %rdi      # 0xb23d
leaq 0x44b6(%rip), %rsi      # 0xb81a
leaq 0x3ee2(%rip), %rdx      # 0xb24d
movl $0x719, %ecx            # imm = 0x719
xorl %eax, %eax
callq 0x2030
movq 0x8eea(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x73a5
leaq 0x3eb3(%rip), %rsi      # 0xb23d
leaq 0x4489(%rip), %rdx      # 0xb81a
leaq 0x3eb5(%rip), %rcx      # 0xb24d
movl $0x719, %r8d            # imm = 0x719
xorl %eax, %eax
callq 0x22d0
movl $0x1, %edi
callq 0x2230
// File: /workspace/github_c_makefile_star2_O1/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 0x38d54(%rip), %rdi     # 0x40370
testq %rdi, %rdi
je 0x7626
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, 0x38d23(%rip)     # 0x40370
testq %rax, %rax
je 0x7676
leaq 0x4dae(%rip), %rsi      # 0xc407
movq %rax, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2050
movq 0x38d00(%rip), %rax     # 0x40370
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3f1b(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x8bdd(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x76a6
leaq 0x3f01(%rip), %rdi      # 0xb598
movl $0x24, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x3b90(%rip), %rdi      # 0xb23d
leaq 0x5fff(%rip), %rsi      # 0xd6b3
leaq 0x3b92(%rip), %rdx      # 0xb24d
movl $0x100, %ecx            # imm = 0x100
xorl %eax, %eax
callq 0x2030
movq 0x8b9a(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x76f5
leaq 0x3b63(%rip), %rsi      # 0xb23d
leaq 0x5fd2(%rip), %rdx      # 0xd6b3
leaq 0x3b65(%rip), %rcx      # 0xb24d
movl $0x100, %r8d            # imm = 0x100
xorl %eax, %eax
callq 0x22d0
movl $0x1, %edi
callq 0x2230
// File: /workspace/github_c_makefile_star2_O1/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 0x8993(%rip), %rdi      # 0x10310
testq %rdi, %rdi
je 0x7a09
callq 0x2300
testq %rax, %rax
je 0x7a92
movq %rax, %rbx
movq %rax, %rdi
callq 0x2320
testq %rax, %rax
je 0x79ed
leaq 0x4a5c(%rip), %r14      # 0xc407
movq %rsp, %r15
cmpb $0x2e, 0x13(%rax)
je 0x79e0
addq $0x13, %rax
movq 0x8951(%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 0x7a01
movq %rbx, %rdi
callq 0x2320
testq %rax, %rax
jne 0x79ae
movq %rbx, %rdi
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
jmp 0x2350
movq %rsp, %rdi
callq 0x27d3
leaq 0x4988(%rip), %rdi      # 0xc398
xorl %eax, %eax
callq 0x2030
movq 0x884a(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x7a39
leaq 0x496e(%rip), %rdi      # 0xc398
movl $0x29, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x37fd(%rip), %rdi      # 0xb23d
leaq 0x49c6(%rip), %rsi      # 0xc40d
leaq 0x37ff(%rip), %rdx      # 0xb24d
movl $0x19a, %ecx            # imm = 0x19A
xorl %eax, %eax
callq 0x2030
movq 0x8807(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x7a88
leaq 0x37d0(%rip), %rsi      # 0xb23d
leaq 0x4999(%rip), %rdx      # 0xc40d
leaq 0x37d2(%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_O1/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 0x8a9a
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 0x8a40
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x58(%rbx), %r12
movq (%r12,%r14), %rdi
testq %rdi, %rdi
je 0x8a0e
callq 0x2220
movq 0x8(%r12,%r14), %rdi
testq %rdi, %rdi
je 0x8a1d
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 0x89fc
movq 0x58(%rbx), %rdi
callq 0x2220
movq $0x0, 0x58(%rbx)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x8a5f
callq 0x2220
movq $0x0, 0x60(%rbx)
movl $0x0, 0x68(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x8a7c
callq 0x2220
testb %bpl, %bpl
je 0x8a91
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 0x45ab(%rip), %rdi      # 0xd04c
xorl %eax, %eax
callq 0x2030
movq 0x77b9(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x8aca
leaq 0x4591(%rip), %rdi      # 0xd04c
movl $0x33, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x276c(%rip), %rdi      # 0xb23d
leaq 0x45a8(%rip), %rsi      # 0xd080
leaq 0x276e(%rip), %rdx      # 0xb24d
movl $0x31b, %ecx            # imm = 0x31B
xorl %eax, %eax
callq 0x2030
movq 0x7776(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x8b19
leaq 0x273f(%rip), %rsi      # 0xb23d
leaq 0x457b(%rip), %rdx      # 0xd080
leaq 0x2741(%rip), %rcx      # 0xb24d
movl $0x31b, %r8d            # imm = 0x31B
xorl %eax, %eax
callq 0x22d0
movl $0x1, %edi
callq 0x2230
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %r14
movq %r14, %rdi
callq 0x2150
movq 0x40(%rbx), %rsi
movl 0x28(%rbx), %edx
shlq $0x3, %rdx
movq %r14, %rdi
callq 0x23a0
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2240
movq (%r15), %rax
movq %rax, 0x18(%rbx)
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x636d(%rip), %rdi      # 0x10260
movq %rbx, %rsi
callq 0x22a0
testl %eax, %eax
je 0x9f7a
cmpb $0x0, (%rbx)
je 0x9f7a
movq %rbx, %rdi
callq 0x2300
testq %rax, %rax
je 0x9f7f
movq %rax, %r14
movq %r14, %rdi
callq 0x2320
testq %rax, %rax
je 0x9f40
cmpb $0x2e, 0x13(%rax)
je 0x9f14
addq $0x13, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x760a
movq %rax, %rdi
callq 0x2100
jmp 0x9f14
movq %r14, %rdi
callq 0x2350
testb %bpl, %bpl
je 0x9f7a
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x21f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
testq %r14, %r14
je 0x9f7a
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_O1/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 0x2390
movl $0x1, %eax
movl %eax, %ecx
movl %ecx, %edx
decl %ecx
movl (%rdi,%rcx,4), %r8d
movl (%rdi,%rdx,4), %r9d
cmpl %r9d, %r8d
jle 0x238a
movl %r9d, (%rdi,%rcx,4)
movl %r8d, (%rdi,%rdx,4)
testq %rcx, %rcx
jne 0x236c
incl %eax
cmpl %esi, %eax
jne 0x236a
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x2506
movl %ebx, %eax
xorl %ecx, %ecx
movl %ecx, (%r14,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x24fa
xorl %edi, %edi
callq 0x2080
movl %eax, %edi
callq 0x2070
cmpl $0x2, %ebx
jl 0x2545
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 0x2522
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25d4
movl $0x1, %eax
movl %eax, %ecx
movl %ecx, %edx
decl %ecx
movl (%rdi,%rcx,4), %r8d
movl (%rdi,%rdx,4), %r9d
cmpl %r9d, %r8d
jle 0x25ce
movl %r9d, (%rdi,%rcx,4)
movl %r8d, (%rdi,%rdx,4)
testq %rcx, %rcx
jne 0x25b0
incl %eax
cmpl %esi, %eax
jne 0x25ae
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x2825
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 0x2818
movl %r9d, (%rdi,%rsi,4)
movq %r8, %rsi
testl %r8d, %r8d
jne 0x27fa
xorl %esi, %esi
movl %esi, %esi
movl %edx, (%rdi,%rsi,4)
incq %rcx
cmpq %rax, %rcx
jne 0x27f4
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movl %ebx, %eax
subl %esi, %eax
cmpl $0x2, %eax
jb 0x2ab3
leal 0x1(%rsi), %ecx
movl %esi, %eax
movl %esi, %r15d
cmpl %ebx, %ecx
jae 0x2a8d
movl %ecx, %edx
leaq (%r14,%rdx,4), %rdx
movl %esi, %r15d
movslq %ecx, %rdi
movl (%r14,%rdi,4), %edi
cmpl (%r14,%rax,4), %edi
jge 0x2a83
incl %r15d
movl (%r14,%r15,4), %edi
movl (%rdx), %r8d
movl %r8d, (%r14,%r15,4)
movl %edi, (%rdx)
incl %ecx
addq $0x4, %rdx
cmpl %ecx, %ebx
jne 0x2a66
movl (%r14,%rax,4), %ecx
movl %r15d, %edx
movl (%r14,%rdx,4), %edi
movl %edi, (%r14,%rax,4)
movl %ecx, (%r14,%rdx,4)
movq %r14, %rdi
movl %r15d, %edx
callq 0x2a3e
incl %r15d
movl %r15d, %esi
jmp 0x2a48
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
leal -0x1(%rbx), %ebp
movl %ebx, %eax
subl %esi, %eax
cmpl $0x2, %eax
jb 0x2d4b
leal 0x1(%rsi), %ecx
movl %esi, %eax
movl %esi, %r15d
cmpl %ebx, %ecx
jae 0x2d25
movl %ecx, %ecx
leaq (%r14,%rcx,4), %rcx
movl %ebp, %edx
subl %esi, %edx
xorl %edi, %edi
movl %esi, %r15d
movl (%rcx,%rdi,4), %r8d
cmpl (%r14,%rax,4), %r8d
jge 0x2d1e
incl %r15d
movl (%r14,%r15,4), %r9d
movl %r8d, (%r14,%r15,4)
movl %r9d, (%rcx,%rdi,4)
incq %rdi
cmpl %edi, %edx
jne 0x2d05
movl (%r14,%rax,4), %ecx
movl %r15d, %edx
movl (%r14,%rdx,4), %edi
movl %edi, (%r14,%rax,4)
movl %ecx, (%r14,%rdx,4)
movq %r14, %rdi
movl %r15d, %edx
callq 0x2cd2
incl %r15d
movl %r15d, %esi
jmp 0x2ce1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/keithnoguchi[P]pearls-in-action/0xb/qsort2_test.c
// Function: generate_sorted_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 0x2f66
movl %esi, %eax
xorl %ecx, %ecx
movl %ecx, (%rdi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x2f5b
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
leal -0x1(%rbx), %ebp
movl %ebx, %r12d
subl %r15d, %r12d
cmpl $0x2, %r12d
jb 0x3038
callq 0x2090
xorl %edx, %edx
divl %r12d
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), %ecx
movl %r15d, %r12d
cmpl %ebx, %ecx
jae 0x300c
movl %ecx, %ecx
leaq (%r14,%rcx,4), %rcx
movl %ebp, %edx
subl %r15d, %edx
xorl %esi, %esi
movl %r15d, %r12d
movl (%rcx,%rsi,4), %edi
cmpl (%r14,%rax,4), %edi
jge 0x3005
incl %r12d
movl (%r14,%r12,4), %r8d
movl %edi, (%r14,%r12,4)
movl %r8d, (%rcx,%rsi,4)
incq %rsi
cmpl %esi, %edx
jne 0x2fed
movl (%r14,%rax,4), %ecx
movl %r12d, %edx
movl (%r14,%rdx,4), %esi
movl %esi, (%r14,%rax,4)
movl %ecx, (%r14,%rdx,4)
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x2f8f
incl %r12d
movl %r12d, %r15d
jmp 0x2fa2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movl %ebx, %eax
subl %esi, %eax
cmpl $0x2, %eax
jb 0x32f5
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 0x3298
incl %ecx
movslq %ecx, %r9
movl (%r14,%r9,4), %r9d
cmpl (%r14,%rax,4), %r9d
jl 0x3282
jmp 0x329a
movl %edi, %ecx
leal -0x1(%rdx), %edi
cmpl %edi, %esi
cmovbl %esi, %edi
leal 0x1(%rdi), %ebp
decl %edx
cmpl %esi, %edx
jbe 0x32bd
movslq %edx, %r8
movl (%r14,%r8,4), %r8d
cmpl (%r14,%rax,4), %r8d
jg 0x32a5
leal 0x1(%rdx), %ebp
jmp 0x32bf
movl %edi, %edx
movl %edx, %edi
movl (%r14,%rdi,4), %r8d
cmpl %edx, %ecx
jge 0x32da
movl %ecx, %r9d
movl (%r14,%r9,4), %r10d
movl %r8d, (%r14,%r9,4)
movl %r10d, (%r14,%rdi,4)
jmp 0x3276
movl (%r14,%rax,4), %ecx
movl %r8d, (%r14,%rax,4)
movl %ecx, (%r14,%rdi,4)
movq %r14, %rdi
callq 0x325a
movl %ebp, %esi
jmp 0x3263
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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, %ebx
movl %esi, %r15d
movq %rdi, %r14
leal -0x1(%rbx), %r12d
movl %ebx, %ebp
subl %r15d, %ebp
cmpl $0x2, %ebp
jb 0x38eb
callq 0x2090
xorl %edx, %edx
divl %ebp
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), %ecx
movl %r12d, %ebp
cmpl %ebx, %ecx
jae 0x3872
movl (%r14,%rax,4), %edx
movslq %ecx, %rsi
leaq (%r14,%rsi,4), %rsi
cmpl %edx, (%rsi)
jge 0x3872
incl %ecx
addq $0x4, %rsi
cmpl %ebx, %ecx
jb 0x3862
movl %ebx, %ecx
cmpl %r15d, %ebp
jbe 0x3896
movl (%r14,%rax,4), %edx
movslq %ebp, %rsi
leaq (%r14,%rsi,4), %rsi
cmpl %edx, (%rsi)
jle 0x3896
decl %ebp
addq $-0x4, %rsi
cmpl %r15d, %ebp
ja 0x3882
movl %r15d, %edx
jmp 0x3898
movl %ebp, %edx
movl %edx, %ebp
movl %ecx, %esi
cmpl %edx, %ecx
jge 0x38bc
movslq %ecx, %rdi
movl (%r14,%rdi,4), %r8d
movslq %edx, %r9
movl (%r14,%r9,4), %r10d
leal 0x1(%rcx), %esi
movl %r10d, (%r14,%rdi,4)
leal -0x1(%rdx), %ebp
movl %r8d, (%r14,%r9,4)
cmpl %edx, %ecx
movl %esi, %ecx
jl 0x3853
movl (%r14,%rax,4), %ecx
movl %ebp, %edx
movl (%r14,%rdx,4), %esi
movl %esi, (%r14,%rax,4)
movl %ecx, (%r14,%rdx,4)
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x380b
incl %ebp
movl %ebp, %r15d
jmp 0x381f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %r14
movabsq $0x5c53454f5245485c, %r12 # imm = 0x5C53454F5245485C
xorl %ebx, %ebx
movl $0x8fca0, %esi          # imm = 0x8FCA0
xorl %edx, %edx
callq 0x1080
movq %rsp, %r15
movl $0x20, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x1040
movq (%r15), %rax
xorq %r12, %rax
movabsq $0x5c444e554f535c, %rcx # imm = 0x5C444E554F535C
xorq 0x7(%r15), %rcx
orq %rax, %rcx
jne 0x1377
xorl %ebx, %ebx
movl $0x8fb40, %esi          # imm = 0x8FB40
movq %r14, %rdi
xorl %edx, %edx
callq 0x1080
movq %rsp, %r15
movl $0x20, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x1040
xorq (%r15), %r12
movabsq $0x5c4d494e415c53, %rax # imm = 0x5C4D494E415C53
xorq 0x6(%r15), %rax
orq %r12, %rax
jne 0x137e
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1080
movl $0x1, %ebx
movl %ebx, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x10e0
jmp 0x1366
callq 0x10fc
jmp 0x1366
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r14, %rdi
callq 0x1070
testl %eax, %eax
jne 0x13ec
movl $0x1, %esi
movl $0x64, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x1040
movq %rax, %r12
cmpl $0x64, %r12d
je 0x13cf
movq %r14, %rdi
callq 0x1030
testl %eax, %eax
jne 0x13f8
movslq %r12d, %rdx
movl $0x1, %esi
movq %r15, %rdi
movq %rbx, %rcx
callq 0x10c0
cmpl %r12d, %eax
je 0x1399
callq 0x113d
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1118
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movb $0x0, 0x4(%r15)
movl $0x3afd7e8, (%r15)      # imm = 0x3AFD7E8
movw $0x25eb, 0x6(%rsp)      # imm = 0x25EB
movl $0x8a4a0, %esi          # imm = 0x8A4A0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1080
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1385
movl $0x4f4c4, %esi          # imm = 0x4F4C4
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1080
movl $0x1, %esi
movl $0x5, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x10c0
cmpq $0x5, %rax
jne 0x148f
leaq 0x6(%rsp), %rdi
movl $0x1, %esi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x10c0
cmpq $0x2, %rax
jne 0x1494
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x1162
callq 0x1187
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
cmpl $0x4, %edi
jne 0x1541
movq 0x8(%r15), %rdi
leaq 0xbd3(%rip), %rsi       # 0x208b
callq 0x1090
testq %rax, %rax
je 0x1533
movq %rax, %rbx
movq 0x10(%r15), %rdi
leaq 0xbbb(%rip), %rsi       # 0x208b
callq 0x1090
testq %rax, %rax
je 0x1533
movq %rax, %r14
movq 0x18(%r15), %rdi
leaq 0xba6(%rip), %rsi       # 0x208e
callq 0x1090
testq %rax, %rax
je 0x1533
movq %rax, %r15
movq %rbx, %rdi
callq 0x12bc
testl %eax, %eax
je 0x1517
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1385
movq %r14, %rdi
movq %r15, %rsi
callq 0x13fd
movq %rbx, %rdi
callq 0x1050
movq %r14, %rdi
callq 0x1050
movq %r15, %rdi
callq 0x1050
xorl %eax, %eax
jmp 0x154e
leaq 0xb57(%rip), %rdi       # 0x2091
callq 0x10a0
jmp 0x1549
movq %r15, %rdi
callq 0x11ac
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
leaq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %r12
leaq 0x30(%rsp), %r9
movq %r12, %r8
callq 0x1eb6
movsd 0x8(%rsp), %xmm1
movsd (%r12), %xmm4
movapd %xmm4, %xmm2
subsd %xmm1, %xmm2
andpd 0x1db5(%rip), %xmm2     # 0x3010
movapd %xmm0, %xmm3
ucomisd 0x1db9(%rip), %xmm2     # 0x3020
ja 0x12f2
movsd 0x30(%rsp), %xmm0
movapd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm2
subsd %xmm2, %xmm1
andpd 0x1d87(%rip), %xmm1     # 0x3010
ucomisd 0x1d8f(%rip), %xmm1     # 0x3020
ja 0x133c
movsd 0x28(%rsp), %xmm0
movapd %xmm0, %xmm2
movsd 0x18(%rsp), %xmm1
subsd %xmm1, %xmm2
andpd 0x1d5d(%rip), %xmm2     # 0x3010
ucomisd 0x1d65(%rip), %xmm2     # 0x3020
ja 0x1386
movapd %xmm3, %xmm0
movsd 0x20(%rsp), %xmm1
subsd %xmm1, %xmm0
andpd 0x1d39(%rip), %xmm0     # 0x3010
ucomisd 0x1d41(%rip), %xmm0     # 0x3020
ja 0x13cc
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3ce7(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1dbb(%rip), %rax      # 0x30be
movq %rax, (%rsp)
leaq 0x1d8a(%rip), %rsi      # 0x3098
movl %r15d, %edx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
movapd %xmm4, %xmm0
movb $0x2, %al
movsd %xmm3, 0x8(%rsp)
callq 0x1050
movsd 0x8(%rsp), %xmm3
incl 0x3d15(%rip)            # 0x504c
jmp 0x126d
movapd %xmm2, %xmm1
movq 0x3c99(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1d72(%rip), %rax      # 0x30c3
movq %rax, (%rsp)
leaq 0x1d3c(%rip), %rsi      # 0x3098
movl %r15d, %edx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
movb $0x2, %al
movsd %xmm3, 0x8(%rsp)
callq 0x1050
movsd 0x8(%rsp), %xmm3
incl 0x3ccb(%rip)            # 0x504c
jmp 0x1297
movq 0x3c53(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1d32(%rip), %rax      # 0x30c9
movq %rax, (%rsp)
leaq 0x1cf6(%rip), %rsi      # 0x3098
movl %r15d, %edx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
movb $0x2, %al
movsd %xmm3, 0x8(%rsp)
callq 0x1050
movsd 0x8(%rsp), %xmm3
incl 0x3c85(%rip)            # 0x504c
jmp 0x12c1
movq 0x3c0d(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1cf5(%rip), %rax      # 0x30d2
movq %rax, (%rsp)
leaq 0x1cb0(%rip), %rsi      # 0x3098
movl %r15d, %edx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
movapd %xmm3, %xmm0
movb $0x2, %al
callq 0x1050
incl 0x3c47(%rip)            # 0x504c
jmp 0x12e5
// File: /workspace/github_c_makefile_star2_O1/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 0x373f
leaq 0x115b(%rip), %rsi      # 0x4890
movl $0x2, %edi
callq 0x1334
movq 0x18(%rbx), %rdi
callq 0x1488
testl %eax, %eax
je 0x3761
movq 0x18(%rbx), %rdx
leaq 0x1175(%rip), %rsi      # 0x48cc
movl $0x1, %edi
callq 0x137c
movq 0x8(%rbx), %rdi
leaq 0x10(%rsp), %r15
movq %r15, %rsi
movl $0x20, %edx
callq 0x149c
movq 0x10(%rbx), %rdi
callq 0x14fa
movq %rax, %r12
movq %rdx, %r13
movq %rax, %rdi
callq 0x10e0
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x2e6b
movl %eax, %ebp
movq %r13, %rdi
callq 0x1030
cmpl $-0x1, %ebp
jne 0x37c7
leaq 0x1120(%rip), %rsi      # 0x48dd
movl $0x1, %edi
callq 0x1334
movq 0x18(%rbx), %rbx
leaq 0x1129(%rip), %rsi      # 0x48fb
movq %rbx, %rdi
callq 0x10a0
testl %eax, %eax
je 0x3808
movq %rbx, %rdi
callq 0x144c
movq %rax, %rbx
movq 0x8(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x1160
movq %rbx, %rdi
callq 0x1050
jmp 0x3824
movq 0x8(%rsp), %rsi
movq 0x37c4(%rip), %rax      # 0x6fd8
movq (%rax), %rcx
movl $0x1, %edx
movq %r14, %rdi
callq 0x1160
movq %r14, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x24a4a(%rip), %rdi     # 0x37c8d
movl $0x48, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x22b0
leaq 0x249d3(%rip), %rsi     # 0x37c2f
leaq 0x219e1(%rip), %rdx     # 0x34c44
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21c0
leaq 0x24d57(%rip), %rsi     # 0x37fcb
leaq 0x249d4(%rip), %rdx     # 0x37c4f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21c0
leaq 0x249d1(%rip), %rdi     # 0x37c5d
movl $0x2e, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x22b0
leaq 0x249e7(%rip), %rdi     # 0x37c8c
movl $0x49, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
jmp 0x22b0
// File: /workspace/github_c_makefile_star2_O1/dapogon[P]cellcoal/src/cellcoal.c
// Function: PrintDate
static void PrintDate (FILE *fp)
    {
    time_t now;
    char *date;
		
    now=time(NULL);
    date= ctime(&now);
    fprintf (fp,"%s",date);
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x21e0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x20f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0x13ace
movsd 0x2e8cf(%rip), %xmm0    # 0x42370
movq %rbx, %rdi
callq 0x166ff
divsd 0x2e8bf(%rip), %xmm0    # 0x42370
mulsd 0x40(%r14), %xmm0
movsd %xmm0, 0x40(%r14)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x13a8a
movq 0x8(%r14), %r14
jmp 0x13a94
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x13b13
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x13ad6
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
callq 0x13ad6
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_O1/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 0x1daa5(%rip), %xmm0    # 0x34028
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 0x165af
incq %rax
cmpq $0x4, %rax
jne 0x16595
movl $0x4, %eax
incq %rsi
cmpq $0x6, %rsi
jne 0x1658f
incq %rcx
cmpq $0x4, %rcx
jne 0x16589
addl $0x78, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1da48(%rip), %xmm1    # 0x34028
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 0x16637
jnp 0x165e4
movq %rcx, (%rdi)
callq 0x2160
xorpd 0x1da79(%rip), %xmm0    # 0x340c0
divsd (%rsp), %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x166b3
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1664e
movq 0x8(%rbx), %rdi
callq 0x1664e
movq (%rbx), %rax
testq %rax, %rax
jne 0x166a0
cmpq $0x0, 0x8(%rbx)
jne 0x1667d
cmpl $0x0, 0x20(%rbx)
je 0x166b4
testq %rax, %rax
jne 0x166a0
cmpq $0x0, 0x8(%rbx)
jne 0x166a0
cmpl $0x1, 0x20(%rbx)
jne 0x166a0
movl 0x2d0b3(%rip), %eax     # 0x43748
leal 0x1(%rax), %ecx
movl %ecx, 0x2d0aa(%rip)     # 0x43748
jmp 0x166af
movl 0x2d0a6(%rip), %eax     # 0x4374c
leal 0x1(%rax), %ecx
movl %ecx, 0x2d09d(%rip)     # 0x4374c
movl %eax, 0x1c(%rbx)
popq %rbx
retq
movl 0x18(%rbx), %eax
jmp 0x166af
// File: /workspace/github_c_makefile_star2_O1/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 0x166f5
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x166b9
movq 0x8(%rbx), %rdi
callq 0x166b9
cmpq $0x0, (%rbx)
jne 0x166e0
cmpq $0x0, 0x8(%rbx)
je 0x166f6
leaq 0x2d07d(%rip), %rax     # 0x43764
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movl %ecx, 0x18(%rbx)
movl %ecx, 0x1c(%rbx)
popq %rbx
retq
leaq 0x2d063(%rip), %rax     # 0x43760
jmp 0x166e7
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsi, %rbx
movq %rdi, %r14
movss %xmm0, 0xc(%rsp)
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x1da97(%rip), %r15     # 0x34748
testq %r14, %r14
je 0x16d2a
movsd 0x40(%r14), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x40(%r14)
cmpq $0x0, (%r14)
jne 0x16d13
cmpq $0x0, 0x8(%r14)
jne 0x16d13
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 0x2c88d(%rip), %rdi     # 0x43590
movq %r12, %rsi
callq 0x2280
movq %r12, %rdi
callq 0x2030
movq (%r14), %rdi
movss 0xc(%rsp), %xmm0
movq %rbx, %rsi
callq 0x16c89
movq 0x8(%r14), %r14
jmp 0x16cb1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq