LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: tunnel_walk(manifold*, tetra*, int)
tetra *tunnel_walk(manifold *M, tetra *current, int layer_number)
{
	for (int i = 0; i < 3; i++)
	{
		if (current->get_gluedto(i) != NULL)
			continue;  // Stop us going backwards.
		
		current->walk_about(i);
		
		if (current->get_gluedto(i)->get_layer() != layer_number) 
			current->ungluesym(i);  // Nope, don't want to go out of the layer.
		else if (current->get_gluedto(i)->get_category() == current->get_gluedto(3)->get_category())
		{
			tetra *next_tetra = new tetra(M, filler);
			current->subbedby(next_tetra, i, perm_walk_list[i]);
			current->walk_about(i);
			current = next_tetra;
			break;
		}
		else
			current->ungluesym(i);  // Nope, don't want to go that way.
	}
	return current;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0xd60c(%rip), %r15      # 0x1e650
xorl %r14d, %r14d
cmpq $0x0, 0x10(%rbx,%r14,8)
jne 0x1107e
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe318
movq 0x10(%rbx,%r14,8), %rax
cmpl %ebp, 0x90(%rax)
jne 0x11073
movl 0x70(%rax), %eax
movq 0x28(%rbx), %rcx
cmpl 0x70(%rcx), %eax
je 0x110a0
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe13e
incq %r14
addq $0x10, %r15
cmpq $0x3, %r14
jne 0x11047
movq %rbx, %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xc0, %edi
callq 0x3210
movq %rax, %r13
movq $0x0, (%rsp)
movq %rax, %rdi
movq %r12, %rsi
movl $0x7, %edx
movl $0x3, %ecx
movl $0x2, %r8d
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0xde5c
movq %rbx, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %r15, %rcx
callq 0xe200
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe318
jmp 0x1108e
movq %rax, %rbx
movl $0xc0, %esi
movq %r13, %rdi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: boundary_walk(manifold*, tetra*, int)
tetra *boundary_walk(manifold *M, tetra *current, int layer_number)
{
	for (int i = 0; i < 3; i++)
	{
		if (current->get_gluedto(i) != NULL)
			continue;  // Stop us going backwards.
		
		current->walk_about(i);
		
		if (current->get_gluedto(i)->get_category() == marker)  // Good, we hit a marker we put in at the start.
		{
			return current->get_gluedto(i);  // We've already glued current to the marker, so just return it.
		}
		else if (current->get_gluedto(i)->get_layer() != layer_number)
			current->ungluesym(i);  // Nope, don't want to go out of the layer.
		else if (current->get_gluedto(i)->get_category() != gadget_pup)
		{
			tetra *next_tetra = new tetra(M, filler);
			current->subbedby(next_tetra, i, perm_walk_list[i]);
			current->walk_about(i);
			current = next_tetra;
			break;
		}
		else
			current->ungluesym(i);  // Nope, don't want to go that way.
	}
	return current;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0xd52a(%rip), %r15      # 0x1e650
xorl %r14d, %r14d
cmpq $0x0, 0x10(%rbx,%r14,8)
jne 0x1116d
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe318
movq 0x10(%rbx,%r14,8), %r13
movl 0x70(%r13), %eax
cmpl $0x8, %eax
je 0x111d1
cmpl %ebp, 0x90(%r13)
setne %cl
cmpl $0x6, %eax
sete %al
orb %cl, %al
je 0x1117f
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe13e
incq %r14
addq $0x10, %r15
cmpq $0x3, %r14
jne 0x11129
movq %rbx, %r13
jmp 0x111d1
movl $0xc0, %edi
callq 0x3210
movq %rax, %r13
movq $0x0, (%rsp)
movq %rax, %rdi
movq %r12, %rsi
movl $0x7, %edx
movl $0x3, %ecx
movl $0x2, %r8d
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0xde5c
movq %rbx, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %r15, %rcx
callq 0xe200
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe318
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0xc0, %esi
movq %r13, %rdi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: manifold::manifold(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Manifold_type)
manifold::manifold(std::string name_in, Manifold_type mytype)
{
	output_debugging("manifold", 2);
	
	name = name_in;
	manifold_type = mytype;
	num_layers = 0;
	num_cusps = 0;
	
	first_tetra = NULL;
	last_tetra = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
leaq 0x28(%rdi), %r12
movq %r12, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
leaq 0x18(%rsp), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movq %r13, -0x10(%r13)
leaq 0x60fb(%rip), %rsi      # 0x178c6
leaq 0x60fc(%rip), %rdx      # 0x178ce
leaq 0x8(%rsp), %rdi
callq 0x892e
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x4229
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11802
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3150
movl %ebp, 0x10(%r14)
movq $0x0, 0x38(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1184d
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11850
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
jmp 0x11850
movq %rax, %r15
leaq 0x40(%r14), %r13
movq 0x58(%r14), %rdi
testq %rdi, %rdi
je 0x11869
movq 0x68(%r14), %rsi
subq %rdi, %rsi
callq 0x3220
movq (%r13), %rdi
testq %rdi, %rdi
je 0x1187e
movq 0x50(%r14), %rsi
subq %rdi, %rsi
callq 0x3220
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x11892
movq (%r12), %rsi
incq %rsi
callq 0x3220
movq %r15, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: manifold::~manifold()
manifold::~manifold()
{
	output_debugging("demanifold", 2);
	
	// Repeatedly remove the first tetrahedra until there's nothing left.
	while (first_tetra)
		oneless(first_tetra);
	
	for (int i = 0; i < int(cubes.size()); i++)
		delete cubes[i];
	
	return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x5e1c(%rip), %rsi      # 0x176d0
leaq 0x5e1f(%rip), %rdx      # 0x176da
leaq 0x8(%rsp), %rdi
callq 0x892e
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x4229
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x118eb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x118fd
movq %rbx, %rdi
callq 0x11992
jmp 0x118eb
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rax
subq %rdi, %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x1193a
xorl %r14d, %r14d
movq (%rdi,%r14,8), %rdi
movl $0x40, %esi
callq 0x3220
incq %r14
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rax
subq %rdi, %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r14
jl 0x11913
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0x11956
movq 0x68(%rbx), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x3220
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x11967
movq 0x50(%rbx), %rsi
subq %rdi, %rsi
callq 0x3220
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x1197f
movq (%rbx), %rsi
incq %rsi
callq 0x3220
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x11989
movq %rax, %rdi
callq 0x8922
nop
// File: /workspace/github_cpp_makefile_star2_O3/MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: manifold::oneless(tetra*)
void manifold::oneless(tetra *oldguy)
{
	// 1) Unglue each face.
	for (int i = 0; i < 4; i++)
		oldguy->ungluesym(i);
	
	// Maintain the doubly linked list.
	// 2a) Go to prev and fix next, go to next and fix prev.
	// 2b) Fix first and last (if needed).
	if (oldguy->get_prev() != NULL) 
		oldguy->get_prev()->set_next(oldguy->get_next()); 
	else 
		first_tetra = oldguy->get_next();
	
	if (oldguy->get_next() != NULL) 
		oldguy->get_next()->set_prev(oldguy->get_prev());
	else 
		last_tetra = oldguy->get_prev();
	
	// 3) Delete the oldguy.
	delete oldguy;
	
	return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xe13e
incl %ebp
cmpl $0x4, %ebp
jne 0x1199e
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
movq %rcx, %rdx
cmoveq %r14, %rdx
movq %rax, (%rdx)
testq %rax, %rax
cmoveq %r14, %rax
movq %rcx, 0x8(%rax)
callq 0xdff8
movl $0xc0, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: edge_degree(tetra*, int, int)
int edge_degree(tetra *basepoint, int a, int b)
{
	// c and d are the indices of the other two vertices.
	int c = (a+1) % 4;
	if (c == b) c = (c+1) % 4;
	int d = 6 - (a + b + c);
	
	tetra *current = basepoint;
	int current_c = c;
	int current_d = d;
	int count = 0;
	do
	{
		perm p = current->get_gluing(current_c);
		current = current->get_gluedto(current_c);
		int old_d = current_d;
		current_d = p[current_c];
		current_c = p[old_d];
		count++;
	} while (!((current == basepoint) && (current_c == c) && (current_d == d)));
	
	return count;
}

// Assembly:
leal 0x1(%rsi), %eax
leal 0x4(%rsi), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $-0x4, %ecx
negl %ecx
addl %esi, %ecx
incl %ecx
cmpl %edx, %ecx
jne 0x11bda
leal 0x1(%rdx), %eax
movl %eax, %ecx
sarb $0x7, %cl
shrb $0x6, %cl
addb %al, %cl
andb $-0x4, %cl
subb %cl, %al
movsbl %al, %ecx
addl %edx, %esi
addl %ecx, %esi
movl $0x6, %edx
subl %esi, %edx
xorl %eax, %eax
movq %rdi, %rsi
movl %ecx, %r8d
movl %edx, %r9d
movslq %r8d, %r8
movq %r8, %r10
shlq $0x4, %r10
movups 0x30(%rsi,%r10), %xmm0
movaps %xmm0, -0x18(%rsp)
movq 0x10(%rsi,%r8,8), %rsi
movslq %r9d, %r10
movl -0x18(%rsp,%r8,4), %r9d
movl -0x18(%rsp,%r10,4), %r8d
incl %eax
cmpq %rdi, %rsi
jne 0x11bf0
cmpl %ecx, %r8d
jne 0x11bf0
cmpl %edx, %r9d
jne 0x11bf0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: manifold::tidy_boundary()
void manifold::tidy_boundary()
{
	if (GLOBAL_calculate_peripheral_curves) insert_layer();  // We'll need an extra layer to find the longitudes in.
	
	tetra *capoff_tetra = capoff();  // Deal with boundary faces with a mandatory capoff().
	identify_cusps(capoff_tetra);  // Compute the cusps and their number.
	if (GLOBAL_calculate_peripheral_curves) canonical_peripheral_curves(capoff_tetra);
	if (GLOBAL_optimise) capoff_tetra = foldoff(capoff_tetra);  // If allowed to optimise, reduce the number of tetrahedra by folding off.
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xaf93(%rip), %r15      # 0x1e22a
cmpb $0x1, (%r15)
jne 0x132a5
movq %rbx, %rdi
callq 0x106e2
movq %rbx, %rdi
callq 0x119e4
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11c2a
cmpb $0x1, (%r15)
jne 0x132cc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x124be
leaq 0xaf56(%rip), %rax      # 0x1e229
cmpb $0x1, (%rax)
jne 0x132e8
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x12f4c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/MarkCBell[P]twister/./twister/kernel/twister.h
// Function: tetra::set_gluing(int, perm)
void set_gluing(int whichface, perm how)
	{
		// Check how is an odd permutation. This can only arrise from
		// programmer error as users have no direct control over permutation.
		bool c = true;  // c == 'how is even'.
		for (int i = 1; i < 4; i++)
			for (int j = 0; j < i; j++)
				if (how[j] > how[i])
					c ^= true;
		
		if (c) output_error("Even gluing detected.");
		
		gluing[whichface] = how;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movb $0x1, %al
movl $0x1, %ecx
movl (%rbx,%rcx,4), %edx
xorl %esi, %esi
cmpl %edx, (%rbx,%rsi,4)
setg %dil
xorb %dil, %al
incq %rsi
cmpq %rsi, %rcx
jne 0x13a7e
incq %rcx
cmpq $0x4, %rcx
jne 0x13a79
testb $0x1, %al
je 0x13ade
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x3eda(%rip), %rsi      # 0x17988
leaq 0x3ee8(%rip), %rdx      # 0x1799d
movq %rsp, %r15
movq %r15, %rdi
callq 0x892e
movq %r15, %rdi
callq 0x43b0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x13ade
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3220
movslq %ebp, %rax
shlq $0x4, %rax
movups (%rbx), %xmm0
movups %xmm0, 0x30(%r14,%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x13b14
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/findbook.cc
// Function: build_store(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<Sales_data> build_store(const string &s)
{
	Sales_data item;
	vector<Sales_data> ret;
	ifstream is(s);
	while (read(is, item))
		ret.push_back(item);
	sort (ret.begin(), ret.end(), lt);  // need sort for equal_range to work
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x240, %rsp            # imm = 0x240
movq %rdi, %rbx
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movl $0x0, 0x10(%r12)
movq %rax, 0x18(%r12)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq -0x258(%rbp), %rdi
movl $0x8, %edx
callq 0x21c0
leaq -0x258(%rbp), %r14
leaq -0x50(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x47c1
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2660
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d0a
jmp 0x263a
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x26b5
movq %r15, %rax
subq %r14, %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0x28c(%rip), %rcx      # 0x240c
movq %r14, %rdi
movq %r15, %rsi
callq 0x3636
leaq -0x29e(%rip), %rdx      # 0x240c
movq %r14, %rdi
movq %r15, %rsi
callq 0x3735
leaq -0x258(%rbp), %rdi
callq 0x2040
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x26d6
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x26ff
jmp 0x26f0
movq %rax, %r14
leaq -0x258(%rbp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2d6e
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x271c
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2150
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/findbook.cc
// Function: main
int main(int argc, char **argv)
{
	assert(argc > 1);
	// each element in files holds the transactions for a particular store
	vector<vector<Sales_data>> files;
	for (int cnt = 1; cnt != argc; ++cnt)
		files.push_back(build_store(argv[cnt]));

	ifstream in("../data/findbook.in");  // ISBNs to search for
	reportResults(in, cout, files);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
cmpl $0x1, %edi
jle 0x2b91
movq %rsi, %rbx
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl %edi, %r14d
movl $0x1, %r12d
leaq -0x270(%rbp), %r15
leaq -0x68(%rbp), %r13
movq (%rbx,%r12,8), %rsi
movq %r15, %rdi
leaq -0x29(%rbp), %rdx
callq 0x2070
movq %r13, %rdi
movq %r15, %rsi
callq 0x25dc
leaq -0x50(%rbp), %rdi
movq %r13, %rsi
callq 0x42c8
movq %r13, %rdi
callq 0x2d6e
movq -0x270(%rbp), %rdi
leaq -0x260(%rbp), %rax
cmpq %rax, %rdi
je 0x2b31
movq -0x260(%rbp), %rsi
incq %rsi
callq 0x2150
incq %r12
cmpq %r12, %r14
jne 0x2ae0
leaq 0x2535(%rip), %rsi      # 0x5075
leaq -0x270(%rbp), %rdi
movl $0x8, %edx
callq 0x2210
movq 0x4480(%rip), %rsi      # 0x6fd8
leaq -0x270(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x2724
leaq -0x270(%rbp), %rdi
callq 0x2040
leaq -0x50(%rbp), %rdi
callq 0x2ddc
xorl %eax, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24b1(%rip), %rdi      # 0x5049
leaq 0x24b3(%rip), %rsi      # 0x5052
leaq 0x24b8(%rip), %rcx      # 0x505e
movl $0x7f, %edx
callq 0x20b0
movq %rax, %rbx
leaq -0x270(%rbp), %rdi
callq 0x2040
jmp 0x2bfb
jmp 0x2bc3
movq %rax, %rbx
jmp 0x2bfb
movq %rax, %rbx
jmp 0x2bd9
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2d6e
movq -0x270(%rbp), %rdi
leaq -0x260(%rbp), %rax
cmpq %rax, %rdi
je 0x2bfb
movq -0x260(%rbp), %rsi
incq %rsi
callq 0x2150
leaq -0x50(%rbp), %rdi
callq 0x2ddc
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/usealloc2.cc
// Function: main
int main()
{
	vector<int> vi{1,2,3,4,5,6,7,8,9};

	allocator<int> alloc;
	// allocate twice as many elements as vi holds
	auto p = alloc.allocate(vi.size() * 2);

	// construct elements starting at p as copies of elements in vi
	auto q = uninitialized_copy(vi.begin(), vi.end(), p); 

	// initialize the remaining elements to 42
	uninitialized_fill_n(q, vi.size(), 42);

	for (size_t i = 0; i != vi.size(); ++i)
		cout << *(p + i) << " ";
	cout << endl;

	for (size_t i = 0; i != vi.size(); ++i)
		cout << *(q + i) << " ";
	cout << endl;

	alloc.deallocate(p, vi.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movups 0xda0(%rip), %xmm0      # 0x2014
leaq -0x80(%rbp), %rsi
movaps %xmm0, 0x10(%rsi)
movups 0xd81(%rip), %xmm0      # 0x2004
movaps %xmm0, (%rsi)
movl $0x9, 0x20(%rsi)
leaq -0x48(%rbp), %rbx
leaq -0x29(%rbp), %rcx
movl $0x9, %edx
movq %rbx, %rdi
callq 0x144e
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq %rsi
leaq -0x80(%rbp), %rdi
xorl %edx, %edx
callq 0x1494
movq %rax, %rbx
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %r14
subq %rsi, %r14
je 0x133e
movq %rbx, %rdi
movq %r14, %rdx
callq 0x10e0
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
je 0x133e
leaq (%rbx,%r14), %rsi
xorl %edi, %edi
movl $0x2a, (%rsi,%rdi)
addq $0x4, %rdi
cmpq %rdi, %rdx
jne 0x12e8
cmpq %rax, %rcx
je 0x133e
xorl %r13d, %r13d
movq 0x2cd1(%rip), %r15      # 0x3fd8
leaq 0xd1a(%rip), %r12       # 0x2028
movl (%rbx,%r13,4), %esi
movq %r15, %rdi
callq 0x10f0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10c0
incq %r13
movq -0x40(%rbp), %rax
subq -0x48(%rbp), %rax
sarq $0x2, %rax
cmpq %rax, %r13
jne 0x130e
movq %rbx, -0x50(%rbp)
movq 0x2c8f(%rip), %rdi      # 0x3fd8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq 0x2c74(%rip), %r15      # 0x3fd8
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x13c6
movq -0x50(%rbp), %r13
addq %r14, %r13
xorl %ebx, %ebx
movq 0x2c4a(%rip), %r14      # 0x3fd8
leaq 0xc93(%rip), %r12       # 0x2028
movl (%r13,%rbx,4), %esi
movq %r14, %rdi
callq 0x10f0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10c0
incq %rbx
movq -0x40(%rbp), %rax
subq -0x48(%rbp), %rax
sarq $0x2, %rax
cmpq %rax, %rbx
jne 0x1395
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq 0x2bf4(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq -0x40(%rbp), %rsi
subq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x10b0
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x1417
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x10b0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x142e
jmp 0x142e
jmp 0x142e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x1446
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x10b0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/RayTracer.cpp
// Function: create_default_camera(double, double, unsigned int, unsigned int, unsigned int, bool)
Camera* create_default_camera(double vfov, double aperture, unsigned int screen_width, unsigned int screen_height, unsigned int number_of_rays, bool correct_gamma) {
    Camera* cam = new Camera(Vec3(3, 2, 2), Vec3(0, 0, -1), Vec3(0, 1, 0), vfov, aperture);
    update_camera(cam, screen_width, screen_height, number_of_rays, correct_gamma);
    cam->recompute();

    return cam;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movl %edi, %r12d
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movl $0x178, %edi            # imm = 0x178
callq 0x3a470
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
movsd 0x46287(%rip), %xmm0    # 0x83058
movsd 0x46287(%rip), %xmm1    # 0x83060
movaps %xmm1, %xmm2
callq 0x71eae
leaq 0x30(%rsp), %rdi
movsd 0x4621a(%rip), %xmm2    # 0x83008
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x71eae
leaq 0x10(%rsp), %rdi
movsd 0x4623a(%rip), %xmm1    # 0x83040
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
callq 0x71eae
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x792fa
movl %r12d, 0x8(%rbx)
movl %r15d, 0xc(%rbx)
movl %r14d, 0x10(%rbx)
movb %bpl, 0x14(%rbx)
movq %rbx, %rdi
callq 0x7909e
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x178, %esi            # imm = 0x178
movq %rbx, %rdi
callq 0x3a480
movq %r14, %rdi
callq 0x3a790
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/include/cxxopts.hpp
// Function: cxxopts::ParseResult::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const OptionValue&
    operator[](const std::string& option) const
    {
      auto iter = m_options->find(option);

      if (iter == m_options->end())
      {
        throw_or_mimic<option_not_present_exception>(option);
      }

      auto riter = m_results.find(iter->second);

      return riter->second;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x47044
movq %rax, %r14
testq %rax, %rax
jne 0x40feb
movq %r15, %rdi
callq 0x48266
addq $0x68, %rbx
addq $0x28, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4820a
addq $0x18, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/include/cxxopts.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const& cxxopts::OptionValue::as<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>() const
const T&
    as() const
    {
      if (m_value == nullptr) {
        throw_or_mimic<std::domain_error>("No value");
      }

#ifdef CXXOPTS_NO_RTTI
      return static_cast<const values::standard_value<T>&>(*m_value).get();
#else
      return dynamic_cast<const values::standard_value<T>&>(*m_value).get();
#endif
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x4105f
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x43b38(%rip), %rsi     # 0x84b64
leaq 0x43b39(%rip), %rdx     # 0x84b6c
movq %rsp, %r14
movq %r14, %rdi
callq 0x44390
movq %r14, %rdi
callq 0x57ddc
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4105c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3a480
movq (%rbx), %rdi
leaq 0x6170a(%rip), %rsi     # 0xa2770
leaq 0x61743(%rip), %rdx     # 0xa27b0
xorl %ecx, %ecx
callq 0x3a4f0
testq %rax, %rax
je 0x41093
movq 0x28(%rax), %rcx
testq %rcx, %rcx
jne 0x41086
movq 0x18(%rax), %rcx
movq %rcx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x3a800
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x410b1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3a480
movq %rbx, %rdi
callq 0x3a790
nop
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/include/cxxopts.hpp
// Function: void cxxopts::values::stringstream_parser<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double&)
void stringstream_parser(const std::string& text, T& value)
    {
      std::stringstream in(text);
      in >> value;
      if (!in) {
        throw_or_mimic<argument_incorrect_type>(text);
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x18, %edx
callq 0x3a6c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x3a2e0
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
je 0x57624
movq %rbx, %rdi
callq 0x54d24
movq 0x4c8f5(%rip), %rsi     # 0xa3f20
leaq 0x8(%rsp), %rdi
callq 0x3a360
leaq 0x88(%rsp), %rdi
callq 0x3a150
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x4c8c7(%rip), %rsi     # 0xa3f20
leaq 0x8(%rsp), %rdi
callq 0x3a360
leaq 0x88(%rsp), %rdi
callq 0x3a150
movq %rbx, %rdi
callq 0x3a790
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/include/json.hpp
// Function: nlohmann::detail::input_stream_adapter::get_character()
std::char_traits<char>::int_type get_character() override
    {
        auto res = sb.sbumpc();
        // set eof manually, as we don't use the istream interface.
        if (res == EOF)
        {
            is.clear(is.rdstate() | std::ios::eofbit);
        }
        return res;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x10(%rdi), %rcx
cmpq 0x18(%rdi), %rcx
jae 0x58a58
movzbl (%rcx), %eax
incq %rcx
movq %rcx, 0x10(%rdi)
popq %rbx
retq
movq (%rdi), %rax
callq *0x50(%rax)
cmpl $-0x1, %eax
jne 0x58a56
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x2, %esi
callq 0x3a750
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x58a56
nop
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/Frames.cpp
// Function: RayTracer::Frames::Frames(RayTracer::Frames const&)
Frames::Frames(const Frames& other)
    : frame_index(other.frame_index),
    temp_dir(other.temp_dir),
    dynamic_writing(other.dynamic_writing),
    width(other.width),
    height(other.height),
    n_frames(other.n_frames),
    fps(other.fps)
{
    // Depending on whether we write dynamically, copy the necessary data
    if (this->dynamic_writing) {
        // Copy the current_frame, done
        this->current_frame = new Image(*other.current_frame);
    } else {
        // Copy their entire this->frames list
        this->frames = new Image*[this->n_frames];
        for (std::size_t i = 0; i <= this->frame_index; i++) {
            this->frames[i] = new Image(*other.frames[i]);
        }
        // Update the current_frame
        this->current_frame = this->frames[frame_index];
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %rbx
leaq 0x28(%rdi), %r13
movq %r13, 0x18(%rdi)
movq 0x18(%rsi), %rsi
movq 0x20(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x48588
movb 0x38(%r15), %al
movb %al, 0x38(%r14)
movdqu 0x3c(%r15), %xmm0
movdqu %xmm0, 0x3c(%r14)
cmpb $0x1, %al
jne 0x62534
movl $0x10, %edi
callq 0x3a470
movq %rax, %r12
movq (%r15), %rsi
movq %rax, %rdi
callq 0x6393e
jmp 0x62585
pshufd $0xee, %xmm0, %xmm0     # xmm0 = xmm0[2,3,2,3]
movd %xmm0, %edi
shlq $0x3, %rdi
callq 0x3a040
movq %rax, 0x8(%r14)
xorl %ebp, %ebp
movl $0x10, %edi
callq 0x3a470
movq %rax, %r12
movq 0x8(%r15), %rax
movq (%rax,%rbp,8), %rsi
movq %r12, %rdi
callq 0x6393e
movq 0x8(%r14), %rax
movq %r12, (%rax,%rbp,8)
incq %rbp
movq 0x10(%r14), %rax
cmpq %rax, %rbp
jbe 0x6254c
movq 0x8(%r14), %rcx
movq (%rcx,%rax,8), %r12
movq %r12, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x625a0
jmp 0x6259b
movq %rax, %r14
jmp 0x625b0
movq %rax, %r14
movl $0x10, %esi
movq %r12, %rdi
callq 0x3a480
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x625c4
movq (%r13), %rsi
incq %rsi
callq 0x3a480
movq %r14, %rdi
callq 0x3a790
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/Frames.cpp
// Function: RayTracer::Frames::Frames(RayTracer::Frames&&)
Frames::Frames(Frames&& other)
    : frame_index(other.frame_index),
    temp_dir(other.temp_dir),
    dynamic_writing(other.dynamic_writing),
    width(other.width),
    height(other.height),
    n_frames(other.n_frames),
    fps(other.fps)
{
    // Copy the correct pointers
    if (this->dynamic_writing) {
        this->current_frame = other.current_frame;
    } else {
        this->frames = other.frames;
        this->current_frame = this->frames[this->frame_index];
    }

    // Overwrite the other pointer with null
    other.frames = nullptr;
    other.current_frame = nullptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
leaq 0x28(%r14), %rax
movq %rax, 0x18(%r14)
movq 0x18(%rsi), %rsi
movq 0x20(%rbx), %rdx
addq %rsi, %rdx
callq 0x48588
movb 0x38(%rbx), %cl
movb %cl, 0x38(%r14)
movups 0x3c(%rbx), %xmm0
movups %xmm0, 0x3c(%r14)
movq %rbx, %rax
testb %cl, %cl
jne 0x62621
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movq 0x10(%r14), %rcx
leaq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/Frames.cpp
// Function: RayTracer::Frames::~Frames()
Frames::~Frames() {
    // Deallocate either everything or only the current frame
    if (!this->dynamic_writing) {
        for (std::size_t i = 0; i <= this->frame_index; i++) {
            delete this->frames[i];
        }
        // Delete the list as well
        delete[] this->frames;
    } else {
        delete this->current_frame;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x38(%rdi)
je 0x62663
movq (%rbx), %r14
testq %r14, %r14
je 0x62654
movq %r14, %rdi
callq 0x639f4
movl $0x10, %esi
movq %r14, %rdi
callq 0x3a480
jmp 0x6269f
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x6267b
movq %r14, %rdi
callq 0x639f4
movl $0x10, %esi
movq %r14, %rdi
callq 0x3a480
incq %r15
cmpq 0x10(%rbx), %r15
jbe 0x62666
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x6269f
callq 0x3a590
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x626bc
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3a480
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/Image.cpp
// Function: RayTracer::ImageRow::operator[](unsigned int)
Pixel ImageRow::operator[](unsigned int index) {
    // Check if out of bounds
    if (index >= this->width) {
        throw out_of_range("Cannot get element " + to_string(index) + " from Image with width " + to_string(index));
    }

    // Get a pointer to the correct position in the data
    double* pixel = this->data + 3 * index;
    return Pixel(pixel);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %esi, %r14d
cmpl %esi, 0x8(%rdi)
jbe 0x6376c
leal (%r14,%r14,2), %eax
shlq $0x3, %rax
addq (%rdi), %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3a210
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movl %r14d, %esi
callq 0x64341
leaq 0x24aba(%rip), %rsi     # 0x88247
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x5cd14
leaq 0x24ab8(%rip), %rsi     # 0x8825b
leaq 0x68(%rsp), %rdi
callq 0x3a810
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x637ce
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x637db
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rdi
movl %r14d, %esi
callq 0x64341
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x643c1
movb $0x1, %bpl
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x3a680
xorl %ebp, %ebp
movq 0x4076d(%rip), %rsi     # 0xa3fa0
movq 0x4074e(%rip), %rdx     # 0xa3f88
movq %rbx, %rdi
callq 0x3a760
movq %rax, %r14
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6386e
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x3a480
jmp 0x6386e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63891
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3a480
jmp 0x63891
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x638b0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3a480
jmp 0x638b0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x638cb
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3a480
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x638e6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3a480
testb %bpl, %bpl
jne 0x63910
jmp 0x63918
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63910
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3a480
jmp 0x63910
movq %rax, %r14
movq %rbx, %rdi
callq 0x3a340
movq %r14, %rdi
callq 0x3a790
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/Image.cpp
// Function: RayTracer::Image::Image(RayTracer::Image const&)
Image::Image(const Image& other)
    : Image(other.width, other.height)
{
    cout << "Copy constructor" << endl;

    // Copy all pixels over
    for (std::size_t i = 0; i < this->width * this->height * 3; i++) {
        this->data[i] = other.data[i];
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl 0xc(%rsi), %ecx
movl %eax, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
imull %ecx, %eax
leal (%rax,%rax,2), %edi
shlq $0x3, %rdi
callq 0x3a040
movq %rax, (%rbx)
movq 0x40612(%rip), %r15     # 0xa3f80
leaq 0x248fe(%rip), %rsi     # 0x88273
movl $0x10, %edx
movq %r15, %rdi
callq 0x3a500
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x3a440
movsbl %al, %esi
movq 0x405e0(%rip), %rdi     # 0xa3f80
callq 0x3a050
movq %rax, %rdi
callq 0x3a310
movl 0x8(%rbx), %eax
imull 0xc(%rbx), %eax
leal (%rax,%rax,2), %eax
testl %eax, %eax
je 0x639d5
movq (%r14), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x639c3
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x639eb
callq 0x3a590
movq %r14, %rdi
callq 0x3a790
nop
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/Image.cpp
// Function: RayTracer::Image::operator[](unsigned int)
ImageRow Image::operator[](unsigned int index) {
    // Check if the index is within bounds
    if (index >= this->height) {
        throw out_of_range("Cannot get row " + to_string(index) + " from Image with height " + to_string(index));
    }

    // Get the correct pointer
    double* row = this->data + 3 * (index * this->width);
    return ImageRow(row, this->width);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %esi, %r14d
cmpl %esi, 0xc(%rdi)
jbe 0x63f31
movl 0x8(%rdi), %edx
imull %edx, %r14d
leal (%r14,%r14,2), %eax
shlq $0x3, %rax
addq (%rdi), %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3a210
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movl %r14d, %esi
callq 0x64341
leaq 0x24379(%rip), %rsi     # 0x882cb
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x5cd14
leaq 0x24373(%rip), %rsi     # 0x882db
leaq 0x68(%rsp), %rdi
callq 0x3a810
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x63f93
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x63fa0
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rdi
movl %r14d, %esi
callq 0x64341
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x643c1
movb $0x1, %bpl
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x3a680
xorl %ebp, %ebp
movq 0x3ffa8(%rip), %rsi     # 0xa3fa0
movq 0x3ff89(%rip), %rdx     # 0xa3f88
movq %rbx, %rdi
callq 0x3a760
movq %rax, %r14
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x64033
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x3a480
jmp 0x64033
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x64056
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3a480
jmp 0x64056
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x64075
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3a480
jmp 0x64075
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x64090
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3a480
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x640ab
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3a480
testb %bpl, %bpl
jne 0x640d5
jmp 0x640dd
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x640d5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3a480
jmp 0x640d5
movq %rax, %r14
movq %rbx, %rdi
callq 0x3a340
movq %r14, %rdi
callq 0x3a790
nop
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_save_file(unsigned char const*, unsigned long, char const*)
unsigned lodepng_save_file(const unsigned char* buffer, size_t buffersize, const char* filename) {
  FILE* file;
  file = fopen(filename, "wb" );
  if(!file) return 79;
  fwrite(buffer, 1, buffersize, file);
  fclose(file);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x247d8(%rip), %rsi     # 0x88ec1
movq %rdx, %rdi
callq 0x3a530
testq %rax, %rax
je 0x64718
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x3a840
movq %r15, %rdi
callq 0x3a460
xorl %eax, %eax
jmp 0x6471d
movl $0x4f, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: ensureBits17(LodePNGBitReader*, unsigned long)
static unsigned ensureBits17(LodePNGBitReader* reader, size_t nbits) {
  size_t start = reader->bp >> 3u;
  size_t size = reader->size;
  if(start + 2u < size) {
    reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u) |
                     ((unsigned)reader->data[start + 2] << 16u);
    reader->buffer >>= (reader->bp & 7u);
    return 1;
  } else {
    reader->buffer = 0;
    if(start + 0u < size) reader->buffer |= reader->data[start + 0];
    if(start + 1u < size) reader->buffer |= ((unsigned)reader->data[start + 1] << 8u);
    reader->buffer >>= (reader->bp & 7u);
    return reader->bp + nbits <= reader->bitsize;
  }
}

// Assembly:
movq 0x8(%rdi), %r8
movq 0x18(%rdi), %rax
movq %rax, %rcx
shrq $0x3, %rcx
leaq 0x2(%rcx), %rdx
cmpq %r8, %rdx
jae 0x64960
movq (%rdi), %rdx
movzwl (%rdx,%rcx), %esi
movzbl 0x2(%rdx,%rcx), %edx
shll $0x10, %edx
orl %esi, %edx
andb $0x7, %al
movl %eax, %ecx
shrl %cl, %edx
movl %edx, 0x20(%rdi)
movl $0x1, %eax
retq
movl $0x0, 0x20(%rdi)
xorl %edx, %edx
cmpq %r8, %rcx
jae 0x64978
movq (%rdi), %rdx
movzbl (%rdx,%rcx), %edx
movl %edx, 0x20(%rdi)
incq %rcx
cmpq %r8, %rcx
jae 0x6498d
movq (%rdi), %r8
movzbl (%r8,%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %edx
movl %eax, %ecx
andb $0x7, %cl
shrl %cl, %edx
movl %edx, 0x20(%rdi)
addq %rax, %rsi
xorl %eax, %eax
cmpq 0x10(%rdi), %rsi
setbe %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: ensureBits9(LodePNGBitReader*, unsigned long)
static unsigned ensureBits9(LodePNGBitReader* reader, size_t nbits) {
  size_t start = reader->bp >> 3u;
  size_t size = reader->size;
  if(start + 1u < size) {
    reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u);
    reader->buffer >>= (reader->bp & 7u);
    return 1;
  } else {
    reader->buffer = 0;
    if(start + 0u < size) reader->buffer |= reader->data[start + 0];
    reader->buffer >>= (reader->bp & 7u);
    return reader->bp + nbits <= reader->bitsize;
  }
}

// Assembly:
movq 0x8(%rdi), %r8
movq 0x18(%rdi), %rax
movq %rax, %rcx
shrq $0x3, %rcx
leaq 0x1(%rcx), %rdx
cmpq %r8, %rdx
jae 0x649d2
movq (%rdi), %rdx
movzwl (%rdx,%rcx), %edx
andb $0x7, %al
movl %eax, %ecx
shrl %cl, %edx
movl %edx, 0x20(%rdi)
movl $0x1, %eax
retq
movl $0x0, 0x20(%rdi)
xorl %edx, %edx
cmpq %r8, %rcx
jae 0x649e7
movq (%rdi), %rdx
movzbl (%rdx,%rcx), %edx
movl %eax, %ecx
andb $0x7, %cl
shrl %cl, %edx
movl %edx, 0x20(%rdi)
addq %rax, %rsi
xorl %eax, %eax
cmpq 0x10(%rdi), %rsi
setbe %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_crc32(unsigned char const*, unsigned long)
unsigned lodepng_crc32(const unsigned char* data, size_t length) {
  unsigned r = 0xffffffffu;
  size_t i;
  for(i = 0; i < length; ++i) {
    r = lodepng_crc32_table[(r ^ data[i]) & 0xffu] ^ (r >> 8u);
  }
  return r ^ 0xffffffffu;
}

// Assembly:
testq %rsi, %rsi
je 0x677ed
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
leaq 0x20e30(%rip), %rdx     # 0x88600
movb (%rdi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdx,%r8,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x677d0
notl %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_chunk_next(unsigned char*, unsigned char*)
unsigned char* lodepng_chunk_next(unsigned char* chunk, unsigned char* end) {
  if(chunk >= end || end - chunk < 12) return end; /*too small to contain a chunk*/
  if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
    && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) {
    /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */
    return chunk + 8;
  } else {
    size_t total_chunk_length;
    unsigned char* result;
    if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end;
    result = chunk + total_chunk_length;
    if(result < chunk) return end; /*pointer overflow*/
    return result;
  }
}

// Assembly:
movq %rsi, %rax
movq %rsi, %rcx
subq %rdi, %rcx
setbe %dl
cmpq $0xc, %rcx
setl %cl
orb %dl, %cl
jne 0x679a6
movzbl (%rdi), %eax
movl %eax, %edx
xorb $-0x77, %dl
movb 0x1(%rdi), %cl
movl %ecx, %esi
xorb $0x50, %sil
orb %dl, %sil
jne 0x67983
movb $0x50, %cl
cmpb $0x4e, 0x2(%rdi)
jne 0x67983
cmpb $0x47, 0x3(%rdi)
jne 0x67983
cmpb $0xd, 0x4(%rdi)
jne 0x67983
cmpb $0xa, 0x5(%rdi)
jne 0x67983
cmpb $0x1a, 0x6(%rdi)
jne 0x67983
cmpb $0xa, 0x7(%rdi)
jne 0x67983
addq $0x8, %rdi
movq %rdi, %rax
retq
shll $0x18, %eax
movzbl %cl, %ecx
shll $0x10, %ecx
orl %eax, %ecx
movzbl 0x2(%rdi), %eax
shll $0x8, %eax
orl %ecx, %eax
movzbl 0x3(%rdi), %ecx
orq %rax, %rcx
leaq (%rdi,%rcx), %rax
addq $0xc, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_chunk_next_const(unsigned char const*, unsigned char const*)
const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk, const unsigned char* end) {
  if(chunk >= end || end - chunk < 12) return end; /*too small to contain a chunk*/
  if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
    && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) {
    /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */
    return chunk + 8;
  } else {
    size_t total_chunk_length;
    const unsigned char* result;
    if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end;
    result = chunk + total_chunk_length;
    if(result < chunk) return end; /*pointer overflow*/
    return result;
  }
}

// Assembly:
movq %rsi, %rax
movq %rsi, %rcx
subq %rdi, %rcx
setbe %dl
cmpq $0xc, %rcx
setl %cl
orb %dl, %cl
jne 0x67a25
movzbl (%rdi), %eax
movl %eax, %edx
xorb $-0x77, %dl
movb 0x1(%rdi), %cl
movl %ecx, %esi
xorb $0x50, %sil
orb %dl, %sil
jne 0x67a02
movb $0x50, %cl
cmpb $0x4e, 0x2(%rdi)
jne 0x67a02
cmpb $0x47, 0x3(%rdi)
jne 0x67a02
cmpb $0xd, 0x4(%rdi)
jne 0x67a02
cmpb $0xa, 0x5(%rdi)
jne 0x67a02
cmpb $0x1a, 0x6(%rdi)
jne 0x67a02
cmpb $0xa, 0x7(%rdi)
jne 0x67a02
addq $0x8, %rdi
movq %rdi, %rax
retq
shll $0x18, %eax
movzbl %cl, %ecx
shll $0x10, %ecx
orl %eax, %ecx
movzbl 0x2(%rdi), %eax
shll $0x8, %eax
orl %ecx, %eax
movzbl 0x3(%rdi), %ecx
orq %rax, %rcx
leaq (%rdi,%rcx), %rax
addq $0xc, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_chunk_find(unsigned char*, unsigned char*, char const*)
unsigned char* lodepng_chunk_find(unsigned char* chunk, unsigned char* end, const char type[5]) {
  for(;;) {
    if(chunk >= end || end - chunk < 12) return 0; /* past file end: chunk + 12 > end */
    if(lodepng_chunk_type_equals(chunk, type)) return chunk;
    chunk = lodepng_chunk_next(chunk, end);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
subq %rdi, %rax
setbe %cl
cmpq $0xc, %rax
setl %al
orb %cl, %al
je 0x67a47
xorl %r14d, %r14d
jmp 0x67a83
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %r12
xorl %r14d, %r14d
movq %r15, %rdi
movq %r12, %rsi
callq 0x6780c
testb %al, %al
jne 0x67a80
movq %r15, %rdi
movq %rbx, %rsi
callq 0x67928
movq %rax, %r15
movq %rbx, %rax
subq %r15, %rax
jbe 0x67a83
cmpq $0xb, %rax
jg 0x67a53
jmp 0x67a83
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_chunk_find_const(unsigned char const*, unsigned char const*, char const*)
const unsigned char* lodepng_chunk_find_const(const unsigned char* chunk, const unsigned char* end, const char type[5]) {
  for(;;) {
    if(chunk >= end || end - chunk < 12) return 0; /* past file end: chunk + 12 > end */
    if(lodepng_chunk_type_equals(chunk, type)) return chunk;
    chunk = lodepng_chunk_next_const(chunk, end);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
subq %rdi, %rax
setbe %cl
cmpq $0xc, %rax
setl %al
orb %cl, %al
je 0x67ab3
xorl %r14d, %r14d
jmp 0x67aef
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %r12
xorl %r14d, %r14d
movq %r15, %rdi
movq %r12, %rsi
callq 0x6780c
testb %al, %al
jne 0x67aec
movq %r15, %rdi
movq %rbx, %rsi
callq 0x679a7
movq %rax, %r15
movq %rbx, %rax
subq %r15, %rax
jbe 0x67aef
cmpq $0xb, %rax
jg 0x67abf
jmp 0x67aef
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq