LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rdi), %ebp
cmpl $0x9, %ebp
ja 0x2469
movq %rsi, %r14
movq %rdi, %rbx
movl $0x124, %eax            # imm = 0x124
btl %ebp, %eax
jb 0x2435
movl $0x248, %eax            # imm = 0x248
btl %ebp, %eax
jae 0x2472
leaq 0xc09(%rip), %rdi       # 0x3030
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
jne 0x2469
jmp 0x245a
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
movl (%rbx), %ebp
movslq %ebp, %rax
leaq 0xc2c(%rip), %rcx       # 0x3090
movl (%rcx,%rax,4), %eax
movl %eax, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, %ebp
jne 0x2469
leaq 0xb9c(%rip), %rdi       # 0x301a
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
jne 0x2490
movl $0x2, (%rbx)
leaq 0xb8b(%rip), %rdi       # 0x3022
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
jne 0x24a9
movl $0x5, (%rbx)
leaq 0xb79(%rip), %rdi       # 0x3029
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
jne 0x2469
movl $0x8, %eax
jmp 0x2467
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3904(%rip), %xmm0     # 0x7008
mulsd 0x3904(%rip), %xmm0     # 0x7010
movsd 0x3904(%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 0x38e7(%rip), %xmm3     # 0x7020
cvttsd2si %xmm3, %edx
cvttpd2dq %xmm3, %xmm0
cvtdq2pd %xmm0, %xmm0
subsd %xmm0, %xmm3
mulsd 0x38d7(%rip), %xmm3     # 0x7028
cvttsd2si %xmm3, %ecx
movb $-0x1, %al
decl %edx
cmpl $0x4, %edx
ja 0x3796
leaq 0x3913(%rip), %rsi      # 0x7078
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
notb %cl
movb $-0x1, %dl
xorl %esi, %esi
jmp 0x378a
notb %cl
xorl %edx, %edx
jmp 0x3792
notb %cl
movb $-0x1, %sil
xorl %eax, %eax
jmp 0x3798
movb $-0x1, %sil
xorl %edx, %edx
movl %ecx, %eax
jmp 0x379a
movb $-0x1, %dl
xorl %eax, %eax
movl %ecx, %esi
jmp 0x379a
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_O1/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 %r14
pushq %rbx
subq $0x20, %rsp
movapd %xmm0, %xmm2
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
movaps %xmm1, %xmm0
movapd %xmm2, %xmm1
callq 0x3050
xorpd %xmm2, %xmm2
xorl %eax, %eax
movsd 0x10(%rsp,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm2
incq %rax
cmpq $0x1, %rax
je 0x37d9
movsd %xmm2, 0x8(%rsp)
callq 0x36fc
movsd 0x8(%rsp), %xmm0
movl %eax, %ebx
movl %eax, %r14d
andl $0xffffff, %r14d        # imm = 0xFFFFFF
movl %r14d, %ebp
shrl $0x10, %ebp
shrl $0x8, %r14d
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3827
sqrtsd %xmm0, %xmm0
jmp 0x382c
callq 0x3200
mulsd 0x37fc(%rip), %xmm0     # 0x7030
callq 0x3090
movl %ebx, %eax
notl %eax
movl $0xff, %ecx
andl %ecx, %eax
movl %r14d, %edx
notl %edx
andl %ecx, %edx
movl %ebp, %esi
xorl %ecx, %esi
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd %xmm0, %xmm1
movzbl %bl, %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
movsd 0x37cc(%rip), %xmm3     # 0x7038
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %eax
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm1
movzbl %r14b, %edx
xorps %xmm2, %xmm2
cvtsi2sd %edx, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %edx
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
mulsd %xmm0, %xmm1
movzbl %bpl, %esi
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
mulsd %xmm3, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %esi
shll $0x10, %esi
andl %ecx, %edx
shll $0x8, %edx
orl %esi, %edx
andl %ecx, %eax
orl %edx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x66f8(%rip), %rdi      # 0x9fe0
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x3190
cmpl $0x0, (%rbx)
jle 0x39b2
xorl %r13d, %r13d
movq 0x66d8(%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
movaps %xmm0, 0x10(%rsp)
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 0x6921(%rip), %rsi      # 0xa290
cmpq 0x6922(%rip), %rsi      # 0xa298
je 0x3995
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsi)
movapd 0x10(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x18, 0x68fd(%rip)     # 0xa290
jmp 0x39a4
leaq 0x68ec(%rip), %rdi      # 0xa288
movq %rbp, %rdx
callq 0x5560
incl %r13d
cmpl 0xc(%rsp), %r13d
jl 0x391a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4fec
movq 0x689a(%rip), %rdi      # 0xa288
cmpq %rdi, 0x689b(%rip)      # 0xa290
je 0x3b0e
xorl %r14d, %r14d
leaq 0x40(%rsp), %rbx
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
leaq (,%r14,8), %rax
leaq (%rax,%rax,2), %r12
addq %r12, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
callq 0x502a
movaps %xmm0, %xmm2
movapd %xmm1, %xmm0
movsd %xmm2, 0x50(%rsp)
movsd %xmm1, 0x58(%rsp)
movaps %xmm2, %xmm1
callq 0x3050
movsd %xmm0, 0x8(%rsp)
movq 0x6833(%rip), %rax      # 0xa288
movl 0x10(%rax,%r12), %ebp
xorl %eax, %eax
xorpd %xmm0, %xmm0
movsd 0x50(%rsp,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x1, %rax
je 0x3a60
ucomisd 0x35c1(%rip), %xmm0     # 0x7040
jb 0x3a87
sqrtsd %xmm0, %xmm0
jmp 0x3a8c
callq 0x3200
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x38(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x3470
movsd %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x3070
movsd 0x30(%rsp), %xmm1
movsd %xmm1, 0x40(%rsp)
movsd %xmm0, 0x48(%rsp)
movq %rbx, %rdi
movsd 0x38(%rsp), %xmm0
callq 0x506e
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
addpd 0x10(%rsp), %xmm0
movapd %xmm0, 0x10(%rsp)
incq %r14
movq 0x679d(%rip), %rax      # 0xa290
movq 0x678e(%rip), %rdi      # 0xa288
subq %rdi, %rax
sarq $0x3, %rax
imulq %r15, %rax
cmpq %r14, %rax
ja 0x3a0d
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x39c1
movaps %xmm0, %xmm2
movaps %xmm1, %xmm0
movaps %xmm2, %xmm1
callq 0x3050
callq 0x36fc
movsd 0x34f4(%rip), %xmm0     # 0x7048
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 0x678d(%rip), %rcx      # 0xa308
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_O1/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 0x4fec
cmpl $0x437, %ebp            # imm = 0x437
jg 0x3c3b
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 0x3b27
movsd 0x3402(%rip), %xmm0     # 0x7018
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
decl %r14d
jne 0x3bf1
addl %ebx, %ebp
cmpl $0x438, %ebp            # imm = 0x438
jl 0x3bda
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
cmpl $0x1, %esi
jne 0x3d3f
movq %rbx, -0x40(%rbp)
movq %rsp, -0x38(%rbp)
movl 0x6630(%rip), %r15d     # 0xa2a0
movq %rsp, %rbx
leaq 0xf(,%r15,8), %rax
andq $-0x10, %rax
subq %rax, %rbx
movq %rbx, %rsp
testq %r15, %r15
je 0x3c9c
leaq (,%r15,8), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3170
movl $0x0, -0x2c(%rbp)
cmpl $0x0, 0x65f6(%rip)      # 0xa2a0
jle 0x3cf4
leaq 0x65ed(%rip), %r12      # 0xa2a0
leaq -0x48(%rbp), %r13
leaq -0x2c(%rbp), %r14
movq %r13, %rdi
leaq -0x10d(%rip), %rsi      # 0x3bb8
movq %r14, %rdx
movq %r12, %rcx
callq 0x5168
movslq -0x2c(%rbp), %rax
cmpq $0x0, (%rbx,%rax,8)
jne 0x3d8a
movq -0x48(%rbp), %rcx
movq %rcx, (%rbx,%rax,8)
incl %eax
movl %eax, -0x2c(%rbp)
cmpl 0x65ae(%rip), %eax      # 0xa2a0
jl 0x3cbb
cmpl $0x0, 0x65a5(%rip)      # 0xa2a0
jle 0x3d1e
xorl %r12d, %r12d
movq %rbx, %r14
movq %r14, %rdi
callq 0x33f0
incq %r12
movslq 0x658b(%rip), %rax      # 0xa2a0
addq $0x8, %r14
cmpq %rax, %r12
jl 0x3d03
testq %r15, %r15
je 0x3d35
shlq $0x3, %r15
cmpq $0x0, -0x8(%rbx,%r15)
jne 0x3d8a
addq $-0x8, %r15
jne 0x3d27
movq -0x38(%rbp), %rsp
movq -0x40(%rbp), %rbx
jmp 0x3d4b
xorl %edi, %edi
movl $0x1, %esi
callq 0x3bb8
movq (%rbx), %rsi
leaq 0x6553(%rip), %rdi      # 0xa2a8
callq 0x5b46
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3d6b
testq %r15, %r15
je 0x3d82
shlq $0x3, %r15
cmpq $0x0, -0x8(%rbx,%r15)
jne 0x3d8a
addq $-0x8, %r15
jne 0x3d74
movq %rax, %rdi
callq 0x3430
callq 0x30b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38d3
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x22ff(%rip), %rsi      # 0x71f8
leaq 0x2304(%rip), %rdx      # 0x7204
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x54d0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3c44
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4f31
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4f53
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O1/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 0x47ac
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 0x503a(%rip), %r14      # 0x9fd0
leaq 0x2268(%rip), %rsi      # 0x7205
movl $0x16, %edx
movq %r14, %rdi
callq 0x32e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3260
leaq 0x2260(%rip), %rsi      # 0x721c
movl $0x4, %edx
movq %rax, %rdi
callq 0x32e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4ffe
testq %rdx, %rdx
jne 0x5007
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
retq
shlq $0x3, %rdx
jmp 0x33a0
pushq %rax
movl $0x4, %edi
callq 0x3140
movl $0x0, (%rax)
leaq 0x4c99(%rip), %rsi      # 0x9cb8
movq %rax, %rdi
xorl %edx, %edx
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O1/iannisdezwart[P]forcefield-visualiser/./lib/linear_algebra.hpp
// Function: Vector<2, double>::operator*(double)
Vector<size, number_type> operator*(number_type scalar)
		{
			Vector<size, number_type> new_vector;

			for (int i = 0; i < size; i++) {
				new_vector.values[i] = values[i] * scalar;
			}

			return new_vector;
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movaps %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4fec
movapd (%rsp), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movupd (%rbx), %xmm0
mulpd %xmm1, %xmm0
movapd %xmm0, (%r14)
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5214
testq %rdx, %rdx
jne 0x5238
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
jmp 0x5236
shlq $0x4, %rdx
xorl %eax, %eax
cmpq $0x2, 0x8(%rsi,%rax)
jne 0x5238
movq (%rsi,%rax), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%rdi,%rax)
addq $0x10, %rax
cmpq %rax, %rdx
jne 0x521a
popq %rax
retq
movl $0x4, %edi
callq 0x3140
movl $0x0, (%rax)
leaq 0x4a69(%rip), %rsi      # 0x9cb8
movq %rax, %rdi
xorl %edx, %edx
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x20(%rsp)
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4fec
movsd 0x8(%rsp,%r14,8), %xmm0
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm1
mulsd 0x18(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x1, %rax
je 0x528a
movsd %xmm0, 0x8(%rsp,%r14,8)
leaq 0x1(%r14), %rax
addq $0x10, %rbx
testq %r14, %r14
movq %rax, %r14
je 0x5281
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5740
movq 0x8(%rbx), %r14
cmpq 0x10(%rbx), %r14
je 0x5734
movl %ebp, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x577c
addq $0x18, %r14
cmpq 0x10(%rbx), %r14
jne 0x571f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32b0
leaq 0xa0(%rsp), %rdi
callq 0x3080
testb %al, %al
je 0x5bef
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x30, %rdi
movl $0x1, 0x1c(%rdi)
movl 0x20(%rdi), %esi
callq 0x33d0
leaq 0x10(%rsp), %rdi
movq %rbx, (%rdi)
addq $0x58, %rbx
movq %rbx, 0x8(%rdi)
leaq 0x30(%rsp), %rsi
callq 0x5f26
movq 0x4408(%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 0x3220
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 0x539a
callq 0x3030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5c88
xorl %ebp, %ebp
leaq 0x40da(%rip), %rsi      # 0x9d08
movq 0x4393(%rip), %rdx      # 0x9fc8
movq %rbx, %rdi
callq 0x3400
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5c63
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3290
jmp 0x5c63
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5c75
movq %rbx, %rdi
callq 0x31d0
jmp 0x5c75
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x3350
movq %r14, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6024
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 0x66c4
leaq 0x58(%rsp), %rdi
leaq 0x38(%r15), %rsi
callq 0x67c6
movsd 0x50(%r15), %xmm0
movq %rsp, %rdi
movsd %xmm0, 0x70(%rdi)
callq 0x6086
movq (%rbx), %rax
cmpl $0x0, 0x10(%rax)
je 0x5fa0
movq (%rsp), %rdi
callq 0x33e0
movslq %eax, %r12
jmp 0x5fa6
movl $0x1, %r12d
testq %r12, %r12
je 0x5fe9
xorl %r13d, %r13d
movq %rsp, %r14
movq (%rbx), %rax
cmpl $0x0, 0x4(%rax)
je 0x5fe1
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6190
movq %r14, %rdi
movq %rax, %rsi
callq 0x610a
incq %r15
movq (%rbx), %rax
movl 0x4(%rax), %eax
cmpq %rax, %r15
jb 0x5fbd
incq %r13
cmpq %r12, %r13
jne 0x5fb1
movq %rsp, %rdi
callq 0x61f6
movq %rsp, %rdi
callq 0x6280
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x6010
jmp 0x6010
jmp 0x6010
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6280
movq %rbx, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3480
movq %rax, %rbx
movq $0x0, 0x98(%rax)
movq 0x90(%rax), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x3270
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3320
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
je 0x6403
movq %rbx, %rdi
addq $0x90, %rdi
movq 0x98(%rbx), %rdx
leaq 0xee1(%rip), %rcx       # 0x72d7
movl $0x17, %r8d
xorl %esi, %esi
callq 0x3380
cmpq $0x0, 0x98(%rbx)
jne 0x6419
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%rbx), %rdi
movq 0x3b85(%rip), %rsi      # 0x9fa8
movl $0xc8, %edx
callq 0x32c0
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x34b0
movq %rdx, %r14
movq %rax, %rdi
callq 0x3110
cmpl $0x2, %r14d
jne 0x6466
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6634
callq 0x33b0
jmp 0x6403
callq 0x351e
movq %rax, %rbx
callq 0x33b0
movq %rbx, %rdi
callq 0x3430
movq %rax, %rdi
callq 0x5457
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3480
movq %rax, %rbx
movq $0x0, 0x98(%rax)
movq 0x90(%rax), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x3270
movq %rax, %r14
movq %rax, %rdi
callq 0x31b0
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
je 0x64ef
movq %rbx, %rdi
addq $0x90, %rdi
movq 0x98(%rbx), %rdx
leaq 0xecb(%rip), %rcx       # 0x73ad
movl $0x17, %r8d
xorl %esi, %esi
callq 0x3380
cmpq $0x0, 0x98(%rbx)
jne 0x6501
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
movq 0x3a9d(%rip), %rsi      # 0x9fa8
movl $0xc8, %edx
callq 0x32c0
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x34b0
movq %rdx, %r14
movq %rax, %rdi
callq 0x3110
cmpl $0x2, %r14d
jne 0x654e
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6634
callq 0x33b0
jmp 0x64ef
callq 0x353e
movq %rax, %rbx
callq 0x33b0
movq %rbx, %rdi
callq 0x3430
movq %rax, %rdi
callq 0x5457
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x698b
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x69aa
movq %rbx, %rdi
callq 0x69e2
cmpl $0x3, 0x24(%rbx)
jne 0x6961
movq 0x38(%rbx), %rdx
movq 0x40(%rbx), %rax
cmpq %rax, %rdx
je 0x6942
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 0x6961
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
subl %edx, %ecx
xorl %r8d, %r8d
callq 0x3230
movsd 0x68(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x697d
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x3440
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
popq %rbx
jmp 0x3180
leaq 0xaa8(%rip), %rdi       # 0x743a
leaq 0xaf4(%rip), %rsi       # 0x748d
leaq 0xb08(%rip), %rcx       # 0x74a8
movl $0x76, %edx
callq 0x31a0
leaq 0xb15(%rip), %rdi       # 0x74c6
leaq 0xad5(%rip), %rsi       # 0x748d
leaq 0xae9(%rip), %rcx       # 0x74a8
movl $0x77, %edx
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33c0
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rilutham[P]gotojakarta/go-to-jakarta.cpp
// Function: PathSearchNode::GoalDistanceEstimate(PathSearchNode&)
float PathSearchNode::GoalDistanceEstimate( PathSearchNode &nodeGoal )
{
  // goal is always Jakarta!
  switch(city)
  {
    case Garut: return 165; break;
    case Jakarta: return 0; break;
    case Tasikmalaya: return 201; break;
    case Ciamis: return 212; break;
    case Banjar: return 234; break;
    case Pangandaran: return 265; break;
    case Sumedang: return 141; break;
    case Bandung: return 132; break;
    case Cimahi: return 109; break;
    case Kuningan: return 202; break;
    case Majalengka: return 171; break;
    case Cirebon: return 201; break;
    case Indramayu: return 158; break;
    case Subang: return 111; break;
    case Karawang: return 56; break;
    case Purwakarta: return 81; break;
    case Cianjur: return 78; break;
    case Sukabumi: return 85; break;
    case Bogor: return 36; break;
    case Depok: return 22; break;
    case Bekasi: return 30; break;
  }
  cerr << "ASSERT: city = " << CityNames[city] << endl;
	return 0;
}

// Assembly:
movl (%rdi), %eax
cmpq $0x15, %rax
jae 0x138f
leaq 0x208f(%rip), %rcx      # 0x3418
movss (%rcx,%rax,4), %xmm0
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3c50(%rip), %r14      # 0x4ff0
leaq 0x1c79(%rip), %rsi      # 0x3020
movl $0xf, %edx
movq %r14, %rdi
callq 0x1120
movl (%rbx), %eax
movq 0x3d4b(%rip), %rcx      # 0x5108
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq %r14, %rdi
callq 0x1120
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x10c0
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 -0x2c(%rbp), %r15
movl $0x0, (%r15)
leaq 0x3cea(%rip), %r12      # 0x5120
xorl %r13d, %r13d
xorps %xmm0, %xmm0
movl (%r14), %eax
imulq $0x54, %rax, %rax
ucomiss (%r12,%rax), %xmm0
ja 0x145c
movl %r13d, -0x2c(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1dc0
xorps %xmm0, %xmm0
incq %r13
addq $0x4, %r12
cmpq $0x15, %r13
jne 0x143c
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2440
movq %rax, %rbx
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x1e0b
movl (%r15), %eax
movl %eax, 0x1c(%rbx)
movq 0x38(%r14), %rsi
cmpq 0x40(%r14), %rsi
je 0x1dfb
movq %rbx, (%rsi)
addq $0x8, 0x38(%r14)
jmp 0x1e0b
addq $0x30, %r14
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
callq 0x24a2
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2440
movq %rax, 0x50(%rbx)
movq %rbx, %rdi
callq 0x2440
movq %rax, 0x58(%rbx)
testq %rax, %rax
je 0x1fb2
movq 0x50(%rbx), %rcx
testq %rcx, %rcx
je 0x1fb2
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 0x1f3e
movq 0x50(%rbx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x1f4a
leaq 0x50(%rbx), %rdx
movq %rbx, %rdi
callq 0x24a2
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
movq -0x8(%rsi), %rcx
subq %rax, %rsi
sarq $0x3, %rsi
leaq -0x1(%rsi), %rdx
cmpq $0x2, %rsi
jl 0x1f99
movss 0x18(%rcx), %xmm0
leaq -0x1(%rdx), %rsi
shrq $0x3f, %rsi
addq %rdx, %rsi
decq %rsi
sarq %rsi
movq (%rax,%rsi,8), %rdi
movss 0x18(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1f99
movq %rdi, (%rax,%rdx,8)
cmpq $0x2, %rdx
movq %rsi, %rdx
jg 0x1f6b
jmp 0x1f9c
movq %rdx, %rsi
movq %rcx, (%rax,%rsi,8)
movl $0x0, 0x4c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12b2(%rip), %rdi      # 0x326b
leaq 0x12cf(%rip), %rsi      # 0x328f
leaq 0x12d5(%rip), %rcx      # 0x329c
movl $0x9d, %edx
callq 0x10a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rilutham[P]gotojakarta/./stlastar.h
// Function: AStarSearch<PathSearchNode>::FreeSolutionNodes()
void FreeSolutionNodes()
	{
		Node *n = m_Start;

		if( m_Start->child )
		{
			do
			{
				Node *del = n;
				n = n->child;
				FreeNode( del );

				del = NULL;

			} while( n != m_Goal );

			FreeNode( n ); // Delete the goal

		}
		else
		{
			// if the start node is the solution we need to just delete the start and goal
			// nodes
			FreeNode( m_Start );
			FreeNode( m_Goal );
		}

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %r14
cmpq $0x0, 0x8(%r14)
je 0x238b
leaq 0x68(%rbx), %r15
movq %r14, %rsi
movq 0x8(%r14), %r14
decl 0x98(%rbx)
movq %r15, %rdi
callq 0x2864
cmpq 0x58(%rbx), %r14
jne 0x2362
decl 0x98(%rbx)
movq %r15, %rdi
movq %r14, %rsi
jmp 0x23ad
decl 0x98(%rbx)
leaq 0x68(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2864
movq 0x58(%rbx), %rsi
decl 0x98(%rbx)
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2864
// File: /workspace/github_cpp_makefile_star2_O1/rilutham[P]gotojakarta/./stlastar.h
// Function: AStarSearch<PathSearchNode>::AllocateNode()
Node *AllocateNode()
	{

#if !USE_FSA_MEMORY
		Node *p = new Node;
		return p;
#else
		Node *address = m_FixedSizeAllocator.alloc();

		if( !address )
		{
			return NULL;
		}
		m_AllocateNodeCount ++;
		Node *p = new (address) Node;
		return p;
#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x2479
movq 0x28(%rax), %rcx
movq %rcx, 0x68(%rdi)
testq %rcx, %rcx
je 0x2462
movq $0x0, 0x20(%rcx)
movq $0x0, 0x20(%rax)
movq 0x70(%rdi), %rcx
testq %rcx, %rcx
je 0x247d
movq %rax, 0x20(%rcx)
jmp 0x247f
xorl %eax, %eax
jmp 0x2487
xorl %ecx, %ecx
movq %rcx, 0x28(%rax)
movq %rax, 0x70(%rdi)
testq %rax, %rax
je 0x249e
incl 0x98(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x24a0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rilutham[P]gotojakarta/./fsa.h
// Function: FixedSizeAllocator<AStarSearch<PathSearchNode>::Node>::FixedSizeAllocator(unsigned int)
FixedSizeAllocator( unsigned int MaxElements = FSA_DEFAULT_SIZE ) :
	m_pFirstUsed( NULL ),
	m_MaxElements( MaxElements )
	{
		// Allocate enough memory for the maximum number of elements

		char *pMem = new char[ m_MaxElements * sizeof(FSA_ELEMENT) ];

		m_pMemory = (FSA_ELEMENT *) pMem; 

		// Set the free list first pointer
		m_pFirstFree = m_pMemory;

		// Clear the memory
		memset( m_pMemory, 0, sizeof( FSA_ELEMENT ) * m_MaxElements );

		// Point at first element
		FSA_ELEMENT *pElement = m_pFirstFree;

		// Set the double linked free list
		for( unsigned int i=0; i<m_MaxElements; i++ )
		{
			pElement->pPrev = pElement-1;
			pElement->pNext = pElement+1;

			pElement++;
		}

		// first element should have a null prev
		m_pFirstFree->pPrev = NULL;
		// last element should have a null next
		(pElement-1)->pNext = NULL;

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl %esi, 0x10(%rdi)
movl %esi, %eax
shlq $0x4, %rax
leaq (%rax,%rax,2), %r12
movq %r12, %rdi
callq 0x1030
movq %rax, %r14
movq %rax, 0x18(%r15)
movq %rax, (%r15)
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x1090
movq %r14, %rax
testl %ebx, %ebx
je 0x264c
movq %r14, %rax
addq $0x30, %rax
leaq -0x60(%rax), %rcx
movq %rcx, -0x10(%rax)
movq %rax, -0x8(%rax)
addq $0x30, %rax
decl %ebx
jne 0x2634
addq $-0x30, %rax
xorl %ecx, %ecx
movq %rcx, 0x20(%r14)
movq %rcx, -0x8(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rilutham[P]gotojakarta/./stlastar.h
// Function: AStarSearch<PathSearchNode>::FreeAllNodes()
void FreeAllNodes()
	{
		// iterate open list and delete all nodes
		typename vector< Node * >::iterator iterOpen = m_OpenList.begin();

		while( iterOpen != m_OpenList.end() )
		{
			Node *n = (*iterOpen);
			FreeNode( n );

			iterOpen ++;
		}

		m_OpenList.clear();

		// iterate closed list and delete unused nodes
		typename vector< Node * >::iterator iterClosed;

		for( iterClosed = m_ClosedList.begin(); iterClosed != m_ClosedList.end(); iterClosed ++ )
		{
			Node *n = (*iterClosed);
			FreeNode( n );
		}

		m_ClosedList.clear();

		// delete the goal

		FreeNode(m_Goal);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %rax
cmpq %rax, %r15
je 0x269b
leaq 0x68(%rbx), %r14
movq (%r15), %rsi
decl 0x98(%rbx)
movq %r14, %rdi
callq 0x2864
addq $0x8, %r15
movq 0x8(%rbx), %rax
cmpq %rax, %r15
jne 0x267d
movq (%rbx), %rcx
cmpq %rcx, %rax
je 0x26a7
movq %rcx, 0x8(%rbx)
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %rax
cmpq %rax, %r15
je 0x26d6
leaq 0x68(%rbx), %r14
movq (%r15), %rsi
decl 0x98(%rbx)
movq %r14, %rdi
callq 0x2864
addq $0x8, %r15
movq 0x20(%rbx), %rax
cmpq %rax, %r15
jne 0x26b8
movq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0x26e3
movq %rcx, 0x20(%rbx)
movq 0x58(%rbx), %rsi
decl 0x98(%rbx)
addq $0x68, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2864
nop