LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/main.c
// Function: test_single
void test_single(const char *data, bool verbose, bool parse_second, int precision) {
    ParserState state;
    initParserState(&state);
    state.parse_second = parse_second;
    state.precision = precision;

    if (verbose) printf("Input:  '%s'\n", data);
    normalize(data, strlen(data), &state);
    if (verbose) printf("Output: '%s'\n", state.result);
    resetParserState(&state);

    freeParserState(&state);
}

// Assembly:
subq $0x58, %rsp
movb %dl, %al
movb %sil, %dl
movq %rdi, 0x50(%rsp)
andb $0x1, %dl
movb %dl, 0x4f(%rsp)
andb $0x1, %al
movb %al, 0x4e(%rsp)
movl %ecx, 0x48(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x14c90
movb 0x4e(%rsp), %al
andb $0x1, %al
movb %al, 0x40(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x10(%rsp)
testb $0x1, 0x4f(%rsp)
je 0x17165
movq 0x50(%rsp), %rsi
leaq 0x696a(%rip), %rdi      # 0x1dac8
movb $0x0, %al
callq 0x10a0
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1080
movq 0x8(%rsp), %rdi
movq %rax, %rsi
leaq 0x10(%rsp), %rdx
callq 0x9d60
testb $0x1, 0x4f(%rsp)
je 0x171a5
movq 0x18(%rsp), %rsi
leaq 0x6938(%rip), %rdi      # 0x1dad6
movb $0x0, %al
callq 0x10a0
leaq 0x10(%rsp), %rdi
callq 0x14cc0
leaq 0x10(%rsp), %rdi
callq 0x14d00
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/JesseBuesking[P]omnomnum/main.c
// Function: test_loop
void test_loop(const char *data) {
    ParserState state;
    initParserState(&state);

    int i;
    for (i = 0; i < 1000; i++) {
        normalize(data, strlen(data), &state);
        resetParserState(&state);
    }

    freeParserState(&state);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x14c90
movl $0x0, 0x14(%rsp)
cmpl $0x3e8, 0x14(%rsp)      # imm = 0x3E8
jge 0x17222
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1080
movq 0x8(%rsp), %rdi
movq %rax, %rsi
leaq 0x18(%rsp), %rdx
callq 0x9d60
leaq 0x18(%rsp), %rdi
callq 0x14cc0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x171db
leaq 0x18(%rsp), %rdi
callq 0x14d00
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kernfel[P]fNEAT/main.c
// Function: get_robot_params
void get_robot_params( struct Robot_Params *params ) {
	params->radius = 1;
	
	params->motor_sensitivity = 0.01;
	params->motor_threshold = 0.1;
	params->turn_sensitivity = 0.01;
	params->turn_threshold = 0.1;
	
	params->num_dist_sensors = 0;
	params->dist_sensor_length = 1;
	params->dist_sensor_pos = NULL;
	params->invert_dist_sensors = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8ae4(%rip), %xmm0     # 0xa068
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x8aac(%rip), %xmm0     # 0xa040
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x8ad3(%rip), %xmm0     # 0xa078
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movsd 0x8a8a(%rip), %xmm0     # 0xa040
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movsd 0x8ab1(%rip), %xmm0     # 0xa078
movsd %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movsd 0x8a85(%rip), %xmm0     # 0xa068
movsd %xmm0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x40(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kernfel[P]fNEAT/main.c
// Function: m_get_spread
void m_get_spread( pNode *in, int n, double x ) {
	int i;
	for ( i=1; i<=n; i++ ) {
		in[i-1].x[0] = x;
		in[i-1].x[1] = (-0.5) + i/(1.0+n);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x18d6
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
cvtsi2sdl -0x1c(%rbp), %xmm1
cvtsi2sdl -0xc(%rbp), %xmm2
movsd 0x87ca(%rip), %xmm0     # 0xa068
addsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd 0x87da(%rip), %xmm0     # 0xa088
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1867
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kernfel[P]fNEAT/main.c
// Function: analyse_maze
int analyse_maze( TileMaze *m, int *behaviour, int print ) {
	int x, y, maxval=0, tiles_visited=0;
	for ( x=0; x<m->x*m->y; x++ ) {
		maxval = max(maxval, behaviour[x]);
		if ( behaviour[x] )
			tiles_visited++;
	}
	if ( print ) {
		for ( y=0; y<m->y; y++ ) {
			putchar('\n');
			for ( x=0; x<m->x; x++ ) {
				if ( behaviour[x + m->x*y] ) {
					int track = (int)(34 * behaviour[x + m->x*y] / maxval);
					if ( track < 9 )
						putchar( '1'+track );
					else
						putchar( 'A'+(track-9) );
				} else if ( m->tiles[x + m->x*y] )
					putchar('0');
				else
					putchar('#');
			}
		}
		putchar('\n');
		fflush(stdout);
	}
	return tiles_visited;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movq -0x8(%rbp), %rdx
imull 0xc(%rdx), %ecx
cmpl %ecx, %eax
jge 0x196e
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x1936
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1944
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x1961
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1963
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1908
cmpl $0x0, -0x14(%rbp)
je 0x1a84
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x1a6b
movl $0xa, %edi
callq 0x1040
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1a5b
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rdx
movl 0x8(%rdx), %edx
imull -0x1c(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x1a12
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rdx
movl 0x8(%rdx), %edx
imull -0x1c(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
imull $0x22, (%rax,%rcx,4), %eax
cltd
idivl -0x20(%rbp)
movl %eax, -0x28(%rbp)
cmpl $0x9, -0x28(%rbp)
jge 0x1a02
movl -0x28(%rbp), %edi
addl $0x31, %edi
callq 0x1040
jmp 0x1a10
movl -0x28(%rbp), %edi
subl $0x9, %edi
addl $0x41, %edi
callq 0x1040
jmp 0x1a4b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rdx
movl 0x8(%rdx), %edx
imull -0x1c(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1a3f
movl $0x30, %edi
callq 0x1040
jmp 0x1a49
movl $0x23, %edi
callq 0x1040
jmp 0x1a4b
jmp 0x1a4d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x19a0
jmp 0x1a5d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x197f
movl $0xa, %edi
callq 0x1040
movq 0xa564(%rip), %rax      # 0xbfe0
movq (%rax), %rdi
callq 0x1100
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kernfel[P]fNEAT/cppn.c
// Function: allocate_CPPN
int allocate_CPPN( CPPN *net ) {
	int err=0;

	net->nodes = 0;
	net->links = 0;

	if (( err = Malloc( net->links, net->num_links*sizeof *net->links ) ) \
	 || ( err = Malloc( net->nodes, (net->num_inputs+net->num_outputs+net->num_hidden)*sizeof *net->nodes ) )) {
		delete_CPPN( net );
	}

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x8(%rbp), %rax
movslq 0x20(%rax), %rsi
shlq $0x5, %rsi
callq 0x6330
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jne 0x22d8
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0xc(%rcx), %eax
movq -0x8(%rbp), %rcx
addl 0x10(%rcx), %eax
movslq %eax, %rsi
shlq $0x4, %rsi
callq 0x6330
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x22e1
movq -0x8(%rbp), %rdi
callq 0x23a0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kernfel[P]fNEAT/cppn.c
// Function: clone_CPPN
int clone_CPPN( CPPN *net, const CPPN *original ) {
	int err=0;
	
	// Copy values over
	memcpy( net, original, sizeof *original );

	// Reassign pointers
	if (( err = allocate_CPPN( net ) ))
		return err;
	
	// Copy nodes and links
	memcpy( net->nodes, original->nodes, (net->num_inputs+net->num_outputs+net->num_hidden)*sizeof *net->nodes );
	memcpy( net->links, original->links, net->num_links*sizeof *net->links );

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x28, %edx
callq 0x10d0
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x2332
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2388
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0xc(%rcx), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movslq %eax, %rdx
shlq $0x4, %rdx
callq 0x10d0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x20(%rax), %rdx
shlq $0x5, %rdx
callq 0x10d0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kernfel[P]fNEAT/cppn.c
// Function: delete_CPPN
void delete_CPPN( CPPN *net ) {
	free( net->nodes );
	free( net->links );
	net->links = 0;
	net->nodes = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kernfel[P]fNEAT/cppn.c
// Function: randomise_CPPN_weights
void randomise_CPPN_weights( CPPN *net, struct NEAT_Params *params ) {
	int i;
	double k=params->random_weights_range*2/RAND_MAX;
	for ( i=0; i<net->num_links; i++ ) {
		net->links[i].weight = k * rand() - params->random_weights_range;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsd 0x7c84(%rip), %xmm0     # 0xa090
mulsd 0x100(%rax), %xmm0
movsd 0x7d74(%rip), %xmm1     # 0xa190
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x249e
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x11b0
movsd -0x28(%rbp), %xmm0
cvtsi2sd %eax, %xmm2
movq -0x10(%rbp), %rax
movsd 0x100(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x242c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x5, %rsi
callq 0x63c0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x305b
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3142
cmpl $0x0, -0x30(%rbp)
jne 0x3077
movq -0x18(%rbp), %rcx
movl 0x108(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x108(%rcx)
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jle 0x30b5
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x30(%rbp), %eax
jae 0x30a8
jmp 0x30b5
jmp 0x30aa
movl -0x38(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x3081
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x38(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x38(%rbp), %eax
jle 0x30fa
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
subl -0x38(%rbp), %eax
movslq %eax, %rdx
shlq $0x5, %rdx
callq 0x1120
movl -0x30(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x20(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x8(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x40(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movl -0x2c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x3243
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x3233
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movslq 0x8(%rcx), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edx
movq -0x20(%rbp), %rcx
callq 0x3150
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x3235
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3195
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0x3570
movq -0x20(%rbp), %rax
leaq 0x6d04(%rip), %rcx      # 0xa1c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd -0x18(%rbp), %xmm0
movaps 0x6cdf(%rip), %xmm1     # 0xa1b0
pand %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x357a
movsd 0x6ba1(%rip), %xmm0     # 0xa088
mulsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
callq 0x11a0
movsd 0x6ca2(%rip), %xmm1     # 0xa1a0
mulsd %xmm1, %xmm0
movsd 0x6c8e(%rip), %xmm1     # 0xa198
mulsd %xmm1, %xmm0
movsd 0x6b22(%rip), %xmm1     # 0xa038
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x357a
movsd -0x18(%rbp), %xmm0
callq 0x1160
movsd %xmm0, -0x8(%rbp)
jmp 0x357a
movsd -0x18(%rbp), %xmm0
callq 0x1140
movsd %xmm0, -0x8(%rbp)
jmp 0x357a
movsd -0x18(%rbp), %xmm0
xorps %xmm3, %xmm3
movsd 0x6b15(%rip), %xmm2     # 0xa068
cmpltsd %xmm3, %xmm0
movaps %xmm0, %xmm1
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x357a
jmp 0x3570
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x43b3
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x5e37(%rip), %rsi      # 0xa1d8
movb $0x0, %al
callq 0x10c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4387
jmp 0x43b5
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movq -0x8(%rbp), %rdx
addl 0xc(%rdx), %ecx
cmpl %ecx, %eax
jge 0x43fe
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %ecx
leaq 0x5df9(%rip), %rsi      # 0xa1e5
movb $0x0, %al
callq 0x10c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x43b5
jmp 0x4400
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movq -0x8(%rbp), %rdx
addl 0xc(%rdx), %ecx
movq -0x8(%rbp), %rdx
addl 0x10(%rdx), %ecx
cmpl %ecx, %eax
jge 0x4450
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %ecx
leaq 0x5dbf(%rip), %rsi      # 0xa1fd
movb $0x0, %al
callq 0x10c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4400
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x4509
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rsi
shlq $0x5, %rsi
addq %rsi, %rax
movl 0x4(%rax), %r8d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rsi
shlq $0x5, %rsi
addq %rsi, %rax
movl 0x8(%rax), %r9d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rsi
shlq $0x5, %rsi
addq %rsi, %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rsi
shlq $0x5, %rsi
addq %rsi, %rax
cmpl $0x0, 0x18(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
leaq 0x5d24(%rip), %rsi      # 0xa215
movl %eax, (%rsp)
movb $0x1, %al
callq 0x10c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4457
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x50(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x4670
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x4560
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4666
leaq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x28, %edx
callq 0x10d0
movq -0x18(%rbp), %rcx
movl 0x10c(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x10c(%rcx)
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movl 0x110(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x110(%rcx)
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl %ecx, 0x4(%rax)
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4660
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x64(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x22f0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x4612
movl -0x64(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x46f0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4666
movl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x64(%rbp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x30(%rax)
movq -0x18(%rbp), %rax
movl 0x110(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x110(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x64(%rbp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x34(%rax)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x45c4
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rsi
movl $0x38, %edx
callq 0x6370
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jne 0x46da
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rsi
movl $0x18, %edx
callq 0x6370
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x46e3
movq -0x8(%rbp), %rdi
callq 0x46f0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4731
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
callq 0x23a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4703
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x63f4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6406
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1070
movq -0x8(%rbp), %rax
leaq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x6490
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x6455
jmp 0x646e
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x6700
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x646c
jmp 0x646e
jmp 0x646e
leaq -0x38(%rbp), %rdi
callq 0x6a20
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movl -0xc(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6a38
jmp 0x6a7e
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x6a67
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x6a20
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6a3f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jge 0x6ba6
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x6b03
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6acc
movsd -0x28(%rbp), %xmm0
movsd 0x37a0(%rip), %xmm1     # 0xa2b0
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x6b67
movsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
subsd 0x8(%rax,%rcx,8), %xmm0
movaps 0x3662(%rip), %xmm1     # 0xa1b0
pand %xmm1, %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6b20
movsd -0x38(%rbp), %xmm0
movsd 0x373c(%rip), %xmm1     # 0xa2b0
divsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd 0x18(%rax,%rcx,8), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6aab
movsd -0x20(%rbp), %xmm0
movsd 0x34b5(%rip), %xmm1     # 0xa068
divsd %xmm1, %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movl $0x8, %esi
callq 0x6330
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x6dff
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movl $0x8, %esi
callq 0x6330
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x6e17
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6ec1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x1800, %esi           # imm = 0x1800
callq 0x6330
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x6eaa
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl $0x8000, %esi           # imm = 0x8000
callq 0x6330
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x6ebb
movq -0x10(%rbp), %rdi
callq 0x6ed0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6ec1
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x6f0f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6ee3
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jae 0x6f42
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6f16
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kernfel[P]fNEAT/network.c
// Function: reset_pNetwork
void reset_pNetwork( pNetwork *net ) {
	// No further processing is needed, as the block allocations remain intact
	net->num_nodes = 0;
	net->num_used_nodes = 0;
	net->num_links = 0;
	net->num_used_links = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
shll $0x8, %ecx
cmpl %ecx, %eax
jne 0x7306
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x63c0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jne 0x72ee
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
shlq $0x3, %rax
addq %rax, %rdi
movl $0x1800, %esi           # imm = 0x1800
callq 0x6330
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x72f9
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7380
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x737a
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x28(%rcx), %ecx
shll $0xa, %ecx
cmpl %ecx, %eax
jne 0x742b
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x63c0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x7413
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
shlq $0x3, %rax
addq %rax, %rdi
movl $0x8000, %esi           # imm = 0x8000
callq 0x6330
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x741e
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x74aa
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
shrl $0xa, %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
movb $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x74a4
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jae 0x7c9e
movl -0x14(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x7c2d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x7c8e
movq -0x28(%rbp), %rax
movb $0x1, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x10(%rax)
jne 0x7c8c
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x7bd0
jmp 0x7c8e
jmp 0x7c90
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7c03
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movaps 0x24c9(%rip), %xmm1     # 0xa1b0
pand %xmm1, %xmm0
movq -0x10(%rbp), %rax
ucomisd 0x20(%rax), %xmm0
jbe 0x7d61
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x7d19
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
subsd 0x20(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x7d2c
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
addsd 0x20(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm1
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x25d5(%rip), %xmm1     # 0xa328
callq 0x1080
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kernfel[P]fNEAT/network-static.c
// Function: create_eNetwork
int create_eNetwork( eNetwork *e ) {
	e->nodes = 0;
	e->inputs = 0;
	e->outputs = 0;
	e->links = 0;

	e->num_nodes = 0;
	e->num_inputs = 0;
	e->num_outputs = 0;
	e->num_links = 0;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kernfel[P]fNEAT/network-static.c
// Function: delete_eNetwork
void delete_eNetwork( eNetwork *e ) {
	free( e->nodes );
	free( e->inputs );
	free( e->outputs );
	free( e->links );

	e->nodes = 0;
	e->inputs = 0;
	e->outputs = 0;
	e->links = 0;

	e->num_nodes = 0;
	e->num_inputs = 0;
	e->num_outputs = 0;
	e->num_links = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x99e8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
leaq 0x95a(%rip), %rsi       # 0xa330
movb $0x0, %al
callq 0x10c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9997
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jae 0x9a5a
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %esi
shlq $0x4, %rsi
addq %rsi, %rax
movsd (%rax), %xmm0
leaq 0x8f6(%rip), %rsi       # 0xa33e
movb $0x1, %al
callq 0x10c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x99ef
addq $0x20, %rsp
popq %rbp
retq