LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::split_string_list(std::vector<char*, std::allocator<char*>>*, int)
vector<vector<char*>*>* t_string::split_string_list(vector<char*>* string_list, int n_batches)
{
	vector<vector<char*>*>* batches = new vector<vector<char*>*>();

	int n_string_per_batch = (int)string_list->size() / n_batches;
	vector<char*>* current_batch = new vector<char*>();
	batches->push_back(current_batch);
	for(int i_str = 0; i_str < (int)string_list->size(); i_str++)
	{
		if((int)current_batch->size() == n_string_per_batch)
		{
			current_batch = new vector<char*>();
			batches->push_back(current_batch);
		}

		current_batch->push_back(string_list->at(i_str));
	} // i_str loop.

	return(batches);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x18, %edi
callq 0x2160
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x10(%rax)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltd
idivl %ebp
movl %eax, %ebp
movl $0x18, %edi
callq 0x2160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r15, 0x10(%rax)
movq %rsp, %rdx
movq %rax, (%rdx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x8f18
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x69c9
xorl %r13d, %r13d
movq %rsp, %r12
xorl %r15d, %r15d
movq (%rsp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x3, %rcx
cmpl %ecx, %ebp
jne 0x6976
movl $0x18, %edi
callq 0x2160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, (%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x696b
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x6976
movq %r14, %rdi
movq %r12, %rdx
callq 0x8f18
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
subq %rdx, %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x69db
movq (%rsp), %rdi
addq %r13, %rdx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x69a7
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x69ac
callq 0x4eb6
incq %r15
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltq
addq $0x8, %r13
cmpq %rax, %r15
jl 0x6928
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f82(%rip), %rdi      # 0xa964
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::copy_tokens_2_strs(std::vector<t_string*, std::allocator<t_string*>>*)
vector<char*>* t_string::copy_tokens_2_strs(t_string_tokens* toks)
{
	vector<char*>* strs = new vector<char*>();
	for (int i_t = 0; i_t < toks->size(); i_t++)
	{
		strs->push_back(toks->at(i_t)->str());
	} // i_t loop.

	return(strs);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %edi
callq 0x2160
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x73fa
xorl %r12d, %r12d
movq %rsp, %r15
movq (%rax,%r12,8), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4016
incq %r12
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x73cb
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::remove_beginning_spaces_tabs(char*)
char* t_string::remove_beginning_spaces_tabs(char* string)
{
	int i_last_space = 0;

	int l_str = t_string::string_length(string);

	for(int i = 0; i < l_str; i++)
	{
		if(string[i] != ' ' &&
			string[i] != '\t')
		{
			i_last_space = i;
			break;
		}
	}

	char* reloc_copy = new char[l_str + 2];

	// Relocate.
	copy(reloc_copy, &string[i_last_space]);
	
	return(reloc_copy);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incl %eax
cmpb $0x0, (%rbx,%rax)
jne 0x783e
xorl %r14d, %r14d
testl %eax, %eax
jle 0x7869
movl %eax, %ecx
xorl %r12d, %r12d
movzbl (%rbx,%r12), %edx
cmpl $0x20, %edx
je 0x7861
cmpl $0x9, %edx
jne 0x786c
incq %r12
cmpq %r12, %rcx
jne 0x7852
xorl %r12d, %r12d
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, %r15
addq %r12, %rbx
movl %r14d, %r12d
incl %r14d
cmpb $0x0, (%rbx,%r12)
jne 0x787d
cmpl $0x1, %r14d
adcl $0x0, %r14d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2100
movb $0x0, (%r15,%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::compare_prefixes(char const*, char const*)
bool t_string::compare_prefixes(const char* str1, const char* str2)
{
	int i = 0;
	while(str1[i] && str2[i])
	{
		if(str1[i] != str2[i])
		{
			return(false);
		} // comparison.

		i++;
	} // i loop.

	return(true);
}

// Assembly:
movb (%rdi), %cl
movb $0x1, %al
testb %cl, %cl
je 0x8239
xorl %edx, %edx
movb (%rsi,%rdx), %r8b
testb %r8b, %r8b
je 0x8239
cmpb %r8b, %cl
jne 0x823a
movb 0x1(%rdi,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x8220
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/akdess[P]BAFExtract/src/ansi_string.cpp
// Function: t_string::ends_with(char const*, char const*)
bool t_string::ends_with(const char* full_string, const char* sub_str)
{
	if(string_length(full_string) < string_length(sub_str))
	{
		return(false);
	}

	// Go over all the characters of the sub-string and check if they match to the end of the string.
	int i_str = string_length(full_string) - 1;
	unsigned int i_sub = string_length(sub_str) - 1;
	while(1)
	{
		if(sub_str[i_sub] != full_string[i_str])
		{
			return(false);
		}

		if(i_sub == 0)
		{
			return(true);
		}
		else
		{
			i_sub--;
		}

		i_str--;		
	} // i loop.

	return(true);
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incl %eax
cmpb $0x0, (%rdi,%rax)
jne 0x848f
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
incl %ecx
cmpb $0x0, (%rsi,%rcx)
jne 0x849c
cmpl %ecx, %eax
jge 0x84ab
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incl %eax
cmpb $0x0, (%rdi,%rax)
jne 0x84b0
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
leal 0x2(%rcx), %edx
incl %ecx
cmpb $0x0, (%rsi,%rdx)
jne 0x84bd
cltq
leaq (%rdi,%rax), %rdx
decq %rdx
movl %ecx, %eax
movb (%rsi,%rax), %dil
movb (%rdx), %r8b
cmpb %r8b, %dil
sete %al
addl $-0x1, %ecx
jae 0x84ed
decq %rdx
cmpb %r8b, %dil
je 0x84d1
retq
// File: /workspace/github_cpp_makefile_star2_O3/pstuifzand[P]magento-tools/src/magento-helpers.cpp
// Function: find_code_pool(char const*)
CodePool find_code_pool(const char* filename) {
    int n         = strlen(filename);
    const char* p = filename;

    while (1) {
        if (strncmp("app/code/", p, 9) == 0) {
            p += 9;
            n -= 9;
            break;
        }
        while (n && *p != '/') { ++p; --n; }
        if (!n) break;
        ++p; --n;
    }
    if (strncmp("cor", p, 3) == 0) return CodePool::CORE;
    if (strncmp("com", p, 3) == 0) return CodePool::COMMUNITY;
    if (strncmp("loc", p, 3) == 0) return CodePool::LOCAL;
    return CodePool::ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xce7(%rip), %rdi       # 0x3004
movl $0x9, %edx
movq %rbx, %rsi
callq 0x20a0
testl %eax, %eax
je 0x2388
movq %rbx, %rdi
callq 0x2090
leaq 0xcc7(%rip), %r14       # 0x3004
testl %eax, %eax
je 0x2392
leaq 0x1(%rbx), %r15
movl $0x1, %ebp
subl %eax, %ebp
cmpb $0x2f, -0x1(%r15)
je 0x235f
incq %r15
incl %ebp
cmpl $0x1, %ebp
jne 0x234c
jmp 0x237e
movl $0x9, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x20a0
movl %eax, %ecx
negl %ebp
movq %r15, %rbx
movl %ebp, %eax
testl %ecx, %ecx
jne 0x233d
jmp 0x238b
decl %eax
addq %rax, %rbx
incq %rbx
jmp 0x2392
movq %rbx, %r15
addq $0x9, %r15
movq %r15, %rbx
movzbl (%rbx), %eax
leal -0x63(%rax), %ecx
negl %ecx
cmpl $0x63, %eax
jne 0x23dc
movzbl 0x1(%rbx), %edx
subl $0x6f, %edx
jne 0x23b5
movzbl 0x2(%rbx), %esi
movl $0x72, %edx
subl %esi, %edx
jmp 0x23b7
negl %edx
testl %edx, %edx
je 0x23d6
cmpl $0x63, %eax
jne 0x23dc
movzbl 0x1(%rbx), %ecx
subl $0x6f, %ecx
jne 0x23da
movzbl 0x2(%rbx), %edx
movl $0x6d, %ecx
subl %edx, %ecx
jmp 0x23dc
xorl %eax, %eax
jmp 0x240f
negl %ecx
testl %ecx, %ecx
je 0x240a
subl $0x6c, %eax
jne 0x23fb
movzbl 0x1(%rbx), %eax
subl $0x6f, %eax
jne 0x23fb
movzbl 0x2(%rbx), %ecx
movl $0x63, %eax
subl %ecx, %eax
jmp 0x23fd
negl %eax
cmpl $0x1, %eax
movl $0x3, %eax
sbbl $0x0, %eax
jmp 0x240f
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pstuifzand[P]magento-tools/src/magento-helpers.cpp
// Function: root_start_element_handler(void*, char const*, char const**)
void root_start_element_handler(void* udata, const XML_Char* name, const XML_Char** atts) {
    user_data* data = (user_data*)udata;

    switch (data->state) {
        case State::WAIT_FOR_SECTION: {
            if (strcmp("helpers", name) == 0) data->state = State::IN_HELPERS;
            if (strcmp("models", name) == 0) data->state = State::IN_MODELS;
            if (strcmp("blocks", name) == 0) data->state = State::IN_BLOCKS;
        } break;

        case State::IN_HELPERS:
        case State::IN_MODELS:
        case State::IN_BLOCKS: {
            // here is a tag with a variable name
            data->name.assign(name);
            data->state = start_element_next_state[int(data->state)];
        } break;

        case State::IN_HELPER:
        case State::IN_BLOCK:
        case State::IN_MODEL: {
            if (strcmp("class", name) == 0) data->state = start_element_next_state[int(data->state)];
        } break;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %r15d
cmpq $0x9, %r15
ja 0x248f
movq %rsi, %r14
movq %rdi, %rbx
movl $0x124, %eax            # imm = 0x124
btl %r15d, %eax
jb 0x245c
movl $0x248, %eax            # imm = 0x248
btl %r15d, %eax
jae 0x249b
leaq 0xbd6(%rip), %rdi       # 0x3024
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
jne 0x248f
jmp 0x2482
leaq 0x8(%rbx), %r15
movq 0x10(%rbx), %r12
movq %r14, %rdi
callq 0x2090
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x2170
movslq (%rbx), %r15
leaq 0xc07(%rip), %rax       # 0x3090
movl (%rax,%r15,4), %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x1, %r15d
jne 0x248f
leaq 0xb66(%rip), %rdi       # 0x300e
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
jne 0x24ba
movl $0x2, (%rbx)
leaq 0xb55(%rip), %rdi       # 0x3016
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
jne 0x24d3
movl $0x5, (%rbx)
leaq 0xb43(%rip), %rdi       # 0x301d
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
jne 0x248f
movl $0x8, %eax
jmp 0x248d
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./colour.hpp
// Function: angle_to_rgb(double)
png::rgb_pixel angle_to_rgb(double angle)
{
	// We convert the angle such that it becomes a number between 0 and 1.
	// Here, 0 means an angle of 0 radians, and 1 means an angle of 2 PI radians.

	double angle_ratio = (angle / M_PI) / 2; // [-0.5, 0.5]
	if (angle_ratio < 0) angle_ratio += 1; // [0, 1]

	// Now we multiply this `angle_ratio` by 6 and cast it to an int.
	// This will initialise `int angle_sector` to an integer between [0, 6].
	// The edge case `angle_sector == 6` will be handled by the switch below.

	int angle_sector = angle_ratio * 6; // [0, 6] (int)

	// We calculate how far the angle is from the `angle_sector` base.
	// We store this value into `int remaining_value` and multiply it by 255
	// to make it a pixel value.

	int remaining_value = ((angle_ratio * 6) - (double) angle_sector) * 255.0;

	// The switch will return the correct png::rgb_pixel

	switch (angle_sector) {
		case 0:
		default: // If the `angle_sector` is 6 (equivalent to 6 mod 6 == 0)
			return png::rgb_pixel(255, remaining_value, 0);
		case 1:
			return png::rgb_pixel(255 - remaining_value, 255, 0);
		case 2:
			return png::rgb_pixel(0, 255, remaining_value);
		case 3:
			return png::rgb_pixel(0, 255 - remaining_value, 255);
		case 4:
			return png::rgb_pixel(remaining_value, 0, 255);
		case 5:
			return png::rgb_pixel(255, 0, 255 - remaining_value);
	}
}

// Assembly:
divsd 0x3914(%rip), %xmm0     # 0x7008
mulsd 0x3914(%rip), %xmm0     # 0x7010
movsd 0x3914(%rip), %xmm1     # 0x7018
addsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
mulsd 0x38f7(%rip), %xmm3     # 0x7020
cvttsd2si %xmm3, %edx
cvttpd2dq %xmm3, %xmm0
cvtdq2pd %xmm0, %xmm0
subsd %xmm0, %xmm3
mulsd 0x38e7(%rip), %xmm3     # 0x7028
cvttsd2si %xmm3, %ecx
movb $-0x1, %al
decl %edx
cmpl $0x4, %edx
ja 0x3786
leaq 0x391b(%rip), %rsi      # 0x7070
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
notb %cl
movb $-0x1, %dl
xorl %esi, %esi
jmp 0x377a
notb %cl
xorl %edx, %edx
jmp 0x3782
notb %cl
movb $-0x1, %sil
xorl %eax, %eax
jmp 0x3788
movb $-0x1, %sil
xorl %edx, %edx
movl %ecx, %eax
jmp 0x378a
movb $-0x1, %dl
xorl %eax, %eax
movl %ecx, %esi
jmp 0x378a
xorl %esi, %esi
movl %ecx, %edx
movzbl %sil, %ecx
shll $0x10, %ecx
movzbl %dl, %edx
shll $0x8, %edx
orl %ecx, %edx
movzbl %al, %eax
orl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./colour.hpp
// Function: force_to_rgb(Vector<2, double>)
png::rgb_pixel force_to_rgb(Vector<2> force)
{
	// Get the angle and the length of the vector

	double angle = force.angle();

	// Calculate the corresponding hue

	png::rgb_pixel pixel = angle_to_rgb(angle);

	// Calculate the normalised force

	double normalised_force = tanh(force.length() * 20.0);

	// Set the lightness

	int inverse_red = 255 - pixel.red;
	int inverse_green = 255 - pixel.green;
	int inverse_blue = 255 - pixel.blue;

	pixel.red += inverse_red * normalised_force * 0.85;
	pixel.green += inverse_green * normalised_force * 0.85;
	pixel.blue += inverse_blue * normalised_force * 0.85;

	return pixel;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movaps %xmm1, %xmm2
movsd %xmm1, 0x8(%rsp)
movaps %xmm0, %xmm1
movsd %xmm0, (%rsp)
movaps %xmm2, %xmm0
callq 0x3050
callq 0x36ec
movl %eax, %ebx
movl %eax, %r12d
notl %r12d
movl %eax, %ebp
andl $0xffffff, %ebp         # imm = 0xFFFFFF
movl %ebp, %r14d
shrl $0x8, %r14d
movl %r14d, %r15d
notl %r15d
shrl $0x10, %ebp
movsd (%rsp), %xmm1
mulsd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
mulsd 0x3824(%rip), %xmm0     # 0x7030
callq 0x3090
movl $0xff, %ecx
andl %ecx, %r12d
andl %ecx, %r15d
movl %ebp, %edx
xorl %ecx, %edx
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
mulsd %xmm0, %xmm1
andl %ecx, %ebx
xorps %xmm2, %xmm2
cvtsi2sd %ebx, %xmm2
movsd 0x37fb(%rip), %xmm3     # 0x7038
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %eax
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
mulsd %xmm0, %xmm1
andl %ecx, %r14d
xorps %xmm2, %xmm2
cvtsi2sd %r14d, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %esi
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
shll $0x10, %edx
andl %ecx, %esi
shll $0x8, %esi
orl %edx, %esi
andl %ecx, %eax
orl %esi, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./mass.hpp
// Function: get_masses_from_user_input()
void get_masses_from_user_input()
{
	int number_of_masses;
	cin >> number_of_masses;

	for (int i = 0; i < number_of_masses; i++) {
		int x, y, weight;
		cin >> x >> y >> weight;

		Mass mass(x, y, weight);
		masses.push_back(mass);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x6726(%rip), %rdi      # 0x9fe0
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x3190
cmpl $0x0, (%rbx)
jle 0x397c
xorl %r13d, %r13d
movq 0x6706(%rip), %rbx      # 0x9fe0
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movq %rsp, %r12
leaq 0x10(%rsp), %rbp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3190
movq %rax, %rdi
movq %r15, %rsi
callq 0x3190
movq %rax, %rdi
movq %r12, %rsi
callq 0x3190
movl (%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2sdl 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl 0x4(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movq 0x694f(%rip), %rsi      # 0xa288
cmpq 0x6950(%rip), %rsi      # 0xa290
je 0x395f
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsi)
movupd 0x10(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x18, 0x692b(%rip)     # 0xa288
jmp 0x396e
leaq 0x691a(%rip), %rdi      # 0xa280
movq %rbp, %rdx
callq 0x5510
incl %r13d
cmpl 0xc(%rsp), %r13d
jl 0x38ec
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./forces.hpp
// Function: calculate_resulting_force(Vector<2, double>)
Vector<2> calculate_resulting_force(Vector<2> pixel_position)
{
	Vector<2> resulting_force;

	// For each mass ...

	for (int i = 0; i < masses.size(); i++) {
		// ... we calculate the vector from the pixel to the mass ...

		Vector<2> pixel_to_mass = masses[i].position - pixel_position;

		// ... and we calculate the angle and the inverse distance of this vector ...

		double angle = pixel_to_mass.angle();
		double inverse_distance = masses[i].weight / pixel_to_mass.length();

		// ... with these we construct a normalised `Vector<2> force_vector`,
		// which we multiply by the scalar `double inverse_distance` ...

		Vector<2> force_vector = Vector<2>::from_angle(angle) * inverse_distance;

		// ... and add the current `force_vector` to the `resulting_force`.

		resulting_force += force_vector;
	}

	return resulting_force;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4f86
movq 0x68c9(%rip), %rdi      # 0xa280
cmpq %rdi, 0x68ca(%rip)      # 0xa288
je 0x3ab4
xorl %r14d, %r14d
leaq 0x38(%rsp), %rbx
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r12d, %r12d
addq %r14, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
callq 0x4fc0
movaps %xmm0, %xmm2
movsd %xmm0, (%rsp)
movaps %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
movaps %xmm2, %xmm1
callq 0x3050
movsd %xmm0, 0x30(%rsp)
movq 0x686d(%rip), %rax      # 0xa280
xorps %xmm1, %xmm1
cvtsi2sdl 0x10(%rax,%r14), %xmm1
movsd (%rsp), %xmm2
mulsd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm3
mulsd %xmm3, %xmm3
addsd %xmm2, %xmm3
xorps %xmm2, %xmm2
sqrtsd %xmm3, %xmm2
divsd %xmm2, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x3460
movsd %xmm0, (%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x3070
movsd (%rsp), %xmm1
movsd %xmm1, 0x38(%rsp)
movsd %xmm0, 0x40(%rsp)
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x5004
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
addpd 0x10(%rsp), %xmm0
movapd %xmm0, 0x10(%rsp)
incq %r12
movq 0x67f5(%rip), %rax      # 0xa288
movq 0x67e6(%rip), %rdi      # 0xa280
subq %rdi, %rax
sarq $0x3, %rax
imulq %r15, %rax
addq $0x18, %r14
cmpq %r12, %rax
ja 0x39d9
jmp 0x3aba
movapd 0x10(%rsp), %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./rendering.hpp
// Function: render_pixel(Vector<2, double>)
void render_pixel(Vector<2> pixel_position)
{
	// Calculate the angle of the resulting force at this position ...

	Vector<2> resulting_force = calculate_resulting_force(pixel_position);
	double angle = resulting_force.angle();

	// ... and set the pixel in the image to the corresponding hue

	image[pixel_position[1]][pixel_position[0]] = angle_to_rgb(angle);
}

// Assembly:
subq $0x28, %rsp
movaps %xmm1, (%rsp)
movaps %xmm0, 0x10(%rsp)
callq 0x398b
movaps %xmm0, %xmm2
movaps %xmm1, %xmm0
movaps %xmm2, %xmm1
callq 0x3050
callq 0x36ec
movsd 0x3545(%rip), %xmm0     # 0x7040
movapd (%rsp), %xmm1
cvttsd2si %xmm1, %rcx
subsd %xmm0, %xmm1
cvttsd2si %xmm1, %rdx
movq %rcx, %rsi
sarq $0x3f, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
movq 0x67de(%rip), %rcx      # 0xa300
leaq (%rsi,%rsi,2), %rdx
movapd 0x10(%rsp), %xmm1
cvttsd2si %xmm1, %rsi
subsd %xmm0, %xmm1
cvttsd2si %xmm1, %rdi
movq %rsi, %r8
sarq $0x3f, %r8
andq %rdi, %r8
orq %rsi, %r8
movq (%rcx,%rdx,8), %rcx
leaq (%r8,%r8,2), %rdx
movw %ax, (%rcx,%rdx)
shrl $0x10, %eax
movb %al, 0x2(%rcx,%rdx)
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./rendering.hpp
// Function: render_rows(int, int)
void render_rows(int start_row, int increment)
{
	// Render each pixel of the given rows

	Vector<2> current_position;

	// Start `int y` at the `start_row` and increment it by `increment` each time

	for (int y = start_row; y < HEIGHT; y += increment) {
		current_position[1] = y;

		for (int x = 0; x < WIDTH; x++) {
			current_position[0] = x;

			// Render the current pixel

			render_pixel(current_position);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movl %edi, %ebp
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4f86
cmpl $0x437, %ebp            # imm = 0x437
jg 0x3be2
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x18(%rsp)
xorpd %xmm0, %xmm0
movl $0x780, %r14d           # imm = 0x780
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x3ace
movsd 0x345b(%rip), %xmm0     # 0x7018
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
decl %r14d
jne 0x3b98
addl %ebx, %ebp
cmpl $0x438, %ebp            # imm = 0x438
jl 0x3b81
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./rendering.hpp
// Function: render_image(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, RenderingMode)
void render_image(string file_name, RenderingMode rendering_mode)
{
	// If we're doing multithreading ...

	if (rendering_mode == MULTI_THREADED) {
		// ... store the threads in an array, ...

		thread thread_pool[number_of_threads];

		// ... start each thread ...

		for (int i = 0; i < number_of_threads; i++) {
			thread_pool[i] = thread(render_rows, i, number_of_threads);
		}

		// ... and wait until all threads finished.

		for (int i = 0; i < number_of_threads; i++) {
			thread_pool[i].join();
		}
	} else {
		// Else, let the main thread render the whole image

		render_rows(0, 1);
	}

	// Write the image

	image.write(file_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r13
cmpl $0x1, %esi
jne 0x3ce4
movq %rsp, -0x40(%rbp)
movl 0x6685(%rip), %r15d     # 0xa298
movq %rsp, %rbx
leaq 0xf(,%r15,8), %rax
andq $-0x10, %rax
subq %rax, %rbx
movq %rbx, %rsp
testq %r15, %r15
je 0x3c3f
leaq (,%r15,8), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3170
movl $0x0, -0x2c(%rbp)
cmpl $0x0, 0x664b(%rip)      # 0xa298
jle 0x3cc7
movq %r13, -0x38(%rbp)
leaq 0x663e(%rip), %r12      # 0xa298
leaq -0x48(%rbp), %r13
leaq -0x2c(%rbp), %r14
movq %r13, %rdi
leaq -0x10d(%rip), %rsi      # 0x3b5f
movq %r14, %rdx
movq %r12, %rcx
callq 0x50f4
movslq -0x2c(%rbp), %rax
cmpq $0x0, (%rbx,%rax,8)
jne 0x3d30
movq -0x48(%rbp), %rcx
movq %rcx, (%rbx,%rax,8)
leal 0x1(%rax), %ecx
movl %ecx, -0x2c(%rbp)
movl 0x65fe(%rip), %eax      # 0xa298
cmpl %eax, %ecx
jl 0x3c62
testl %eax, %eax
movq -0x38(%rbp), %r13
jle 0x3cc7
xorl %r12d, %r12d
movq %rbx, %r14
movq %r14, %rdi
callq 0x33e0
incq %r12
movslq 0x65da(%rip), %rax      # 0xa298
addq $0x8, %r14
cmpq %rax, %r12
jl 0x3cac
testq %r15, %r15
je 0x3cde
shlq $0x3, %r15
cmpq $0x0, -0x8(%rbx,%r15)
jne 0x3d30
addq $-0x8, %r15
jne 0x3cd0
movq -0x40(%rbp), %rsp
jmp 0x3cf0
xorl %edi, %edi
movl $0x1, %esi
callq 0x3b5f
movq (%r13), %rsi
leaq 0x65a5(%rip), %rdi      # 0xa2a0
callq 0x5afc
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3d11
testq %r15, %r15
je 0x3d28
shlq $0x3, %r15
cmpq $0x0, -0x8(%rbx,%r15)
jne 0x3d30
addq $-0x8, %r15
jne 0x3d1a
movq %rax, %rdi
callq 0x3420
callq 0x30b0
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./motion.hpp
// Function: motion::render_image_from_user_input()
void render_image_from_user_input()
	{
		// Get the masses from stdin

		get_masses_from_user_input();

		// Render the image

		render_image("output/1.png", MULTI_THREADED);
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0x38a5
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2355(%rip), %rsi      # 0x71e8
leaq 0x235a(%rip), %rdx      # 0x71f4
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x547a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3beb
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4ecb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4eed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/index.cpp
// Function: main
int main()
{
	// Store the current timestamp to measure the execution time

	auto start = chrono::high_resolution_clock::now();

	// Replace this function with what you want to render
	// Some example functions are written in `motion.hpp`

	motion::four_body();

	// Print the execution time

	auto stop = chrono::high_resolution_clock::now();
	auto duration = chrono::duration_cast<chrono::milliseconds>(stop - start);

	cout << "Total execution time: " << duration.count() << " ms\n";
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x3040
movq %rax, %rbx
callq 0x475c
callq 0x3040
subq %rbx, %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rbx
shrq $0x3f, %rbx
sarq $0x12, %rdx
addq %rdx, %rbx
movq 0x50a0(%rip), %r14      # 0x9fd0
leaq 0x22be(%rip), %rsi      # 0x71f5
movl $0x16, %edx
movq %r14, %rdi
callq 0x32d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3250
leaq 0x22b6(%rip), %rsi      # 0x720c
movl $0x4, %edx
movq %rax, %rdi
callq 0x32d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./lib/linear_algebra.hpp
// Function: Vector<2, double>::Vector(std::initializer_list<double>)
Vector(initializer_list<number_type> initial_values = {})
		{
			if (initial_values.size() > 0) {
				if (initial_values.size() != size) throw WRONG_DIMENSION;
				copy(initial_values.begin(), initial_values.end(), values);
			} else {
				for (int i = 0; i < size; i++) {
					values[i] = 0;
				}
			}
		}

// Assembly:
cmpq $0x2, %rdx
je 0x4f96
testq %rdx, %rdx
jne 0x4f9d
xorps %xmm0, %xmm0
jmp 0x4f99
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
retq
pushq %rax
movl $0x4, %edi
callq 0x3140
movl $0x0, (%rax)
leaq 0x4d03(%rip), %rsi      # 0x9cb8
movq %rax, %rdi
xorl %edx, %edx
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./lib/linear_algebra.hpp
// Function: Matrix<2, 2, double>::Matrix(std::initializer_list<std::initializer_list<double>>)
Matrix(initializer_list<initializer_list<number_type>> initial_rows = {})
		{
			if (initial_rows.size() > 0) {
				if (initial_rows.size() != rows) throw WRONG_DIMENSION;

				int row = 0;

				for (auto initial_columns : initial_rows) {
					if (initial_columns.size() != columns) {
						throw WRONG_DIMENSION;
					} else {
						copy(initial_columns.begin(), initial_columns.end(), values[row]);
					}

					row++;
				}
			} else {
				for (int y = 0; y < rows; y++) {
					for (int x = 0; x < columns; x++) {
						values[y][x] = 0;
					}
				}
			}
		}

// Assembly:
pushq %rax
cmpq $0x2, %rdx
je 0x5190
testq %rdx, %rdx
jne 0x51b4
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
jmp 0x51b2
cmpq $0x2, 0x8(%rsi)
jne 0x51b4
movq (%rsi), %rax
movups (%rax), %xmm0
movups %xmm0, (%rdi)
cmpq $0x2, 0x18(%rsi)
jne 0x51b4
movq 0x10(%rsi), %rax
movups (%rax), %xmm0
movups %xmm0, 0x10(%rdi)
popq %rax
retq
movl $0x4, %edi
callq 0x3140
movl $0x0, (%rax)
leaq 0x4aed(%rip), %rsi      # 0x9cb8
movq %rax, %rdi
xorl %edx, %edx
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./lib/linear_algebra.hpp
// Function: Vector<2, double> Matrix<2, 2, double>::operator*<2>(Vector<2, double>)
Vector<dimension, number_type> operator*(Vector<dimension, number_type> vector)
		{
			if (dimension != columns) throw WRONG_DIMENSION;

			Vector<dimension> output_vector;

			for (int i = 0; i < rows; i++) {
				for (int j = 0; j < dimension; j++) {
					output_vector[i] += values[i][j] * vector[j];
				}
			}

			return output_vector;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4f86
movsd (%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
movb $0x1, %cl
leaq 0x18(%rsp), %rax
movsd (%r14), %xmm0
shlq $0x4, %r15
addq %rbx, %r15
movb $0x1, %dl
movapd %xmm3, %xmm1
xorl %esi, %esi
mulsd (%r15,%rsi,8), %xmm1
addsd %xmm1, %xmm0
movl $0x1, %esi
movaps %xmm2, %xmm1
testb $0x1, %dl
movl $0x0, %edx
jne 0x5227
movsd %xmm0, (%r14)
movl $0x1, %r15d
movq %rax, %r14
testb $0x1, %cl
movl $0x0, %ecx
jne 0x5213
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./lib/png++-0.2.9/pixel_buffer.hpp
// Function: png::basic_pixel_buffer<png::basic_rgb_pixel<unsigned char>, std::vector<png::basic_rgb_pixel<unsigned char>, std::allocator<png::basic_rgb_pixel<unsigned char>>>, png::row_traits<std::vector<png::basic_rgb_pixel<unsigned char>, std::allocator<png::basic_rgb_pixel<unsigned char>>>>>::resize(unsigned int, unsigned int)
void resize(uint_32 width, uint_32 height)
        {
            m_width = width;
            m_height = height;
            m_rows.resize(height);
            for (typename row_vec::iterator r = m_rows.begin();
                 r != m_rows.end();
                 ++r)
            {
                r->resize(width);
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
addq $0x8, %rdi
movl %edx, %esi
callq 0x56f0
movq 0x8(%rbx), %r14
cmpq 0x10(%rbx), %r14
je 0x56e4
movl %ebp, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x572c
addq $0x18, %r14
cmpq 0x10(%rbx), %r14
jne 0x56cf
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./lib/png++-0.2.9/image.hpp
// Function: png::image<png::basic_rgb_pixel<unsigned char>, png::pixel_buffer<png::basic_rgb_pixel<unsigned char>>>::write(char const*)
void write(char const* filename)
        {
            std::ofstream stream(filename, std::ios::binary);
            if (!stream.is_open())
            {
                throw std_error(filename);
            }
            stream.exceptions(std::ios::badbit);
            write_stream(stream);
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
movl $0x4, %edx
callq 0x32a0
leaq 0xa0(%rsp), %rdi
callq 0x3080
testb %al, %al
je 0x5ba5
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x30, %rdi
movl $0x1, 0x1c(%rdi)
movl 0x20(%rdi), %esi
callq 0x33c0
leaq 0x10(%rsp), %rdi
movq %rbx, (%rdi)
addq $0x58, %rbx
movq %rbx, 0x8(%rdi)
leaq 0x30(%rsp), %rsi
callq 0x5ede
movq 0x4452(%rip), %rax      # 0x9fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x38(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x30(%rsp,%rcx)
callq 0x3210
leaq 0x128(%rsp), %rdi
callq 0x30e0
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3140
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x533e
callq 0x3030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5c3a
xorl %ebp, %ebp
leaq 0x4124(%rip), %rsi      # 0x9d08
movq 0x43dd(%rip), %rdx      # 0x9fc8
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5c11
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
testb %bpl, %bpl
jne 0x5c1b
jmp 0x5c28
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d0
jmp 0x5c28
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x3340
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./lib/png++-0.2.9/generator.hpp
// Function: void png::generator<png::basic_rgb_pixel<unsigned char>, png::image<png::basic_rgb_pixel<unsigned char>, png::pixel_buffer<png::basic_rgb_pixel<unsigned char>>>::pixel_generator, png::image_info_ref_holder, true>::write<std::basic_ofstream<char, std::char_traits<char>>>(std::basic_ofstream<char, std::char_traits<char>>&)
void write(ostream& stream)
        {
            writer< ostream > wr(stream);
            wr.set_image_info(this->get_info());
            wr.write_info();

#if __BYTE_ORDER == __LITTLE_ENDIAN
            if (pixel_traits< pixel >::get_bit_depth() == 16)
            {
#ifdef PNG_WRITE_SWAP_SUPPORTED
                wr.set_swap();
#else
                throw error("Cannot write 16-bit image: recompile with PNG_WRITE_SWAP_SUPPORTED.");
#endif
            }
#endif

            size_t pass_count;
            if (this->get_info().get_interlace_type() != interlace_none)
            {
#ifdef PNG_WRITE_INTERLACING_SUPPORTED
                if (interlacing_supported)
                {
                    pass_count = wr.set_interlace_handling();
                }
                else
                {
                    throw std::logic_error("Cannot write interlaced image: generator does not support it.");
                }
#else
                throw error("Cannot write interlaced image: interlace handling disabled.");
#endif
            }
            else
            {
                pass_count = 1;
            }
            pixgen* pixel_gen = static_cast< pixgen* >(this);
            for (size_t pass = 0; pass < pass_count; ++pass)
            {
                pixel_gen->reset(pass);

                for (uint_32 pos = 0; pos < this->get_info().get_height(); ++pos)
                {
                    wr.write_row(pixel_gen->get_next_row(pos));
                }
            }

            wr.write_end_info();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x5fda
movq (%rbx), %r15
movups (%r15), %xmm0
movups 0xc(%r15), %xmm1
movups %xmm1, 0x2c(%r14)
movups %xmm0, 0x20(%r14)
leaq 0x40(%rsp), %rdi
leaq 0x20(%r15), %rsi
callq 0x667a
leaq 0x58(%rsp), %rdi
leaq 0x38(%r15), %rsi
callq 0x677e
movsd 0x50(%r15), %xmm0
movq %rsp, %rdi
movsd %xmm0, 0x70(%rdi)
callq 0x603c
movq (%rbx), %rax
cmpl $0x0, 0x10(%rax)
je 0x5f5c
movq (%rsp), %rdi
callq 0x33d0
testl %eax, %eax
je 0x5fa0
movslq %eax, %r12
jmp 0x5f62
movl $0x1, %r12d
movq (%rbx), %rax
xorl %r13d, %r13d
movq %rsp, %r14
cmpl $0x0, 0x4(%rax)
je 0x5f98
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6146
movq %r14, %rdi
movq %rax, %rsi
callq 0x60c0
incq %r15
movq (%rbx), %rax
movl 0x4(%rax), %ecx
cmpq %rcx, %r15
jb 0x5f74
incq %r13
cmpq %r12, %r13
jne 0x5f6b
movq %rsp, %rdi
callq 0x61ac
movq %rsp, %rdi
callq 0x6236
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5fc7
jmp 0x5fc7
jmp 0x5fc7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6236
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./lib/png++-0.2.9/writer.hpp
// Function: png::writer<std::basic_ofstream<char, std::char_traits<char>>>::write_data(png_struct_def*, unsigned char*, unsigned long)
static void write_data(png_struct* png, byte* data, png_size_t length)
        {
            io_base* io = static_cast< io_base* >(png_get_error_ptr(png));
            writer* wr = static_cast< writer* >(io);
            wr->reset_error();
            ostream* stream = reinterpret_cast< ostream* >(png_get_io_ptr(png));
            try
            {
                stream->write(reinterpret_cast< char* >(data), length);
                if (!stream->good())
                {
                    wr->set_error("ostream::write() failed");
                }
            }
            catch (std::exception const& error)
            {
                wr->set_error(error.what());
            }
            catch (...)
            {
                assert(!"caught something wrong");
                wr->set_error("write_data: caught something wrong");
            }
            if (wr->is_error())
            {
                wr->raise_error();
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x3470
movq %rax, %rbx
movq $0x0, 0x98(%rax)
movq 0x90(%rax), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x3260
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3310
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
je 0x63b9
movq %rbx, %rdi
addq $0x90, %rdi
movq 0x98(%rbx), %rdx
leaq 0xf1b(%rip), %rcx       # 0x72c7
movl $0x17, %r8d
xorl %esi, %esi
callq 0x3370
cmpq $0x0, 0x98(%rbx)
jne 0x63cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%rbx), %rdi
movq 0x3bcf(%rip), %rsi      # 0x9fa8
movl $0xc8, %edx
callq 0x32b0
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x34a0
movq %rdx, %r14
movq %rax, %rdi
callq 0x3110
cmpl $0x2, %r14d
jne 0x641c
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x65ea
callq 0x33a0
jmp 0x63b9
callq 0x350e
movq %rax, %rbx
callq 0x33a0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x5401
nop
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./lib/png++-0.2.9/writer.hpp
// Function: png::writer<std::basic_ofstream<char, std::char_traits<char>>>::flush_data(png_struct_def*)
static void flush_data(png_struct* png)
        {
            io_base* io = static_cast< io_base* >(png_get_error_ptr(png));
            writer* wr = static_cast< writer* >(io);
            wr->reset_error();
            ostream* stream = reinterpret_cast< ostream* >(png_get_io_ptr(png));
            try
            {
                stream->flush();
                if (!stream->good())
                {
                    wr->set_error("ostream::flush() failed");
                }
            }
            catch (std::exception const& error)
            {
                wr->set_error(error.what());
            }
            catch (...)
            {
                assert(!"caught something wrong");
                wr->set_error("flush_data: caught something wrong");
            }
            if (wr->is_error())
            {
                wr->raise_error();
            }
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3470
movq %rax, %rbx
movq $0x0, 0x98(%rax)
movq 0x90(%rax), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x3260
movq %rax, %r14
movq %rax, %rdi
callq 0x31b0
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
je 0x64a5
movq %rbx, %rdi
addq $0x90, %rdi
movq 0x98(%rbx), %rdx
leaq 0xf05(%rip), %rcx       # 0x739d
movl $0x17, %r8d
xorl %esi, %esi
callq 0x3370
cmpq $0x0, 0x98(%rbx)
jne 0x64b7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
movq 0x3ae7(%rip), %rsi      # 0x9fa8
movl $0xc8, %edx
callq 0x32b0
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x34a0
movq %rdx, %r14
movq %rax, %rdi
callq 0x3110
cmpl $0x2, %r14d
jne 0x6504
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x65ea
callq 0x33a0
jmp 0x64a5
callq 0x352e
movq %rax, %rbx
callq 0x33a0
movq %rbx, %rdi
callq 0x3420
movq %rax, %rdi
callq 0x5401
nop
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./lib/png++-0.2.9/info.hpp
// Function: png::info::write() const
void write() const
        {
            assert(m_png);
            assert(m_info);

            sync_ihdr();
            if (m_color_type == color_type_palette)
            {
                if (! m_palette.empty())
                {
                    png_set_PLTE(m_png, m_info,
                                 const_cast< color* >(& m_palette[0]),
                                 (int) m_palette.size());
                }
                if (! m_tRNS.empty())
                {
#ifdef PNG_tRNS_SUPPORTED
                    png_set_tRNS(m_png, m_info,
                                 const_cast< byte* >(& m_tRNS[0]),
                                 m_tRNS.size(),
                                 NULL);
#else
                    throw error("attempted to write tRNS chunk; recompile with PNG_tRNS_SUPPORTED");
#endif
                }
            }

            if (m_gamma > 0)
            {
#ifdef PNG_gAMA_SUPPORTED
#ifdef PNG_FLOATING_POINT_SUPPORTED
                png_set_gAMA(m_png, m_info, m_gamma);
#else
                png_set_gAMA_fixed(m_png, m_info,
                                   (png_fixed_point)(m_gamma * 100000));
#endif
#else
                throw error("attempted to write gAMA chunk; recompile with PNG_gAMA_SUPPORTED");
#endif
            }

            png_write_info(m_png, m_info);
        }

// Assembly:
pushq %rbx
cmpq $0x0, 0x8(%rdi)
je 0x6951
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x6970
movq %rbx, %rdi
callq 0x69a8
cmpl $0x3, 0x24(%rbx)
jne 0x6927
movq 0x38(%rbx), %rdx
movq 0x40(%rbx), %rax
cmpq %rax, %rdx
je 0x6908
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
subl %edx, %eax
imull $0xaaaaaaab, %eax, %ecx # imm = 0xAAAAAAAB
callq 0x30c0
movq 0x50(%rbx), %rdx
movq 0x58(%rbx), %rcx
cmpq %rcx, %rdx
je 0x6927
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
subl %edx, %ecx
xorl %r8d, %r8d
callq 0x3220
movsd 0x68(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x6943
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x3430
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
popq %rbx
jmp 0x3180
leaq 0xad2(%rip), %rdi       # 0x742a
leaq 0xb1e(%rip), %rsi       # 0x747d
leaq 0xb32(%rip), %rcx       # 0x7498
movl $0x76, %edx
callq 0x31a0
leaq 0xb3f(%rip), %rdi       # 0x74b6
leaq 0xaff(%rip), %rsi       # 0x747d
leaq 0xb13(%rip), %rcx       # 0x7498
movl $0x77, %edx
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/iannisdezwart[P]forcefield-visualiser/./lib/png++-0.2.9/info.hpp
// Function: png::info::sync_ihdr() const
void sync_ihdr(void) const
        {
            png_set_IHDR(m_png,
                         m_info,
                         m_width,
                         m_height,
                         m_bit_depth,
                         m_color_type,
                         m_interlace_type,
                         m_compression_type,
                         m_filter_type);
        }

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rsi
movl 0x18(%rdi), %edx
movl 0x1c(%rdi), %ecx
movl 0x20(%rdi), %r8d
movl 0x24(%rdi), %r9d
movl 0x28(%rdi), %r10d
movl 0x2c(%rdi), %r11d
movl 0x30(%rdi), %ebx
subq $0x8, %rsp
movq %rax, %rdi
pushq %rbx
pushq %r11
pushq %r10
callq 0x33b0
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rilutham[P]gotojakarta/go-to-jakarta.cpp
// Function: PathSearchNode::GetSuccessors(AStarSearch<PathSearchNode>*, PathSearchNode*)
bool PathSearchNode::GetSuccessors( AStarSearch<PathSearchNode> *astarsearch, PathSearchNode *parent_node )
{
  PathSearchNode NewNode;
  for(int c=0; c<MAX_CITIES; c++)
  {
    if(WestJavaMap[city][c] < 0) continue;
    NewNode = PathSearchNode((ENUM_CITIES)c);
    astarsearch->AddSuccessor( NewNode );
  }
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3cf5(%rip), %r12      # 0x5120
xorl %r13d, %r13d
xorps %xmm0, %xmm0
leaq -0x2c(%rbp), %r15
movl (%r14), %eax
imulq $0x54, %rax, %rax
ucomiss (%r12,%rax), %xmm0
ja 0x1455
movl %r13d, -0x2c(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1d80
xorps %xmm0, %xmm0
incq %r13
addq $0x4, %r12
cmpq $0x15, %r13
jne 0x1435
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rilutham[P]gotojakarta/./stlastar.h
// Function: AStarSearch<PathSearchNode>::AddSuccessor(PathSearchNode&)
bool AddSuccessor( UserState &State )
	{
		Node *node = AllocateNode();

		if( node )
		{
			node->m_UserState = State;

			m_Successors.push_back( node );

			return true;
		}

		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
callq 0x23b0
movq %rax, %rbx
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x1dcb
movl (%r15), %eax
movl %eax, 0x1c(%rbx)
movq 0x38(%r14), %rsi
cmpq 0x40(%r14), %rsi
je 0x1dbb
movq %rbx, (%rsi)
addq $0x8, 0x38(%r14)
jmp 0x1dcb
addq $0x30, %r14
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
callq 0x2402
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rilutham[P]gotojakarta/./stlastar.h
// Function: AStarSearch<PathSearchNode>::SetStartAndGoalStates(PathSearchNode&, PathSearchNode&)
void SetStartAndGoalStates( UserState &Start, UserState &Goal )
	{
		m_CancelRequest = false;

		m_Start = AllocateNode();
		m_Goal = AllocateNode();

		assert((m_Start != NULL && m_Goal != NULL));
		
		m_Start->m_UserState = Start;
		m_Goal->m_UserState = Goal;

		m_State = SEARCH_STATE_SEARCHING;
		
		// Initialise the AStar specific parts of the Start Node
		// The user only needs fill out the state information

		m_Start->g = 0; 
		m_Start->h = m_Start->m_UserState.GoalDistanceEstimate( m_Goal->m_UserState );
		m_Start->f = m_Start->g + m_Start->h;
		m_Start->parent = 0;

		// Push the start node on the Open list

		m_OpenList.push_back( m_Start ); // heap now unsorted

		// Sort back element into heap
		push_heap( m_OpenList.begin(), m_OpenList.end(), HeapCompare_f() );

		// Initialise counter for search steps
		m_Steps = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb $0x0, 0x9c(%rdi)
callq 0x23b0
movq %rax, 0x50(%rbx)
movq %rbx, %rdi
callq 0x23b0
movq %rax, 0x58(%rbx)
testq %rax, %rax
je 0x1f70
movq 0x50(%rbx), %rcx
testq %rcx, %rcx
je 0x1f70
leaq 0x1c(%rcx), %rdi
movl (%r15), %edx
movl %edx, 0x1c(%rcx)
movl (%r14), %edx
movl %edx, 0x1c(%rax)
movl $0x1, 0x48(%rbx)
movl $0x0, 0x10(%rcx)
callq 0x137a
movq 0x50(%rbx), %rax
movss %xmm0, 0x14(%rax)
addss 0x10(%rax), %xmm0
movss %xmm0, 0x18(%rax)
movq $0x0, (%rax)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1f05
movq 0x50(%rbx), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1f15
leaq 0x50(%rbx), %rdx
movq %rbx, %rdi
callq 0x2402
movq 0x8(%rbx), %rsi
movq (%rbx), %rax
movq -0x8(%rsi), %rcx
subq %rax, %rsi
sarq $0x3, %rsi
leaq -0x1(%rsi), %rdx
cmpq $0x2, %rsi
jl 0x1f5a
movss 0x18(%rcx), %xmm0
leaq -0x1(%rdx), %rsi
movq %rsi, %rdi
shrq %rdi
movq (%rax,%rdi,8), %r8
movss 0x18(%r8), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1f5a
movq %r8, (%rax,%rdx,8)
movq %rdi, %rdx
cmpq $0x1, %rsi
ja 0x1f32
xorl %edx, %edx
movq %rcx, (%rax,%rdx,8)
movl $0x0, 0x4c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12f4(%rip), %rdi      # 0x326b
leaq 0x1311(%rip), %rsi      # 0x328f
leaq 0x1317(%rip), %rcx      # 0x329c
movl $0x9d, %edx
callq 0x10a0
nop