LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/cppn.c
// Function: CPPN_insert_link
int CPPN_insert_link( CPPN *net, struct NEAT_Params *params, int from, int to, double weight, int is_disabled, unsigned int innov_id ) {
	int err=0;

	if (( err = Realloc( net->links, (net->num_links+1)*sizeof *net->links ) ))
		return err;
	
	if ( ! innov_id )
		innov_id = ++params->innov_counter;

	int i;
	// Find the right place in the innov_id-sorted array
	for ( i=net->num_links; i>0; i-- ) {
		if ( net->links[i-1].innov_id < innov_id )
			break;
	}

	CPPN_Link *l = &net->links[i];
	if ( net->num_links > i ) {
		// Move over, newbies!
		memmove( l+1, l, (net->num_links-i)*sizeof *l );
	}
	l->innov_id = innov_id;
	l->from = from;
	l->to = to;
	l->weight = weight;
	l->is_disabled = is_disabled;
	
	net->num_links++;
	
	return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r15d
movl %r8d, %ebp
movsd %xmm0, 0x10(%rsp)
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
movslq 0x20(%r14), %rsi
shlq $0x5, %rsi
addq $0x20, %rsi
callq 0x480d
testl %eax, %eax
jne 0x2779
testl %r15d, %r15d
jne 0x26ef
movl 0x108(%rbx), %r15d
incl %r15d
movl %r15d, 0x108(%rbx)
movslq 0x20(%r14), %rdi
movq 0x18(%r14), %rbx
testq %rdi, %rdi
movsd 0x10(%rsp), %xmm0
jle 0x2756
leaq -0x20(%rbx), %rdx
movl %edi, %ecx
movl %ecx, %esi
shlq $0x5, %rsi
cmpl %r15d, (%rdx,%rsi)
jb 0x2720
leal -0x1(%rcx), %esi
cmpl $0x1, %ecx
movl %esi, %ecx
jg 0x2708
xorl %ecx, %ecx
movl %ecx, %edx
shlq $0x5, %rdx
addq %rdx, %rbx
movl %edi, %edx
subl %ecx, %edx
jle 0x2760
movl %eax, 0xc(%rsp)
leaq 0x20(%rbx), %rdi
movslq %edx, %rdx
shlq $0x5, %rdx
movq %rbx, %rsi
callq 0x1110
movl 0xc(%rsp), %eax
movsd 0x10(%rsp), %xmm0
movl 0x20(%r14), %edi
jmp 0x2760
movq %rdi, %rcx
shlq $0x5, %rcx
addq %rcx, %rbx
movl %r15d, (%rbx)
movl %r13d, 0x4(%rbx)
movl %r12d, 0x8(%rbx)
movsd %xmm0, 0x10(%rbx)
movl %ebp, 0x18(%rbx)
incl %edi
movl %edi, 0x20(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/cppn.c
// Function: CPPN_exclude_recurrent_links
int CPPN_exclude_recurrent_links( const CPPN *net, const struct NEAT_Params *params, int target_id, int *possible_sources ) {
	int i, n=0;

	// Exclude self
	n += possible_sources[target_id];
	possible_sources[target_id] = 0;

	// Find all links that node #target_id projects to, exclude them
	for ( i=0; i<net->num_links; i++ ) {
		if ( net->links[i].from == target_id ) {
			n += possible_sources[net->links[i].to];
			possible_sources[net->links[i].to] = 0;
			
			// Recurse.
			n += CPPN_exclude_recurrent_links( net, params, net->links[i].to, possible_sources );
		}
	}
	
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movslq %edx, %rax
movl (%rcx,%rax,4), %ebx
movl $0x0, (%rcx,%rax,4)
movl 0x20(%rdi), %eax
testl %eax, %eax
jle 0x2801
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %r12
movl $0x8, %r13d
xorl %r15d, %r15d
movq 0x18(%r12), %rcx
cmpl %ebp, -0x4(%rcx,%r13)
jne 0x27f2
movslq (%rcx,%r13), %rax
addl (%r14,%rax,4), %ebx
movl $0x0, (%r14,%rax,4)
movl (%rcx,%r13), %edx
movq %r12, %rdi
movq (%rsp), %rsi
movq %r14, %rcx
callq 0x2788
addl %eax, %ebx
movl 0x20(%r12), %eax
incq %r15
movslq %eax, %rcx
addq $0x20, %r13
cmpq %rcx, %r15
jl 0x27bc
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/cppn.c
// Function: CPPN_func
double CPPN_func( enum CPPNFunc fn, double x ) {
	switch ( fn ) {
		case CF_ABS:
			return fabs(x);
		case CF_GAUSS:
			return exp(-0.5*x*x)*M_2_SQRTPI*M_SQRT1_2*0.5; // sigma=1, mu=0
		case CF_SIGMOID:
			//return 1.0/(1.0+exp(-4.9*x)); // [0,1]
			return tanh(x); // [-1,1]
		case CF_SINE:
			return sin(x);
		case CF_STEP:
			return x<0.0 ? 0.0 : 1.0;
		case CF_LINEAR:
		default:
			return x;
	}
}

// Assembly:
cmpl $0x5, %edi
ja 0x2a1c
movl %edi, %eax
leaq 0x4903(%rip), %rcx      # 0x72c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq %rax
movsd 0x4769(%rip), %xmm1     # 0x7138
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x1190
mulsd 0x48c0(%rip), %xmm0     # 0x72a8
mulsd 0x48c0(%rip), %xmm0     # 0x72b0
mulsd 0x4750(%rip), %xmm0     # 0x7148
addq $0x8, %rsp
retq
jmp 0x1130
jmp 0x1150
xorpd %xmm1, %xmm1
cmpltsd %xmm1, %xmm0
movsd 0x4718(%rip), %xmm1     # 0x7130
andnpd %xmm1, %xmm0
retq
andps 0x486c(%rip), %xmm0     # 0x7290
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/cppn.c
// Function: get_genetic_distance
double get_genetic_distance( const CPPN *net1, const CPPN *net2, const struct NEAT_Params *params ) {
	int disjoint=0, excess=0, matches=0, n=max(net1->num_links, net2->num_links);
	double w1, w2, wdiff=0.0;
	int i=0, j=0;
	
	while ( i<net1->num_links && j<net2->num_links ) {
		if ( net1->links[i].innov_id == net2->links[j].innov_id ) {
			matches++;
			w1 = net1->links[i].is_disabled ? 0.0 : net1->links[i].weight;
			w2 = net2->links[j].is_disabled ? 0.0 : net2->links[j].weight;
			wdiff += fabs(w1-w2);
			i++;
			j++;
		} else if ( net1->links[i].innov_id > net2->links[j].innov_id ) {
			disjoint++;
			j++;
		} else {
			disjoint++;
			i++;
		}
	}

	if ( i == net1->num_links )
		excess = net2->num_links - j;
	else
		excess = net1->num_links - i;
	
	if ( params->flags & CFL_NO_DISTCALC_NORM )
		return params->disjoint_factor*disjoint + params->excess_factor*excess + params->weight_factor*wdiff/n;
	else
		return params->disjoint_factor*disjoint/n + params->excess_factor*excess/n + params->weight_factor*wdiff/n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl 0x20(%rdi), %ecx
movl 0x20(%rsi), %r8d
cmpl %r8d, %ecx
movl %r8d, %eax
cmovgl %ecx, %eax
testl %ecx, %ecx
setg %r9b
testl %r8d, %r8d
setg %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x2e00
movq 0x18(%rdi), %r9
movq 0x18(%rsi), %r10
xorpd %xmm1, %xmm1
xorl %edi, %edi
movapd 0x450b(%rip), %xmm0     # 0x7290
xorl %esi, %esi
xorl %r11d, %r11d
movslq %esi, %r14
shlq $0x5, %r14
movl (%r9,%r14), %ebp
movslq %edi, %rbx
shlq $0x5, %rbx
movl (%r10,%rbx), %r15d
cmpl %r15d, %ebp
jne 0x2ddb
addq %r9, %r14
xorpd %xmm3, %xmm3
cmpl $0x0, 0x18(%r14)
xorpd %xmm2, %xmm2
jne 0x2dbd
movsd 0x10(%r14), %xmm2
addq %r10, %rbx
cmpl $0x0, 0x18(%rbx)
jne 0x2dcb
movsd 0x10(%rbx), %xmm3
subsd %xmm3, %xmm2
andpd %xmm0, %xmm2
addsd %xmm2, %xmm1
incl %esi
jmp 0x2de3
incl %r11d
cmpl %r15d, %ebp
jbe 0x2de7
incl %edi
jmp 0x2de9
incl %esi
cmpl %ecx, %esi
jge 0x2df2
cmpl %r8d, %edi
jl 0x2d8a
xorps %xmm0, %xmm0
cvtsi2sd %r11d, %xmm0
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
jmp 0x2e08
xorpd %xmm0, %xmm0
xorl %esi, %esi
xorl %edi, %edi
subl %edi, %r8d
subl %esi, %ecx
cmovel %r8d, %ecx
testb $0x1, 0x1(%rdx)
movsd 0x80(%rdx), %xmm1
jne 0x2e5f
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
xorps %xmm3, %xmm3
cvtsi2sd %ecx, %xmm3
mulsd 0x88(%rdx), %xmm3
movhpd 0x90(%rdx), %xmm1       # xmm1 = xmm1[0],mem[0]
divsd %xmm2, %xmm3
mulpd %xmm0, %xmm1
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm1
addsd %xmm1, %xmm3
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm3, %xmm1
movapd %xmm1, %xmm0
jmp 0x2e91
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
mulsd 0x88(%rdx), %xmm2
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
mulsd 0x90(%rdx), %xmm0
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
divsd %xmm2, %xmm0
addsd %xmm1, %xmm0
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/cppn.c
// Function: dump_CPPN
void dump_CPPN( CPPN *net, FILE *fp ) {
	int i;
	for ( i=0; i<net->num_inputs; i++ ) {
		fprintf( fp, "%2d | input\n", i );
	}
	for ( ; i<net->num_inputs+net->num_outputs; i++ ) {
		fprintf( fp, "%2d | output | func %d\n", i, net->nodes[i].func );
	}
	for ( ; i<net->num_inputs+net->num_outputs+net->num_hidden; i++ ) {
		fprintf( fp, "%2d | hidden | func %d\n", i, net->nodes[i].func );
	}
	for ( i=0; i<net->num_links; i++ ) {
		fprintf( fp, "%3d | link #%5x | %2d > %2d | %+5.4f | %d\n", i, net->links[i].innov_id,
		 net->links[i].from, net->links[i].to, net->links[i].weight, !net->links[i].is_disabled );
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x33ae
leaq 0x3f47(%rip), %r15      # 0x72d8
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10b0
incl %ebp
movl 0x8(%r14), %eax
cmpl %eax, %ebp
jl 0x3393
jmp 0x33b0
xorl %ebp, %ebp
addl 0xc(%r14), %eax
cmpl %eax, %ebp
jge 0x33ee
movl %ebp, %r12d
shlq $0x4, %r12
leaq 0x3f1f(%rip), %r15      # 0x72e5
movq (%r14), %rax
movl (%rax,%r12), %ecx
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10b0
movl 0xc(%r14), %eax
addl 0x8(%r14), %eax
incl %ebp
addq $0x10, %r12
cmpl %ebp, %eax
jg 0x33c6
addl 0x10(%r14), %eax
cmpl %eax, %ebp
jge 0x3430
movl %ebp, %r12d
shlq $0x4, %r12
leaq 0x3ef9(%rip), %r15      # 0x72fd
movq (%r14), %rax
movl (%rax,%r12), %ecx
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10b0
movl 0xc(%r14), %eax
addl 0x8(%r14), %eax
addl 0x10(%r14), %eax
incl %ebp
addq $0x10, %r12
cmpl %ebp, %eax
jg 0x3404
cmpl $0x0, 0x20(%r14)
jle 0x348b
xorl %r13d, %r13d
leaq 0x3ed4(%rip), %r15      # 0x7315
xorl %r12d, %r12d
movq 0x18(%r14), %rax
movl (%rax,%r13), %ecx
movl 0x4(%rax,%r13), %r8d
movl 0x8(%rax,%r13), %r9d
movsd 0x10(%rax,%r13), %xmm0
xorl %edx, %edx
cmpl $0x0, 0x18(%rax,%r13)
sete %dl
movl %edx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
movb $0x1, %al
callq 0x10b0
incq %r12
movslq 0x20(%r14), %rax
addq $0x20, %r13
cmpq %rax, %r12
jl 0x3444
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/neat.c
// Function: create_Population
int create_Population( Population *pop, struct NEAT_Params *params, const CPPN *prototype ) {
	int err=0;
	
	pop->num_members = params->population_size;
	pop->num_species = 1;
	
	if (( err = allocate_Population( pop ) ))
		return err;
	
	Individual adam;
	adam.genotype = *prototype;
	adam.species_id = ++params->species_counter;
	adam.id = ++params->individual_counter;
	
	pop->species[0].id = adam.species_id;
	pop->species[0].size = pop->num_members;
	
	int i;
	for ( i=0; i<pop->num_members; i++ ) {
		if (( err = clone_CPPN( &pop->members[i].genotype, prototype ) )) {
			pop->num_members = i;
			delete_Population( pop );
			return err;
		}
		pop->members[i].species_id = adam.species_id;
		pop->members[i].id = ++params->individual_counter;
	}
	
	return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movl 0x50(%rsi), %eax
movl %eax, 0x8(%rdi)
movl $0x1, 0x18(%rdi)
callq 0x356a
movl %eax, %ebp
testl %eax, %eax
jne 0x3559
movq 0x10c(%r15), %xmm0
pcmpeqd %xmm1, %xmm1
psubd %xmm1, %xmm0
movq %xmm0, 0x10c(%r15)
movq 0x10(%rbx), %rax
movd %xmm0, (%rax)
movl 0x8(%rbx), %ecx
movl %ecx, 0x4(%rax)
testl %ecx, %ecx
jle 0x3547
movd %xmm0, 0x4(%rsp)
movq (%rbx), %rdi
xorl %r13d, %r13d
xorl %r14d, %r14d
addq %r13, %rdi
movq %r12, %rsi
callq 0x1e6f
testl %eax, %eax
jne 0x354b
movq (%rbx), %rdi
movl 0x4(%rsp), %eax
movl %eax, 0x30(%rdi,%r13)
movl 0x110(%r15), %eax
incl %eax
movl %eax, 0x110(%r15)
movl %eax, 0x34(%rdi,%r13)
incq %r14
movslq 0x8(%rbx), %rax
addq $0x38, %r13
cmpq %rax, %r14
jl 0x3507
xorl %ebp, %ebp
jmp 0x3559
movl %eax, %ebp
movl %r14d, 0x8(%rbx)
movq %rbx, %rdi
callq 0x35b6
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/neat.c
// Function: allocate_Population
int allocate_Population( Population *pop ) {
	int err=0;
	
	pop->members = 0;
	pop->species = 0;
	
	if (( err = Calloc( pop->members, pop->num_members, sizeof *pop->members ) )
	 || ( err = Calloc( pop->species, pop->num_species, sizeof *pop->species ) ))
		delete_Population( pop );

	return err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
movq %rbx, (%rdi)
movq %rbx, 0x10(%rdi)
movslq 0x8(%rdi), %rsi
movl $0x38, %edx
callq 0x47f7
testl %eax, %eax
jne 0x35a2
leaq 0x10(%r14), %rdi
movslq 0x18(%r14), %rsi
movl $0x18, %edx
callq 0x47f7
testl %eax, %eax
je 0x35ac
movl %eax, %ebx
movq %r14, %rdi
callq 0x35b6
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/neat.c
// Function: delete_Population
void delete_Population( Population *pop ) {
	int i;
	for ( i=0; i<pop->num_members; i++ )
		delete_CPPN( &pop->members[i].genotype );
	free( pop->members );
	free( pop->species );
	pop->members = 0;
	pop->species = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x35e5
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rdi
addq %r14, %rdi
callq 0x1ed7
incq %r15
movslq 0x8(%rbx), %rax
addq $0x38, %r14
cmpq %rax, %r15
jl 0x35ca
movq (%rbx), %rdi
callq 0x1030
movq 0x10(%rbx), %rdi
callq 0x1030
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/neat.c
// Function: epoch
int epoch( Population *pop, struct NEAT_Params *params ) {
	int i, err=0;

	// Initialise next generation whilst saving a set of species representatives
	Individual reps[pop->num_species];
	Individual *champions[pop->num_species];
	int num_reps = pop->num_species;
	if (( err = reproduce_population( pop, params, reps, champions ) ))
		goto cleanup;

	// Mutate the entire new generation
	if (( err = mutate_population( pop, params, champions ) ))
		goto cleanup;

	// Divide the offspring into species
	if (( err = speciate_population( pop, params, reps ) ))
		goto cleanup;
	
	// Adjust the speciation threshold for next generation
	if ( params->target_num_species ) {
		if ( pop->num_species < params->target_num_species && params->speciation_threshold > params->d_speciation_threshold )
			params->speciation_threshold -= params->d_speciation_threshold;
		else if ( pop->num_species > params->target_num_species \
		 && params->speciation_threshold + params->d_speciation_threshold <= params->max_speciation_threshold )
			params->speciation_threshold += params->d_speciation_threshold;
	}

cleanup:
	if ( err != E_NO_OFFSPRING )
		for ( i=0; i<num_reps; i++ )
			if ( reps[i].species_id )
				delete_CPPN( &reps[i].genotype );

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl 0x18(%rdi), %r15d
movq %rsp, %rbx
imulq $0x38, %r15, %rax
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %rbx
movq %rbx, %rsp
movq %rsp, %r13
leaq 0xf(,%r15,8), %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
movq %rsi, -0x30(%rbp)
movq %rbx, %rdx
movq %r13, %rcx
callq 0x375b
testl %eax, %eax
jne 0x36c4
movq %r12, %rdi
movq -0x30(%rbp), %rsi
movq %r13, %rdx
callq 0x3c4b
testl %eax, %eax
jne 0x36c4
movq %r12, %rdi
movq -0x30(%rbp), %r13
movq %r13, %rsi
movq %rbx, %rdx
callq 0x3e9f
testl %eax, %eax
je 0x3704
movl %eax, %r14d
cmpl $-0xa, %r14d
setne %al
testl %r15d, %r15d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x36f2
cmpl $0x0, 0x30(%rbx)
je 0x36e9
movq %rbx, %rdi
callq 0x1ed7
addq $0x38, %rbx
decq %r15
jne 0x36db
movl %r14d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x5c(%r13), %eax
xorl %r14d, %r14d
testl %eax, %eax
je 0x36c7
movl 0x18(%r12), %ecx
cmpl %eax, %ecx
jge 0x3730
movsd 0x68(%r13), %xmm0
movsd 0x70(%r13), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3730
subsd %xmm1, %xmm0
jmp 0x3750
cmpl %eax, %ecx
jle 0x36c7
movsd 0x68(%r13), %xmm0
movsd 0x78(%r13), %xmm1
addsd 0x70(%r13), %xmm0
ucomisd %xmm0, %xmm1
jb 0x36c7
movsd %xmm0, 0x68(%r13)
jmp 0x36c7
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/neat.c
// Function: get_population_ranking
Individual ***get_population_ranking( Population *pop, int *err ) {
	Individual ***ranked=0;

	if (( *err = Malloc( ranked, pop->num_species*sizeof *ranked + pop->num_members*sizeof **ranked ) ))
		return 0;

	int i, j, all_indiv_seen=0, sp;
	for ( sp=0; sp<pop->num_species; sp++ ) {
		// Assign the primary array index to point to the right chunk
		ranked[sp] = (Individual **) &ranked[pop->num_species + all_indiv_seen];
		
		// Find all members...
		int sp_indiv_seen=0;
		for ( i=0; i<pop->num_members; i++ ) {
			// ...of that species...
			if ( pop->members[i].species_id == pop->species[sp].id ) {
				// Go through the conspecifics already in place...
				for ( j=0; j<sp_indiv_seen; j++ ) {
					// Shove the losers back...
					if ( pop->members[i].score > ranked[sp][j]->score ) {
						memmove( ranked[sp]+j+1, ranked[sp]+j, (sp_indiv_seen-j)*sizeof **ranked );
						break;
					}
				}
				// ... so as to maintain order.
				ranked[sp][j] = pop->members + i;
				sp_indiv_seen++;
			}
		}
		all_indiv_seen += sp_indiv_seen;
	}

	return ranked;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
movq $0x0, (%rdi)
movslq 0x18(%rbx), %rax
movslq 0x8(%rbx), %rsi
addq %rax, %rsi
shlq $0x3, %rsi
callq 0x47e4
movl %eax, (%r14)
testl %eax, %eax
je 0x46cc
xorl %eax, %eax
jmp 0x47d2
movl 0x18(%rbx), %ecx
testl %ecx, %ecx
jle 0x47ce
movl 0x8(%rbx), %eax
xorl %r13d, %r13d
xorl %edi, %edi
movq %rbx, 0x10(%rsp)
movq (%rsp), %rdx
leal (%rcx,%rdi), %esi
movslq %esi, %rsi
leaq (%rdx,%rsi,8), %rsi
movq %rsi, (%rdx,%r13,8)
testl %eax, %eax
jle 0x47b9
movq %rdi, 0x8(%rsp)
xorl %r12d, %r12d
leaq (,%r13,2), %r11
addq %r13, %r11
xorl %ebp, %ebp
movq (%rbx), %rcx
movq 0x10(%rbx), %rdx
imulq $0x38, %r12, %r15
movl 0x30(%rcx,%r15), %esi
cmpl (%rdx,%r11,8), %esi
jne 0x47a0
movq (%rsp), %rsi
testl %ebp, %ebp
jle 0x4765
movl %ebp, %edi
movsd 0x28(%rcx,%r15), %xmm0
movq (%rsi,%r13,8), %r8
movslq %ebp, %rdx
shlq $0x3, %rdx
xorl %r14d, %r14d
movq (%r8,%r14,8), %r9
ucomisd 0x28(%r9), %xmm0
ja 0x476a
incq %r14
addq $-0x8, %rdx
cmpq %r14, %rdi
jne 0x4748
movl %edi, %r14d
jmp 0x4790
xorl %r14d, %r14d
jmp 0x4790
leaq (%r8,%r14,8), %rsi
leaq (%r8,%r14,8), %rdi
addq $0x8, %rdi
movq %r11, %rbx
callq 0x1110
movq %rbx, %r11
movq 0x10(%rsp), %rbx
movq (%rbx), %rcx
movq (%rsp), %rsi
movl 0x8(%rbx), %eax
addq %r15, %rcx
movq (%rsi,%r13,8), %rdx
movl %r14d, %esi
movq %rcx, (%rdx,%rsi,8)
incl %ebp
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0x4713
movl 0x18(%rbx), %ecx
movq 0x8(%rsp), %rdi
jmp 0x47bb
xorl %ebp, %ebp
addl %edi, %ebp
incq %r13
movslq %ecx, %rdx
movl %ebp, %edi
cmpq %rdx, %r13
jl 0x46e4
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/util.c
// Function: Realloc_
int Realloc_( void **p, size_t s ) {
	void *q = realloc( *p, s );
	if ( ! q )
		return E_ALLOC;
	*p = q;
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1100
testq %rax, %rax
je 0x4825
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x482a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/extract.c
// Function: extract_links
int extract_links( struct Extraction_Params *eparams ) {
	int err=0;
	
	BinLeaf root = {0};
	eparams->root = &root;
	
	if (( err = build_tree( &root, eparams ) )) {
		goto cleanup;
	}
	
	if (( err = extract_tree( &root, eparams ) )) {
		goto cleanup;
	}

cleanup:
	delete_tree( &root );
	eparams->root = 0;
	return err;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
movq %rdi, (%rbx)
movq %rbx, %rsi
callq 0x4880
movl %eax, %ebp
testl %eax, %eax
jne 0x4868
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x49e8
movl %eax, %ebp
movq %rsp, %rdi
callq 0x4ba1
movq $0x0, (%rbx)
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/extract.c
// Function: build_tree
int build_tree( BinLeaf *p, struct Extraction_Params *eparams ) {
	int i, j, err=0;

	// Divide the parent
	if (( err = Malloc( p->c, CLUSTERSIZE*sizeof *p->c ) ))
		return err;

	double w = 1.0 / (1 << (p->level+2));
	for ( i=0; i<CLUSTERSIZE; i++ ) {
		p->c[i].c = 0;
		p->c[i].level = p->level+1;
		for ( j=0; j<DIMENSIONS; j++ ) {
			// Adjust child coords to be in the center of the quadrant/octant
			p->c[i].x[j] = p->x[j] + ( (i>>j & 1) ? (-1) : 1 ) * w;
		}

		// Populate the new child with CPPN data
		if ( eparams->outgoing )
			read_CPPN( eparams->cppn, eparams->params, eparams->ref, p->c[i].x, p->c[i].r );
		else
			read_CPPN( eparams->cppn, eparams->params, p->c[i].x, eparams->ref, p->c[i].r );
	}

	// Recurse
	if ( p->level < eparams->params->min_resolution-1 \
	 || ( p->level < eparams->params->max_resolution-1 && get_binleaf_variance(p, eparams->params) > eparams->params->variance_threshold ) ) {
		for ( i=0; i<CLUSTERSIZE; i++ ) {
			if (( err = build_tree( &p->c[i], eparams ) ))
				return err;
		}
	}

	return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0xa0, %esi
callq 0x47e4
testl %eax, %eax
je 0x48b1
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb 0x20(%r14), %cl
addb $0x2, %cl
movl $0x1, %eax
shll %cl, %eax
cvtsi2sd %eax, %xmm0
movsd 0x2865(%rip), %xmm1     # 0x7130
divsd %xmm0, %xmm1
leaq 0x8(%rbx), %r15
xorl %r12d, %r12d
movsd %xmm1, 0x8(%rsp)
movq (%r14), %rax
leaq (,%r12,8), %rcx
leaq (%rcx,%rcx,4), %rcx
movq $0x0, (%rax,%rcx)
movl 0x20(%r14), %edx
incl %edx
movq (%r14), %rax
movl %edx, 0x20(%rax,%rcx)
movb $0x1, %cl
leaq (%r12,%r12,4), %rdx
leaq (%rax,%rdx,8), %rsi
xorl %edi, %edi
btl %edi, %r12d
movl $0x0, %r8d
sbbl %r8d, %r8d
orl $0x1, %r8d
xorps %xmm0, %xmm0
cvtsi2sd %r8d, %xmm0
mulsd %xmm1, %xmm0
addsd 0x10(%r14,%rdi,8), %xmm0
movsd %xmm0, 0x10(%rsi,%rdi,8)
movl $0x1, %edi
testb $0x1, %cl
movl $0x0, %ecx
jne 0x490c
cmpb $0x0, 0x18(%rbx)
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rsi
leaq 0x10(%rax,%rdx,8), %rcx
leaq 0x8(%rax,%rdx,8), %r8
je 0x4962
movq %r15, %rdx
jmp 0x4968
movq %rcx, %rdx
movq %r15, %rcx
callq 0x2a25
incq %r12
cmpq $0x4, %r12
movsd 0x8(%rsp), %xmm1
jne 0x48dc
movl 0x20(%r14), %eax
movq 0x28(%rbx), %r15
movl 0x4(%r15), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0x49bf
xorl %r15d, %r15d
movq (%r14), %rdi
addq %r15, %rdi
movq %rbx, %rsi
callq 0x4880
testl %eax, %eax
jne 0x48a0
addq $0x28, %r15
cmpq $0xa0, %r15
jne 0x4995
xorl %ebp, %ebp
jmp 0x48a2
movl 0x8(%r15), %ecx
decl %ecx
xorl %ebp, %ebp
cmpl %ecx, %eax
jge 0x48a2
movq %r14, %rdi
movq %r15, %rsi
callq 0x4be0
ucomisd 0x10(%r15), %xmm0
jbe 0x48a2
jmp 0x4992
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/extract.c
// Function: delete_tree
void delete_tree( BinLeaf *p ) {
	int i;
	if ( ! p->c )
		return;
	for ( i=0; i<CLUSTERSIZE; i++ )
		delete_tree( &p->c[i] );
	free( p->c );
	p->c = 0;
}

// Assembly:
cmpq $0x0, (%rdi)
je 0x4bdf
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
addq %r14, %rdi
callq 0x4ba1
addq $0x28, %r14
cmpq $0xa0, %r14
jne 0x4bb1
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/extract.c
// Function: get_binleaf_variance
double get_binleaf_variance( BinLeaf *p, struct NEAT_Params *params ) {
	int i,j;
	double sum_of_variances=0;
	for ( j=0; j<N_OUTPUTS; j++ ) {
		double sum=0, mean, sum_of_deviations=0;
		for ( i=0; i<CLUSTERSIZE; i++ ) {
			sum += p->c[i].r[j];
		}
		mean = sum/CLUSTERSIZE;
		for ( i=0; i<CLUSTERSIZE; i++ ) {
			sum_of_deviations += fabs( mean - p->c[i].r[j] );
		}

		sum_of_variances += sum_of_deviations/CLUSTERSIZE * params->output_variance_weight[j];
	}
	
	return sum_of_variances/N_OUTPUTS;
}

// Assembly:
movq (%rdi), %rax
movsd 0x18(%rsi), %xmm0
xorpd %xmm1, %xmm1
movl $0x8, %ecx
addsd (%rax,%rcx), %xmm1
addq $0x28, %rcx
cmpq $0xa8, %rcx
jne 0x4bf1
mulsd 0x27a5(%rip), %xmm1     # 0x73b0
xorpd %xmm2, %xmm2
movl $0x8, %ecx
movapd 0x2674(%rip), %xmm3     # 0x7290
movapd %xmm1, %xmm4
subsd (%rax,%rcx), %xmm4
andpd %xmm3, %xmm4
addsd %xmm4, %xmm2
addq $0x28, %rcx
cmpq $0xa8, %rcx
jne 0x4c1c
mulsd 0x276e(%rip), %xmm2     # 0x73b0
mulsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
addsd %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/extract.c
// Function: get_activation_at
void get_activation_at( double x[DIMENSIONS], double r[N_OUTPUTS], struct Extraction_Params *eparams ) {
	int i, read_new=0;
	BinLeaf *b = eparams->root;
	// Check whether x lies within root's bounding box at all
	double w = 1.0 / (1<<(b->level+1));
	for ( i=0; i<DIMENSIONS; i++ ) {
		if ( x[i] > b->x[i]+w || x[i] < b->x[i]-w ) {
			read_new = 1;
			break;
		}
	}
	
	if ( !read_new ) {
		// Drill down into the tree
		while (1) {
			// b is at the requested coordinates, return its readout.
			// No need to check for eparams->outgoing, since the tree was constructed with the same parameters
			if ( ! memcmp(x, b->x, DIMENSIONS*sizeof *x) ) {
				memcpy( r, b->r, N_OUTPUTS*sizeof *r );
				return;
			}
			
			// Determine the appropriate child leaf - 0 for left, 1 for right, dim 0 is right-most bit
			int idx=0;
			for ( i=0; i<DIMENSIONS; i++ ) {
				if ( x[i] > b->x[i] )
					idx |= 1 << i;
			}

			// b has children, c[idx] is closest to the requested coords, check that out
			if ( b->c )
				b = &b->c[idx];

			// b has no children, compute the readout afresh
			else
				break;
		}
	}

	if ( eparams->outgoing )
		read_CPPN( eparams->cppn, eparams->params, eparams->ref, x, r );
	else
		read_CPPN( eparams->cppn, eparams->params, x, eparams->ref, r );
}

// Assembly:
movq (%rdx), %rax
movb 0x20(%rax), %cl
incb %cl
movl $0x1, %r9d
shll %cl, %r9d
movq %rsi, %r8
movq %rdi, %rcx
cvtsi2sd %r9d, %xmm1
movsd 0x24bd(%rip), %xmm0     # 0x7130
divsd %xmm1, %xmm0
movb $0x1, %sil
xorl %edi, %edi
movsd (%rcx,%rdi,8), %xmm1
movsd 0x10(%rax,%rdi,8), %xmm2
movapd %xmm0, %xmm3
addsd %xmm2, %xmm3
ucomisd %xmm3, %xmm1
ja 0x4cfb
subsd %xmm0, %xmm2
ucomisd %xmm1, %xmm2
ja 0x4cfb
movl $0x1, %edi
testb $0x1, %sil
movl $0x0, %esi
jne 0x4c7c
movdqu (%rcx), %xmm0
movdqu 0x10(%rax), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %esi
cmpl $0xffff, %esi           # imm = 0xFFFF
je 0x4d20
movsd (%rcx), %xmm1
xorl %esi, %esi
ucomisd 0x10(%rax), %xmm1
movsd 0x8(%rcx), %xmm1
seta %sil
xorl %edi, %edi
ucomisd 0x18(%rax), %xmm1
seta %dil
leaq (%rsi,%rdi,2), %rsi
movq (%rax), %rdi
leaq (%rsi,%rsi,4), %rax
leaq (%rdi,%rax,8), %rax
testq %rdi, %rdi
jne 0x4cb3
leaq 0x8(%rdx), %rax
cmpb $0x0, 0x18(%rdx)
movq 0x20(%rdx), %rdi
movq 0x28(%rdx), %rsi
je 0x4d15
movq %rax, %rdx
jmp 0x2a25
movq %rcx, %rdx
movq %rax, %rcx
jmp 0x2a25
movq 0x8(%rax), %rax
movq %rax, (%r8)
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/network.c
// Function: create_pNetwork
int create_pNetwork( pNetwork *n ) {
	int err=0;
	n->p_nodes = 0;
	n->p_links = 0;
	if (( err = Malloc( n->p_nodes, sizeof *n->p_nodes ) )
	 || ( err = Malloc( n->p_links, sizeof *n->p_links ) ) ) {
		free( n->p_nodes );
		return err;
	}

	n->p_nodes[0] = 0;
	n->num_nodes = 0;
	n->num_node_blocks = 1;
	n->num_inputs = 0;
	n->num_outputs = 0;

	n->p_links[0] = 0;
	n->num_links = 0;
	n->num_link_blocks = 1;

	if (( err = Malloc( n->p_nodes[0], BLOCKSIZE_NODES*sizeof **n->p_nodes ) )
	 || ( err = Malloc( n->p_links[0], BLOCKSIZE_LINKS*sizeof **n->p_links ) )) {
		delete_pNetwork( n );
		return err;
	}
	
	return err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x30(%rdi)
movl $0x8, %esi
movq %r15, %rdi
callq 0x47e4
testl %eax, %eax
jne 0x4d67
leaq 0x30(%rbx), %r12
movl $0x8, %esi
movq %r12, %rdi
callq 0x47e4
testl %eax, %eax
je 0x4d81
movl %eax, %r14d
movq (%r15), %rdi
callq 0x1030
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%rbx), %rax
xorl %r14d, %r14d
movq %r14, (%rax)
movl %r14d, (%rbx)
movl $0x1, %eax
movl %eax, 0x8(%rbx)
movq %r14, 0x18(%rbx)
movq 0x30(%rbx), %rcx
movq %r14, (%rcx)
movl %r14d, 0x20(%rbx)
movl %eax, 0x28(%rbx)
movq 0x10(%rbx), %rdi
movl $0x1800, %esi           # imm = 0x1800
callq 0x47e4
testl %eax, %eax
jne 0x4dcc
movq (%r12), %rdi
movl $0x8000, %esi           # imm = 0x8000
callq 0x47e4
testl %eax, %eax
je 0x4d72
movl %eax, %r14d
movq %rbx, %rdi
callq 0x4dd9
jmp 0x4d72
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/network.c
// Function: delete_pNetwork
void delete_pNetwork( pNetwork *n ) {
	int i;
	for ( i=0; i<n->num_node_blocks; i++ ) {
		free( n->p_nodes[i] );
	}
	for ( i=0; i<n->num_link_blocks; i++ ) {
		free( n->p_links[i] );
	}

	free( n->p_nodes );
	free( n->p_links );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x4e01
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
movl 0x8(%rbx), %eax
cmpq %rax, %r14
jb 0x4de9
cmpl $0x0, 0x28(%rbx)
je 0x4e22
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
movl 0x28(%rbx), %eax
cmpq %rax, %r14
jb 0x4e0a
movq 0x10(%rbx), %rdi
callq 0x1030
movq 0x30(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/network.c
// Function: add_pNode
int add_pNode( pNetwork *n, const double x[DIMENSIONS], pNode **result ) {
	int err=0;

	// If need be, allocate a new block
	if ( n->num_nodes == n->num_node_blocks * BLOCKSIZE_NODES ) {
		if (( err = Realloc( n->p_nodes, (n->num_node_blocks+1)*sizeof *n->p_nodes ) )
		 || ( err = Malloc( n->p_nodes[n->num_node_blocks], BLOCKSIZE_NODES*sizeof **n->p_nodes ) )) {
			return err;
		}
		n->num_node_blocks++;
	}

	int block = n->num_nodes / BLOCKSIZE_NODES;
	int index = n->num_nodes % BLOCKSIZE_NODES;
	pNode *new = &n->p_nodes[block][index];
	new->used = 0;
	memcpy( new->x, x, DIMENSIONS*sizeof *x );

	n->num_nodes++;
	
	if ( result )
		*result = new;

	return err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %eax
movl 0x8(%rdi), %esi
movl %esi, %ecx
shll $0x8, %ecx
cmpl %ecx, %eax
jne 0x5051
leaq 0x10(%r14), %rdi
incl %esi
shlq $0x3, %rsi
callq 0x480d
testl %eax, %eax
jne 0x5081
movl 0x8(%r14), %edi
shlq $0x3, %rdi
addq 0x10(%r14), %rdi
movl $0x1800, %esi           # imm = 0x1800
callq 0x47e4
testl %eax, %eax
jne 0x5081
incl 0x8(%r14)
movl (%r14), %eax
movzbl %al, %edx
movq 0x10(%r14), %rcx
shrl $0x8, %eax
movq (%rcx,%rax,8), %rcx
leaq (%rdx,%rdx,2), %rdx
movb $0x0, 0x10(%rcx,%rdx,8)
movups (%r15), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl (%r14)
xorl %eax, %eax
testq %rbx, %rbx
je 0x5081
leaq (%rcx,%rdx,8), %rcx
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/network.c
// Function: add_pLink
int add_pLink( pNetwork *n, pNode *from, pNode *to, pLink **result ) {
	int err=0;

	// If need be, allocate a new block
	if ( n->num_links == n->num_link_blocks * BLOCKSIZE_LINKS ) {
		if (( err = Realloc( n->p_links, (n->num_link_blocks+1)*sizeof *n->p_links ) )
		 || ( err = Malloc( n->p_links[n->num_link_blocks], BLOCKSIZE_LINKS*sizeof **n->p_links ) )) {
			return err;
		}
		n->num_link_blocks++;
	}

	int block = n->num_links / BLOCKSIZE_LINKS;
	int index = n->num_links % BLOCKSIZE_LINKS;
	pLink *new = &n->p_links[block][index];
	new->from = from;
	new->to = to;
	new->used = 0;

	n->num_links++;

	if ( result )
		*result = new;

	return err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl 0x20(%rdi), %eax
movl 0x28(%rdi), %esi
movl %esi, %ecx
shll $0xa, %ecx
cmpl %ecx, %eax
jne 0x50df
leaq 0x30(%r14), %rdi
incl %esi
shlq $0x3, %rsi
callq 0x480d
testl %eax, %eax
jne 0x5118
movl 0x28(%r14), %edi
shlq $0x3, %rdi
addq 0x30(%r14), %rdi
movl $0x8000, %esi           # imm = 0x8000
callq 0x47e4
testl %eax, %eax
jne 0x5118
incl 0x28(%r14)
movl 0x20(%r14), %eax
movl %eax, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movq 0x30(%r14), %rdx
movl %eax, %esi
shrl $0xa, %esi
movq (%rdx,%rsi,8), %rdx
shll $0x5, %ecx
movq %r12, (%rdx,%rcx)
movq %r15, 0x8(%rdx,%rcx)
movb $0x0, 0x18(%rdx,%rcx)
incl %eax
movl %eax, 0x20(%r14)
xorl %eax, %eax
testq %rbx, %rbx
je 0x5118
addq %rcx, %rdx
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/network.c
// Function: backtrack
void backtrack( pNetwork *net, pNode *n ) {
	n->used = 1;
	net->num_used_nodes++;
	unsigned int i;
	int index, block=-1;
	pLink *l;
	for ( i = 0; i < net->num_links; i++ ) {
		index = i % BLOCKSIZE_LINKS;
		if ( ! index )
			block++;
		l = &net->p_links[block][index];
		if ( l->to == n ) {
			l->used = 1;
			net->num_used_links++;
			if ( ! l->from->used ) {
				backtrack( net, l->from );
			}
		}
	}
}

// Assembly:
movb $0x1, 0x10(%rsi)
incl 0x4(%rdi)
movl 0x20(%rdi), %eax
testl %eax, %eax
je 0x5610
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
movl %r15d, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
cmpl $0x1, %ecx
adcl $0x0, %ebp
movq 0x30(%r14), %rdx
movslq %ebp, %rsi
movq (%rdx,%rsi,8), %rdx
shll $0x5, %ecx
cmpq %rbx, 0x8(%rdx,%rcx)
jne 0x55fe
addq %rcx, %rdx
movb $0x1, 0x18(%rdx)
incl 0x24(%r14)
movq (%rdx), %rsi
cmpb $0x0, 0x10(%rsi)
jne 0x55fe
movq %r14, %rdi
callq 0x5597
movl 0x20(%r14), %eax
incl %r15d
cmpl %eax, %r15d
jb 0x55ba
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/robot-simplistic.c
// Function: adjust_heading
void adjust_heading( Robot *bot, struct Robot_Params *params, double *controller_outputs ) {
	double turn_output = controller_outputs[1] - controller_outputs[2];
	if ( fabs(turn_output) > params->turn_threshold ) {
		if ( turn_output > 0 )
			turn_output = turn_output - params->turn_threshold;
		else
			turn_output = turn_output + params->turn_threshold;
		bot->heading = fmod( bot->heading + turn_output*params->turn_sensitivity, 2*M_PI );
	}
}

// Assembly:
movsd 0x8(%rdx), %xmm1
subsd 0x10(%rdx), %xmm1
movapd 0x1c6a(%rip), %xmm0     # 0x7290
andpd %xmm1, %xmm0
movsd 0x20(%rsi), %xmm2
ucomisd %xmm2, %xmm0
jbe 0x567b
pushq %rbx
movq %rdi, %rbx
movapd 0x1def(%rip), %xmm3     # 0x7430
xorpd %xmm2, %xmm3
xorpd %xmm0, %xmm0
cmpltsd %xmm1, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm2, %xmm0
orpd %xmm3, %xmm0
addsd %xmm1, %xmm0
mulsd 0x18(%rsi), %xmm0
addsd 0x10(%rdi), %xmm0
movsd 0x1dd0(%rip), %xmm1     # 0x7440
callq 0x1070
movsd %xmm0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/robot-simplistic.c
// Function: get_sensor_readings_in_room
void get_sensor_readings_in_room( Robot *bot, Room *room, struct Robot_Params *params, double *sensor_inputs ) {
	// Calculate sensor data
	int i;
	double s_length = params->dist_sensor_length + params->radius;
	for ( i=0; i<params->num_dist_sensors; i++ ) {
		double s_x = cos(bot->heading + params->dist_sensor_pos[i]) * s_length;
		double s_y = sin(bot->heading + params->dist_sensor_pos[i]) * s_length;
		double depth_x=0, depth_y=0;
		if ( bot->x + s_x < 0 )
			depth_x = -(bot->x + s_x) / s_x;
		else if ( bot->x + s_x > room->x )
			depth_x = (bot->x + s_x - room->x) / s_x;
		if ( bot->y + s_y < 0 )
			depth_y = -(bot->y + s_y) / s_y;
		else if ( bot->y + s_y > room->y )
			depth_y = (bot->y + s_y - room->y) / s_y;
		double reading = max(depth_x, depth_y) * s_length / params->dist_sensor_length;
		sensor_inputs[i] = params->invert_dist_sensors ? 1-reading : reading;
	}
}

// Assembly:
cmpl $0x0, 0x28(%rdx)
jle 0x5924
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movsd 0x30(%rdx), %xmm0
addsd (%rdx), %xmm0
movsd %xmm0, (%rsp)
xorl %r13d, %r13d
movsd 0x10(%r12), %xmm0
movq 0x38(%r14), %rax
addsd (%rax,%r13,8), %xmm0
callq 0x1080
mulsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%r12), %xmm0
movq 0x38(%r14), %rax
addsd (%rax,%r13,8), %xmm0
callq 0x1130
movsd 0x8(%rsp), %xmm5
xorpd %xmm4, %xmm4
movsd (%r12), %xmm2
addsd %xmm5, %xmm2
ucomisd %xmm2, %xmm4
jbe 0x5884
xorpd 0x1bae(%rip), %xmm2     # 0x7430
jmp 0x5897
movsd (%r15), %xmm3
xorpd %xmm1, %xmm1
ucomisd %xmm3, %xmm2
jbe 0x589f
subsd %xmm3, %xmm2
divsd %xmm5, %xmm2
movapd %xmm2, %xmm1
mulsd (%rsp), %xmm0
movsd 0x8(%r12), %xmm2
addsd %xmm0, %xmm2
ucomisd %xmm2, %xmm4
jbe 0x58bf
xorpd 0x1b73(%rip), %xmm2     # 0x7430
jmp 0x58d3
movsd 0x8(%r15), %xmm4
xorpd %xmm3, %xmm3
ucomisd %xmm4, %xmm2
jbe 0x58db
subsd %xmm4, %xmm2
divsd %xmm0, %xmm2
movapd %xmm2, %xmm3
maxsd %xmm3, %xmm1
mulsd (%rsp), %xmm1
divsd 0x30(%r14), %xmm1
cmpb $0x0, 0x40(%r14)
je 0x5901
movsd 0x1837(%rip), %xmm0     # 0x7130
subsd %xmm1, %xmm0
movapd %xmm0, %xmm1
movsd %xmm1, (%rbx,%r13,8)
incq %r13
movslq 0x28(%r14), %rax
cmpq %rax, %r13
jl 0x5829
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/network-static.c
// Function: activate
void activate( eNetwork *net, double *inputs, double *outputs ) {
	unsigned int i, j=0;
	eNode *n = net->nodes;
	eLink *l = net->links;

	// Load input values
	for ( i=0; i<net->num_inputs; i++ ) {
		if ( net->inputs[i] ) {
			net->inputs[i]->a = inputs[i];
			n++;
			j++;
			l += net->inputs[i]->num_inputs;
		}
	}

	// Propagate
	for ( i=j; i<net->num_nodes; i++ ) {
		double sum=0;
		for ( j=0; j<n->num_inputs; j++ ) {
			sum += l->w * l->from->a;
			l++;
		}
		n->a = tanh(sum);
		n++;
	}

	// Load output values
	for ( i=0; i<net->num_outputs; i++ ) {
		if ( net->outputs[i] ) {
			outputs[i] = net->outputs[i]->a;
		} else {
			outputs[i] = 0;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x30(%rdi), %r12
movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x66cc
movq 0x18(%r14), %rcx
xorl %edx, %edx
xorl %ebp, %ebp
movq (%rcx,%rdx,8), %rdi
testq %rdi, %rdi
je 0x66c2
movsd (%rsi,%rdx,8), %xmm0
movsd %xmm0, (%rdi)
addq $0x10, %r15
incl %ebp
movslq 0x8(%rdi), %rdi
shlq $0x4, %rdi
addq %rdi, %r12
incq %rdx
cmpq %rdx, %rax
jne 0x669f
jmp 0x6707
xorl %ebp, %ebp
jmp 0x6707
movl 0x8(%r15), %eax
xorpd %xmm0, %xmm0
testl %eax, %eax
je 0x66f7
movsd (%r12), %xmm1
movq 0x8(%r12), %rcx
mulsd (%rcx), %xmm1
addsd %xmm1, %xmm0
addq $0x10, %r12
decl %eax
jne 0x66dc
callq 0x1150
movsd %xmm0, (%r15)
addq $0x10, %r15
incl %ebp
cmpl (%r14), %ebp
jb 0x66d0
movl 0x14(%r14), %eax
testq %rax, %rax
je 0x673b
movq 0x20(%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
testq %rsi, %rsi
je 0x672a
movsd (%rsi), %xmm0
jmp 0x672e
xorpd %xmm0, %xmm0
movsd %xmm0, (%rbx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x671b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/network-static.c
// Function: dump_eNetwork
void dump_eNetwork( eNetwork *net, FILE *fp ) {
	unsigned int i;
	for ( i=0; i<net->num_nodes; i++ ) {
		fprintf( fp, "0x%08x | %4d\n",
			(unsigned int) &net->nodes[i],
			net->nodes[i].num_inputs
		);
	}

	for ( i=0; i<net->num_links; i++ ) {
		fprintf( fp, "0x%08x | 0x%08x > ... | %+6.4f\n",
			(unsigned int) &net->links[i],
			(unsigned int) net->links[i].from,
			net->links[i].w
		);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, (%rdi)
je 0x678e
leaq 0xd01(%rip), %r15       # 0x7460
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r14), %rax
leal (%rax,%r12), %edx
movl 0x8(%rax,%r12), %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
incq %r13
movl (%r14), %eax
addq $0x10, %r12
cmpq %rax, %r13
jb 0x6765
cmpl $0x0, 0x28(%r14)
je 0x67d2
xorl %r12d, %r12d
leaq 0xccf(%rip), %r15       # 0x746e
xorl %r13d, %r13d
movq 0x30(%r14), %rax
leal (%rax,%r12), %edx
movl 0x8(%rax,%r12), %ecx
movsd (%rax,%r12), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x10b0
incq %r13
movl 0x28(%r14), %eax
addq $0x10, %r12
cmpq %rax, %r13
jb 0x67a2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/aligrudi[P]gpss/sum.c
// Function: main
int main(void)
{
	int cnt = 0;
	int npt;
	int r[NALG];
	int amax[NALG] = {0};
	int arat[NALG] = {0};
	int i;
	while (scanf("%d", &npt) == 1) {
		int best = 0;
		for (i = 0; i < NALG; i++)
			scanf("%d", &r[i]);
		for (i = 0; i < NALG; i++)
			if (best < r[i])
				best = r[i];
		for (i = 0; i < NALG; i++)
			if (r[i] == best)
				amax[i]++;
		for (i = 0; i < NALG; i++)
			arat[i] += r[i] * 10000 / best;
		cnt++;
	}
	for (i = 0; i < NALG; i++) {
		int maxrat = amax[i] * 10000 / cnt;
		int sizerat = arat[i] / cnt;
		printf("%2d.%02d %2d.%02d\n", maxrat / 100, maxrat % 100,
			sizerat / 100, sizerat % 100);
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
pxor %xmm0, %xmm0
movdqa %xmm0, (%rsp)
movdqa %xmm0, 0x20(%rsp)
leaq 0xeb0(%rip), %rdi       # 0x2020
xorl %ebp, %ebp
leaq 0x14(%rsp), %rsi
xorl %eax, %eax
callq 0x1040
cmpl $0x1, %eax
jne 0x12a0
movl (%rsp), %r15d
movl 0x4(%rsp), %r14d
movl 0x8(%rsp), %r13d
movl 0xc(%rsp), %r12d
leaq 0xe7f(%rip), %rbx       # 0x2020
xorl %ebp, %ebp
movq %r13, 0x18(%rsp)
movq %r14, %r13
movq %r15, %r14
xorl %r15d, %r15d
leaq (%rsp,%r15), %rsi
addq $0x30, %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
addq $0x4, %r15
cmpq $0x10, %r15
jne 0x11b1
movdqa 0x30(%rsp), %xmm0
movdqa %xmm0, %xmm1
pcmpgtd 0xe31(%rip), %xmm1      # 0x2010
pand %xmm0, %xmm1
pshufd $0xee, %xmm1, %xmm2     # xmm2 = xmm1[2,3,2,3]
movdqa %xmm1, %xmm3
pcmpgtd %xmm2, %xmm3
pand %xmm3, %xmm1
pandn %xmm2, %xmm3
por %xmm1, %xmm3
pshufd $0x55, %xmm3, %xmm1     # xmm1 = xmm3[1,1,1,1]
movdqa %xmm3, %xmm2
pcmpgtd %xmm1, %xmm2
pand %xmm2, %xmm3
pandn %xmm1, %xmm2
por %xmm3, %xmm2
movd %xmm2, %ecx
pshufd $0x0, %xmm2, %xmm1      # xmm1 = xmm2[0,0,0,0]
pcmpeqd %xmm0, %xmm1
movmskps %xmm1, %eax
movq %r14, %r15
leal 0x1(%r14), %edx
testb $0x1, %al
cmovnel %edx, %r15d
movq %r13, %r14
leal 0x1(%r13), %edx
testb $0x2, %al
cmovnel %edx, %r14d
movq 0x18(%rsp), %r13
leal 0x1(%r13), %edx
testb $0x4, %al
cmovnel %edx, %r13d
leal 0x1(%r12), %edx
testb $0x8, %al
cmovnel %edx, %r12d
xorl %esi, %esi
imull $0x2710, 0x30(%rsp,%rsi,4), %eax # imm = 0x2710
cltd
idivl %ecx
addl %eax, 0x20(%rsp,%rsi,4)
incq %rsi
cmpq $0x4, %rsi
jne 0x125b
incl %ebp
movq %rbx, %rdi
leaq 0x14(%rsp), %rsi
xorl %eax, %eax
callq 0x1040
cmpl $0x1, %eax
je 0x11a3
movl %r14d, 0x4(%rsp)
movl %r13d, 0x8(%rsp)
movl %r12d, 0xc(%rsp)
movl %r15d, (%rsp)
leaq 0xd7c(%rip), %rbx       # 0x2023
xorl %r14d, %r14d
imull $0x2710, (%rsp,%r14,4), %eax # imm = 0x2710
cltd
idivl %ebp
movl %eax, %ecx
movl 0x20(%rsp,%r14,4), %eax
cltd
idivl %ebp
movslq %ecx, %rdx
imulq $0x51eb851f, %rdx, %rsi # imm = 0x51EB851F
movq %rsi, %rcx
shrq $0x3f, %rcx
sarq $0x25, %rsi
addl %ecx, %esi
imull $0x64, %esi, %ecx
subl %ecx, %edx
movslq %eax, %r8
imulq $0x51eb851f, %r8, %rcx  # imm = 0x51EB851F
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x25, %rcx
addl %eax, %ecx
imull $0x64, %ecx, %eax
subl %eax, %r8d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1030
incq %r14
cmpq $0x4, %r14
jne 0x12aa
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/utils/chorus/chorus.c
// Function: getDatum
static double
getDatum(FILE *in,FILE *out,RRA *h,double t)
    {
    static int edge = -1;
    int ceiling;
    double result;
    
    if (t < 0) return 0;

    if (edge == -1) createRRAData(h);

    /* read in five or so samples ahead */

    ceiling = (int) (t + 0.5) + ReadAhead;

    if (ceiling >= h->samples) ceiling = h->samples - 1;

    while (edge < ceiling)
        {
        ++edge;
        h->data[0][edge] = 
            readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
        }

    result = interp(h->data[0],h->samples,t);

    return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x1d5e
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x5578(%rip), %edx      # 0x7170
cmpl $-0x1, %edx
movsd %xmm1, -0x30(%rbp)
jne 0x1c15
movq %rbx, %rdi
callq 0x204e
movsd -0x30(%rbp), %xmm1
movl 0x555b(%rip), %edx      # 0x7170
movsd 0x242b(%rip), %xmm0     # 0x4048
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl 0x5549(%rip), %eax      # 0x7174
movl 0xc(%rbx), %ecx
leal -0x1(%rcx), %r13d
cmpl %ecx, %eax
cmovll %eax, %r13d
cmpl %r13d, %edx
jge 0x1c75
leaq 0x15df(%rip), %r12      # 0x3223
incl %edx
movl %edx, 0x5524(%rip)      # 0x7170
movl 0x8(%rbx), %edx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x29c0
movq 0x18(%rbx), %rcx
movq (%rcx), %rcx
movslq 0x5505(%rip), %rdx      # 0x7170
movl %eax, (%rcx,%rdx,4)
cmpl %r13d, %edx
jl 0x1c44
jmp 0x1c7c
movq 0x18(%rbx), %rax
movq (%rax), %rcx
xorpd %xmm0, %xmm0
movsd -0x30(%rbp), %xmm4
ucomisd %xmm0, %xmm4
jb 0x1d6d
cvttsd2si %xmm4, %eax
movslq 0xc(%rbx), %rsi
leal -0x1(%rsi), %edx
cmpl %eax, %edx
jle 0x1d37
leal 0x1(%rax), %esi
xorl %edi, %edi
testl %eax, %eax
setg %dil
movl %eax, %r8d
subl %edi, %r8d
leal 0x2(%rax), %edi
cmpl %edx, %esi
cmovgel %esi, %edi
movslq %eax, %rdx
xorps %xmm1, %xmm1
cvtsi2sdl (%rcx,%rdx,4), %xmm1
movslq %r8d, %rdx
cvtsi2sdl (%rcx,%rdx,4), %xmm2
movsd 0x237a(%rip), %xmm0     # 0x4050
movapd %xmm1, %xmm3
mulsd %xmm0, %xmm3
subsd %xmm2, %xmm3
movslq %esi, %rdx
xorps %xmm2, %xmm2
cvtsi2sdl (%rcx,%rdx,4), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
movslq %edi, %rdx
xorps %xmm3, %xmm3
cvtsi2sdl (%rcx,%rdx,4), %xmm3
subsd %xmm3, %xmm0
xorps %xmm3, %xmm3
cvtsi2sd %eax, %xmm3
mulsd 0x2345(%rip), %xmm0     # 0x4058
subsd %xmm3, %xmm4
movsd 0x2329(%rip), %xmm3     # 0x4048
ucomisd %xmm4, %xmm3
jbe 0x1d42
subsd %xmm1, %xmm0
addsd %xmm0, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
jmp 0x1d5e
xorps %xmm0, %xmm0
cvtsi2sdl -0x4(%rcx,%rsi,4), %xmm0
jmp 0x1d5e
subsd %xmm0, %xmm2
addsd 0x2312(%rip), %xmm4     # 0x4060
addsd %xmm2, %xmm2
mulsd %xmm2, %xmm4
addsd %xmm0, %xmm4
movapd %xmm4, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x232e(%rip), %rdi      # 0x40a2
leaq 0x232e(%rip), %rsi      # 0x40a9
leaq 0x2330(%rip), %rcx      # 0x40b2
movl $0xa9, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/SandyBridge/KeccakP-1600-times2-SIMD128.c
// Function: KeccakP1600times2_OverwriteWithZeroes
void KeccakP1600times2_OverwriteWithZeroes(void *states, unsigned int instanceIndex, unsigned int byteCount)
{
    unsigned int sizeLeft = byteCount;
    unsigned int lanePosition = 0;
    UINT64 *statesAsLanes = states;

    while(sizeLeft >= SnP_laneLengthInBytes) {
        statesAsLanes[laneIndex(instanceIndex, lanePosition)] = 0;
        sizeLeft -= SnP_laneLengthInBytes;
        lanePosition++;
    }

    if (sizeLeft > 0) {
        memset(&statesAsLanes[laneIndex(instanceIndex, lanePosition)], 0, sizeLeft);
    }
}

// Assembly:
xorl %eax, %eax
cmpl $0x8, %edx
jb 0x1314d
leal -0x8(%rdx), %ecx
movl %ecx, %eax
shrl $0x3, %eax
incl %eax
andl $-0x8, %ecx
addq $0x8, %rcx
xorl %r8d, %r8d
movl %esi, %r9d
movl %r9d, %r10d
movq $0x0, (%rdi,%r10,8)
addl $0x2, %r9d
addq $0x8, %r8
cmpq %r8, %rcx
jne 0x13130
addl %eax, %eax
subl %r8d, %edx
testl %edx, %edx
je 0x13160
addl %esi, %eax
leaq (%rdi,%rax,8), %rdi
movl %edx, %edx
xorl %esi, %esi
jmp 0x5060
retq