LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: manifold::snap_print(std::ostream&)
void manifold::snap_print(std::ostream &o)
{
	output_debugging("print", 2);
	
	// Watch out - blank names will kill snappea.
	if (name == "")
		name = "Blank name disallowed";
	
	// Print basic information.
	o << "% Triangulation" << std::endl;
	o << name << std::endl;
	o << "not_attempted  0.00000000" << std::endl;
	o << "oriented_manifold" << std::endl;  // All manifolds we build are orientable, as all face gluings are odd. 
	o << "CS_unknown" << std::endl;
	o << std::endl;
	
	// As our manifold is orientable we must only have torus cusps, so we write them down.
	o << num_cusps << " 0" << std::endl;
	for (int i = 0; i < num_cusps; i++)
		o << "    torus  0.00000000  0.00000000" << std::endl;
	
	o << std::endl;
	
	// First assign each tetra a snap_index
	int i = 0; 
	for (tetra *current = first_tetra; current != NULL; current = current->get_next())
		current->snap_index = i++;
	
	// Print the number of tetrahedra.
	o << i << std::endl;
	
	// Finally, print the face gluings for each tetrahedron and the cusp data, if any.
	for (tetra *current = first_tetra; current != NULL; current = current->get_next())
		current->print_wrt(o);
	
	o << std::endl;
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2b98(%rip), %rsi      # 0x117cf
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x3e82
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x3d1a
leaq 0x8(%rsp), %rdi
callq 0x3458
leaq 0x18(%r14), %r15
leaq 0x26a6(%rip), %rsi      # 0x1130f
movq %r15, %rdi
callq 0x631c
testb %al, %al
je 0xec84
leaq 0x2b59(%rip), %rsi      # 0x117d5
movq %r15, %rdi
callq 0x3410
leaq 0x2b60(%rip), %rsi      # 0x117eb
movq %rbx, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x3120
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3210
movq %rax, %rdi
callq 0x3120
leaq 0x2b46(%rip), %rsi      # 0x117fb
movq %rbx, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x3120
leaq 0x2b49(%rip), %rsi      # 0x11815
movq %rbx, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x3120
leaq 0x2b44(%rip), %rsi      # 0x11827
movq %rbx, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3120
movl 0x3c(%r14), %esi
movq %rbx, %rdi
callq 0x33c0
leaq 0x2bad(%rip), %rsi      # 0x118bb
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
callq 0x3120
xorl %ebp, %ebp
leaq 0x2b0b(%rip), %r15      # 0x11832
cmpl 0x3c(%r14), %ebp
jge 0xed44
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3230
movq %rax, %rdi
callq 0x3120
incl %ebp
jmp 0xed27
movq %rbx, %rdi
callq 0x3120
xorl %esi, %esi
movq %r14, %rax
movq (%rax), %rax
testq %rax, %rax
je 0xed63
movl %esi, 0xbc(%rax)
incl %esi
jmp 0xed51
movq %rbx, %rdi
callq 0x33c0
movq %rax, %rdi
callq 0x3120
movq (%r14), %r14
testq %r14, %r14
je 0xed88
movq %r14, %rdi
movq %rbx, %rsi
callq 0xedde
jmp 0xed73
movq %rbx, %rdi
callq 0x3120
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3458
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movb $0x1, %al
pushq $0x1
popq %rcx
cmpq $0x4, %rcx
je 0xefff
movl (%rbx,%rcx,4), %edx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0xeffa
cmpl %edx, (%rbx,%rsi,4)
setg %dil
xorb %dil, %al
incq %rsi
jmp 0xefe6
incq %rcx
jmp 0xefdb
testb $0x1, %al
je 0xf02e
leaq 0x28d6(%rip), %rsi      # 0x118e0
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x3e82
movq %r15, %rdi
callq 0x3dec
leaq 0x8(%rsp), %rdi
callq 0x3458
movslq %ebp, %rax
shlq $0x4, %rax
movups (%rbx), %xmm0
movups %xmm0, 0x30(%r14,%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3458
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/MarkCBell[P]twister/./twister/kernel/twister.h
// Function: cube::get_tetra(int)
tetra *get_tetra(int i)  // This for looping.
	{
		switch (i)
		{
			case 0:
				return topleft;
			case 1:
				return midleft;
			case 2:
				return lowleft;
			case 3:
				return topright;
			case 4:
				return midright;
			case 5:
				return lowright;
		}
		return NULL;
	}

// Assembly:
cmpl $0x5, %esi
ja 0xf0ae
movl %esi, %eax
leaq 0x23f8(%rip), %rcx      # 0x11480
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rax
retq
movq 0x20(%rdi), %rax
retq
movq 0x10(%rdi), %rax
retq
movq 0x18(%rdi), %rax
retq
movq 0x8(%rdi), %rax
retq
movq 0x28(%rdi), %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/findbook.cc
// Function: findBook(std::vector<std::vector<Sales_data, std::allocator<Sales_data>>, std::allocator<std::vector<Sales_data, std::allocator<Sales_data>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<matches>
findBook(const vector<vector<Sales_data>> &files, 
         const string &book)
{
	vector<matches> ret;  // initially empty
	// for each store find the range of matching books, if any
	for (auto it = files.cbegin(); it != files.cend(); ++it) {
		// find the range of Sales_data that have the same ISBN
		auto found = equal_range(it->cbegin(), it->cend(), 
		                         book, compareIsbn);
		if (found.first != found.second)  // this store had sales
			// remember the index of this store and the matching range 
			ret.push_back(make_tuple(it - files.cbegin(), 
                                  found.first, found.second));
	}
	return ret; // empty if no matches found
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %r12
movq %r12, %r13
cmpq 0x8(%r15), %r13
je 0x246f
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r14, %rdx
leaq 0x465(%rip), %rcx       # 0x2894
callq 0x2887
movq %rax, %rcx
movq %rdx, %rsi
cmpq %rdx, %rax
je 0x2465
movq %r12, %rax
subq (%r15), %rax
cqto
pushq $0x18
popq %rdi
idivq %rdi
movq %rsi, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
leaq -0x40(%rbp), %rsi
callq 0x2cce
addq $0x18, %r13
addq $0x18, %r12
jmp 0x2417
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2483
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a2e
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x250(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x21c0
leaq -0x250(%rbp), %r14
leaq -0x48(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e79
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x250d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2904
jmp 0x24e7
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq -0x19f(%rip), %rdx      # 0x237c
callq 0x3166
leaq -0x250(%rbp), %rdi
callq 0x2040
leaq -0x48(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x254d
movq %rax, %r14
jmp 0x255c
movq %rax, %r14
leaq -0x250(%rbp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2940
leaq -0x48(%rbp), %rdi
callq 0x2090
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/findbook.cc
// Function: reportResults(std::istream&, std::ostream&, std::vector<std::vector<Sales_data, std::allocator<Sales_data>>, std::allocator<std::vector<Sales_data, std::allocator<Sales_data>>>> const&)
void reportResults(istream &in, ostream &os,
                   const vector<vector<Sales_data>> &files)
{
	string s;   // book to look for
	while (in >> s) {
		auto trans = findBook(files, s);  // stores that sold this book
		if (trans.empty()) {
			cout << s << " not found in any stores" << endl;
			continue;  // get the next book to look for
		}
		for (const auto &store : trans)   // for every store with a sale
			// get<n> returns the specified member from the tuple in store
			os << "store " << get<0>(store) << " sales: "
			   << accumulate(get<1>(store), get<2>(store), 
			                 Sales_data(s))
			   << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0xb8(%rbp), %r14
leaq -0xe8(%rbp), %rbx
movq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x26ce
leaq -0x88(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x23ec
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, -0x50(%rbp)
cmpq %rcx, %rax
je 0x2696
movq %rax, -0x30(%rbp)
cmpq -0x50(%rbp), %rax
je 0x26bd
movq -0x48(%rbp), %rdi
leaq 0x1a06(%rip), %rsi      # 0x401d
callq 0x2120
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
leaq 0x19ee(%rip), %rsi      # 0x4024
callq 0x2120
movq %rax, %r13
movq -0x30(%rbp), %rax
movq (%rax), %r12
movq 0x8(%rax), %r15
movq %r14, %rdi
leaq -0x70(%rbp), %rsi
callq 0x29d6
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x296b
movq %r13, %rdi
movq %rbx, %rsi
callq 0x3dba
movq %rax, %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2090
movq -0x30(%rbp), %rax
addq $0x18, %rax
jmp 0x25fe
movq 0x493b(%rip), %rdi      # 0x6fd8
leaq -0x70(%rbp), %rsi
callq 0x2110
movq %rax, %rdi
leaq 0x1954(%rip), %rsi      # 0x4004
callq 0x2120
movq %rax, %rdi
callq 0x20a0
leaq -0x88(%rbp), %rdi
callq 0x2a2e
jmp 0x25b3
leaq -0x70(%rbp), %rdi
callq 0x2090
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26eb
movq %rax, %rbx
jmp 0x2725
jmp 0x2716
jmp 0x2716
movq %rax, %rbx
jmp 0x2708
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x2090
leaq -0xb8(%rbp), %rdi
callq 0x2090
jmp 0x2719
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x2a2e
leaq -0x70(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x280e
movq %rsi, %rbx
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movl %edi, %r14d
pushq $0x1
popq %r12
leaq -0x270(%rbp), %r15
leaq -0x68(%rbp), %r13
cmpq %r12, %r14
je 0x27b8
movq (%rbx,%r12,8), %rsi
movq %r15, %rdi
leaq -0x29(%rbp), %rdx
callq 0x2070
movq %r13, %rdi
movq %r15, %rsi
callq 0x2496
leaq -0x50(%rbp), %rdi
movq %r13, %rsi
callq 0x3a3c
movq %r13, %rdi
callq 0x2940
movq %r15, %rdi
callq 0x2090
incq %r12
jmp 0x2777
leaq 0x189a(%rip), %rsi      # 0x4059
leaq -0x270(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x2200
movq 0x4803(%rip), %rsi      # 0x6fd8
leaq -0x270(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x2575
leaq -0x270(%rbp), %rdi
callq 0x2040
leaq -0x50(%rbp), %rdi
callq 0x29f4
xorl %eax, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1818(%rip), %rdi      # 0x402d
leaq 0x181a(%rip), %rsi      # 0x4036
leaq 0x181f(%rip), %rcx      # 0x4042
pushq $0x7f
popq %rdx
callq 0x20c0
movq %rax, %rbx
leaq -0x270(%rbp), %rdi
callq 0x2040
jmp 0x2860
jmp 0x283e
movq %rax, %rbx
jmp 0x2860
movq %rax, %rbx
jmp 0x2854
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2940
leaq -0x270(%rbp), %rdi
callq 0x2090
leaq -0x50(%rbp), %rdi
callq 0x29f4
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/SeungjunHa[P]algorithm/a.cpp
// Function: main
int main(void)
{
	ios_base :: sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x1030
movq 0x2e32(%rip), %rax      # 0x3fe0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
andq $0x0, 0xd8(%rax,%rcx)
movq 0x2e0b(%rip), %rax      # 0x3fd0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
andq $0x0, 0xd8(%rax,%rcx)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movups 0xdb0(%rip), %xmm0      # 0x2014
leaq -0x70(%rbp), %rsi
movaps %xmm0, 0x10(%rsi)
movups 0xd91(%rip), %xmm0      # 0x2004
movaps %xmm0, (%rsi)
movl $0x9, 0x20(%rsi)
leaq -0x48(%rbp), %rbx
pushq $0x9
popq %rdx
leaq -0x29(%rbp), %rcx
movq %rbx, %rdi
callq 0x13cc
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq %rsi
leaq -0x29(%rbp), %rdi
xorl %edx, %edx
callq 0x1402
movq %rax, %r14
movq %rax, %rbx
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %r15
subq %rsi, %r15
je 0x12cd
movq %rbx, %rdi
movq %r15, %rdx
callq 0x10e0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
jmp 0x12d0
movq %rsi, %rax
subq %rsi, %rax
addq %r15, %r14
sarq $0x2, %rax
leaq -0x70(%rbp), %rdx
movl $0x2a, (%rdx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x1511
xorl %r13d, %r13d
movq 0x2cdf(%rip), %r15      # 0x3fd8
leaq 0xd28(%rip), %r12       # 0x2028
movq -0x40(%rbp), %rax
subq -0x48(%rbp), %rax
sarq $0x2, %rax
cmpq %rax, %r13
je 0x132d
movl (%rbx,%r13,4), %esi
movq %r15, %rdi
callq 0x10f0
movq %rax, %rdi
movq %r12, %rsi
callq 0x10a0
incq %r13
jmp 0x1300
movq 0x2ca4(%rip), %rdi      # 0x3fd8
callq 0x1060
xorl %r13d, %r13d
movq 0x2c95(%rip), %r15      # 0x3fd8
leaq 0xcde(%rip), %r12       # 0x2028
movq -0x40(%rbp), %rax
subq -0x48(%rbp), %rax
sarq $0x2, %rax
cmpq %rax, %r13
je 0x1377
movl (%r14,%r13,4), %esi
movq %r15, %rdi
callq 0x10f0
movq %rax, %rdi
movq %r12, %rsi
callq 0x10a0
incq %r13
jmp 0x134a
movq 0x2c5a(%rip), %rdi      # 0x3fd8
callq 0x1060
leaq -0x48(%rbp), %r14
movq 0x8(%r14), %rsi
subq (%r14), %rsi
movq %rbx, %rdi
callq 0x10c0
movq %r14, %rdi
callq 0x1488
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13b7
jmp 0x13b7
jmp 0x13b7
jmp 0x13b7
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x1488
movq %rbx, %rdi
callq 0x1100
nop
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day06/ex02/main.cpp
// Function: identify_from_pointer(Base*)
void	identify_from_pointer(Base *p)
{
	if (dynamic_cast<A *>(p))
		std::cout << "A" << std::endl;
	if (dynamic_cast<B *>(p))
		std::cout << "B" << std::endl;
	if (dynamic_cast<C *>(p))
		std::cout << "C" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x130d
movq %rdi, %rbx
leaq 0x2a6f(%rip), %rsi      # 0x3cd8
leaq 0x2a98(%rip), %rdx      # 0x3d08
xorl %ecx, %ecx
callq 0x1090
testq %rax, %rax
je 0x1297
movq 0x2d55(%rip), %rdi      # 0x3fd8
leaq 0xd83(%rip), %rsi       # 0x200d
callq 0x1060
movq %rax, %rdi
callq 0x1040
leaq 0x2a3a(%rip), %rsi      # 0x3cd8
leaq 0x2a7b(%rip), %rdx      # 0x3d20
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1090
testq %rax, %rax
je 0x12cf
movq 0x2d1d(%rip), %rdi      # 0x3fd8
leaq 0xd4d(%rip), %rsi       # 0x200f
callq 0x1060
movq %rax, %rdi
callq 0x1040
leaq 0x2a02(%rip), %rsi      # 0x3cd8
leaq 0x2a5b(%rip), %rdx      # 0x3d38
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1090
testq %rax, %rax
je 0x130d
movq 0x2ce5(%rip), %rdi      # 0x3fd8
leaq 0xd17(%rip), %rsi       # 0x2011
callq 0x1060
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1040
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day06/ex02/main.cpp
// Function: identify_from_reference(Base&)
void identify_from_reference(Base &p)
{
	Base	a;
	try
	{
		a = dynamic_cast<A&>(p);
		std::cout << "A" << std::endl;
	}
	catch (std::bad_cast err) {}
	try
	{
		a = dynamic_cast<B&>(p);
		std::cout << "B" << std::endl;
	}
	catch (std::bad_cast err) {}
	try
	{
		a = dynamic_cast<C&>(p);
		std::cout << "C" << std::endl;
	}
	catch (std::bad_cast err) {}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x29b0(%rip), %rsi      # 0x3cd8
leaq 0x29d9(%rip), %rdx      # 0x3d08
xorl %ecx, %ecx
callq 0x1090
testq %rax, %rax
je 0x13d5
movq 0x2c92(%rip), %rdi      # 0x3fd8
leaq 0xcc0(%rip), %rsi       # 0x200d
callq 0x1060
movq %rax, %rdi
callq 0x1040
leaq 0x2977(%rip), %rsi      # 0x3cd8
leaq 0x29b8(%rip), %rdx      # 0x3d20
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1090
testq %rax, %rax
je 0x13da
movq 0x2c5a(%rip), %rdi      # 0x3fd8
leaq 0xc8a(%rip), %rsi       # 0x200f
callq 0x1060
movq %rax, %rdi
callq 0x1040
leaq 0x293f(%rip), %rsi      # 0x3cd8
leaq 0x2998(%rip), %rdx      # 0x3d38
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1090
testq %rax, %rax
je 0x13df
movq 0x2c22(%rip), %rdi      # 0x3fd8
leaq 0xc54(%rip), %rsi       # 0x2011
callq 0x1060
movq %rax, %rdi
callq 0x1040
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x10f0
callq 0x10f0
callq 0x10f0
movq %rax, %r14
cmpl $0x1, %edx
jne 0x1499
movq %r14, %rdi
callq 0x10a0
movq 0x2bc9(%rip), %rax      # 0x3fc8
addq $0x10, %rax
leaq -0x20(%rbp), %rbx
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x10e0
callq 0x10c0
jmp 0x13ca
movq %rax, %r14
cmpl $0x1, %edx
jne 0x1499
movq %r14, %rdi
callq 0x10a0
movq 0x2b90(%rip), %rax      # 0x3fc8
addq $0x10, %rax
leaq -0x20(%rbp), %r15
movq %rax, (%r15)
movq %r14, %rdi
callq 0x1030
movq %r15, %rdi
callq 0x10e0
callq 0x10c0
jmp 0x1392
movq %rax, %r14
cmpl $0x1, %edx
jne 0x1499
movq %r14, %rdi
callq 0x10a0
movq 0x2b54(%rip), %rax      # 0x3fc8
addq $0x10, %rax
leaq -0x20(%rbp), %r15
movq %rax, (%r15)
movq %r14, %rdi
callq 0x1030
movq %r15, %rdi
callq 0x10e0
callq 0x10c0
jmp 0x135a
movq %r14, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day06/ex02/main.cpp
// Function: main
int		main(void)
{
	Base	*a = new A();
	Base	*b = new B();
	Base	*c = new C();

	identify_from_pointer(a);
	identify_from_pointer(b);
	identify_from_pointer(c);
	std::cout << std::endl;
	identify_from_reference(*a);
	identify_from_reference(*b);
	identify_from_reference(*c);

	delete a;
	delete b;
	delete c;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $0x8
popq %r15
movq %r15, %rdi
callq 0x1070
movq %rax, %rbx
leaq 0x289f(%rip), %rax      # 0x3d60
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x1070
movq %rax, %r14
leaq 0x28aa(%rip), %rax      # 0x3d80
movq %rax, (%r14)
movq %r15, %rdi
callq 0x1070
movq %rax, %r15
leaq 0x28b5(%rip), %rax      # 0x3da0
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x1250
movq %r14, %rdi
callq 0x1250
movq %r15, %rdi
callq 0x1250
movq 0x2acb(%rip), %rdi      # 0x3fd8
callq 0x1040
movq %rbx, %rdi
callq 0x1314
movq %r14, %rdi
callq 0x1314
movq %r15, %rdi
callq 0x1314
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x52470
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
movsd 0x37288(%rip), %xmm0    # 0x8b058
movsd 0x37288(%rip), %xmm1    # 0x8b060
movaps %xmm1, %xmm2
callq 0x7e464
leaq 0x30(%rsp), %rdi
movsd 0x3721b(%rip), %xmm2    # 0x8b008
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x7e464
leaq 0x10(%rsp), %rdi
movsd 0x3723b(%rip), %xmm1    # 0x8b040
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
callq 0x7e464
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x836be
movl %r12d, 0x8(%rbx)
movl %r15d, 0xc(%rbx)
movl %r14d, 0x10(%rbx)
movb %bpl, 0x14(%rbx)
movq %rbx, %rdi
callq 0x83462
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 0x52480
movq %r14, %rdi
callq 0x527a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5bc1e
movq %rax, %r14
testq %rax, %rax
jne 0x56b6f
movq %r15, %rdi
callq 0x5c9ab
addq $0x68, %rbx
addq $0x28, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5c98e
addq $0x18, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x56bcc
leaq 0x35fbf(%rip), %rsi     # 0x8cb64
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x56548
movq %r14, %rdi
callq 0x6a74f
leaq 0x8(%rsp), %rdi
callq 0x52888
movq (%rbx), %rdi
leaq 0x59fad(%rip), %rsi     # 0xb0b80
leaq 0x59fe6(%rip), %rdx     # 0xb0bc0
xorl %ecx, %ecx
callq 0x524e0
testq %rax, %rax
je 0x56bfe
movq 0x28(%rax), %rcx
testq %rcx, %rcx
jne 0x56bf3
movq 0x18(%rax), %rcx
movq %rcx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x52800
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x52888
movq %rbx, %rdi
callq 0x527a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x526b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x52300
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
je 0x69f40
movq %rbx, %rdi
callq 0x67718
leaq 0x8(%rsp), %rdi
callq 0x52370
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x52370
movq %rbx, %rdi
callq 0x527a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x52260
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x6b2aa
movq 0x8(%r14), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x2, %esi
callq 0x52750
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/Renderer.cpp
// Function: RayTracer::Renderer::render(RayTracer::RenderWorld*, RayTracer::Camera*)
Image Renderer::render(RenderWorld* world, Camera* cam) {
    Image out(cam->width, cam->height);
    ProgressBar prgrs(0, cam->width * cam->height - 1);

    // Render it (how depends on if the program is threaded or not)
    #ifndef THREADED

    for (int y = cam->height-1; y >= 0; y--) {
        for (int x = 0; x < cam->width; x++) {
            // Render the pixel
            out[y][x] = world->render_pixel(x, y, *cam);

            if (this->show_progressbar) {
                prgrs.update();
            }
        }
    }

    #else

    // Create a thread pool
    ThreadPool pool(this->n_threads, this->batch_size);

    // Use the thread pool to render it
    unsigned long batch_index = 0;
    unsigned long to_do = cam->width * cam->height;
    while (batch_index < to_do) {
        // Update the progressbar in any case for smoothness
        if (this->show_progressbar) {
            prgrs.set(batch_index);
        }

        // If a the queue is full, wait for another thread to notify us it has taken an element
        if (pool.batch_queue_full()) {
            pool.wait();
        }

        // Create a new batch and append it
        PixelBatch batch = pool.get_batch(cam->width, cam->height, batch_index);
        batch.camera = cam;
        batch.world = world;
        batch.out = &out;
        pool.add_batch(batch);
    }

    // Wait until all threads have been reaped
    pool.complete();
    pool.stop();

    // Update the bar one last time
    if (this->show_progressbar) {
        prgrs.set(batch_index);
    }

    #endif

    return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl 0x8(%rcx), %esi
movl 0xc(%rcx), %edx
movq %rdi, 0x8(%rsp)
callq 0x7312e
movslq 0x8(%r14), %rax
movslq 0xc(%r14), %rdx
imulq %rax, %rdx
decq %rdx
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x82e06
movl 0xc(%r14), %ebp
leaq 0x28(%rsp), %r13
testl %ebp, %ebp
jle 0x72114
decl %ebp
xorl %ebx, %ebx
cmpl 0x8(%r14), %ebx
jge 0x720a8
movq %r13, %rdi
movq %r15, %rsi
movl %ebx, %edx
movl %ebp, %ecx
movq %r14, %r8
callq 0x84620
movq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x73494
movq %rax, 0x18(%rsp)
movl %edx, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
movl %ebx, %esi
callq 0x73004
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x72fd8
cmpb $0x1, 0x8(%r12)
jne 0x72110
leaq 0x48(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x8330a
incl %ebx
jmp 0x720b0
leaq 0x48(%rsp), %rdi
callq 0x72416
movq 0x8(%rsp), %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x7214b
jmp 0x7213e
jmp 0x7213e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x72416
movq 0x8(%rsp), %rdi
callq 0x731be
movq %rbx, %rdi
callq 0x527a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0x18, %rsi
movq %rbx, %rdi
callq 0x525e0
movb 0x38(%r15), %al
movb %al, 0x38(%r14)
movdqu 0x3c(%r15), %xmm0
movdqu %xmm0, 0x3c(%r14)
cmpb $0x1, %al
jne 0x7279b
pushq $0x10
popq %rdi
callq 0x52470
movq %rax, %r12
movq (%r15), %rsi
movq %rax, %rdi
callq 0x7314c
jmp 0x727f0
pshufd $0xee, %xmm0, %xmm0     # xmm0 = xmm0[2,3,2,3]
movd %xmm0, %edi
shlq $0x3, %rdi
callq 0x52040
movq %rax, 0x8(%r14)
xorl %ebp, %ebp
pushq $0x10
popq %r12
movq 0x10(%r14), %rax
cmpq %rax, %rbp
ja 0x727e8
movq %r12, %rdi
callq 0x52470
movq %rax, %r13
movq 0x8(%r15), %rax
movq (%rax,%rbp,8), %rsi
movq %r13, %rdi
callq 0x7314c
movq 0x8(%r14), %rax
movq %r13, (%rax,%rbp,8)
incq %rbp
jmp 0x727b7
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
movq %rax, %r14
pushq $0x10
popq %rsi
movq %r12, %rdi
jmp 0x7281d
jmp 0x7280f
movq %rax, %r14
jmp 0x72822
movq %rax, %r14
pushq $0x10
popq %rsi
movq %r13, %rdi
callq 0x52480
movq %rbx, %rdi
callq 0x52888
movq %r14, %rdi
callq 0x527a0
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0x18, %rsi
callq 0x525e0
movb 0x38(%rbx), %cl
movb %cl, 0x38(%r14)
movups 0x3c(%rbx), %xmm0
movups %xmm0, 0x3c(%r14)
movq %rbx, %rax
testb %cl, %cl
jne 0x72878
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
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x38(%rdi)
je 0x728ba
movq (%rbx), %r14
testq %r14, %r14
je 0x728ad
movq %r14, %rdi
callq 0x731be
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x52480
jmp 0x728f6
xorl %r12d, %r12d
pushq $0x10
popq %r14
movq 0x8(%rbx), %rdi
cmpq 0x10(%rbx), %r12
ja 0x728ec
movq (%rdi,%r12,8), %r15
testq %r15, %r15
je 0x728dc
movq %r15, %rdi
callq 0x731be
movq %r15, %rdi
movq %r14, %rsi
callq 0x52480
incq %r12
jmp 0x728c1
testq %rdi, %rdi
je 0x728f6
callq 0x52580
addq $0x18, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x52888
nop
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/Frames.cpp
// Function: RayTracer::Frames::next()
void Frames::next() {
    // Do nothing if we're already at the last frame
    if (this->frame_index == this->n_frames) {
        return;
    }

    // Depending on whether we should keep everything in memory, write current image to disk and delete it
    if (this->dynamic_writing) {
        this->current_frame->to_png(this->temp_dir + "/out" + to_string(this->frame_index) + ".png");

        delete this->current_frame;
    }

    // Create a new frame
    this->frame_index++;
    this->current_frame = new Image(this->width, this->height);

    // If we should keep everything in memory, update the frames list
    if (!this->dynamic_writing) {
        this->frames[this->frame_index] = this->current_frame;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq 0x10(%rdi), %rax
movl 0x44(%rdi), %ecx
cmpq %rcx, %rax
je 0x72a0e
movq %rdi, %rbx
cmpb $0x1, 0x38(%rdi)
jne 0x729d9
movq (%rbx), %r14
leaq 0x18(%rbx), %rsi
leaq 0x1d9ae(%rip), %rdx     # 0x902f1
leaq 0x28(%rsp), %rdi
callq 0x72e8d
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6eaa7
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x6aac0
leaq 0x1d931(%rip), %rdx     # 0x902a7
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x5a4df
leaq 0x68(%rsp), %rsi
movq %r14, %rdi
callq 0x735c4
leaq 0x68(%rsp), %rdi
callq 0x52888
leaq 0x48(%rsp), %rdi
callq 0x52888
leaq 0x8(%rsp), %rdi
callq 0x52888
leaq 0x28(%rsp), %rdi
callq 0x52888
movq (%rbx), %r14
testq %r14, %r14
je 0x729ca
movq %r14, %rdi
callq 0x731be
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x52480
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
pushq $0x10
popq %rdi
callq 0x52470
movq %rax, %r14
movl 0x3c(%rbx), %esi
movl 0x40(%rbx), %edx
movq %rax, %rdi
callq 0x7312e
movq %r14, (%rbx)
cmpb $0x0, 0x38(%rbx)
jne 0x72a0e
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq %r14, (%rax,%rcx,8)
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x52888
jmp 0x72a2b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x52888
jmp 0x72a3a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x52888
jmp 0x72a49
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x52888
jmp 0x72a63
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x52480
movq %rbx, %rdi
callq 0x527a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xa0, %rsp
movl %esi, %r14d
cmpl %esi, 0x8(%rdi)
jbe 0x7302e
leal (%r14,%r14,2), %eax
shlq $0x3, %rax
addq (%rdi), %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x52220
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movl %r14d, %esi
callq 0x72430
leaq 0x1d37a(%rip), %rsi     # 0x903c7
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x6e761
leaq 0x1d378(%rip), %rdx     # 0x903db
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5a4df
movq %rsp, %rdi
movl %r14d, %esi
callq 0x72430
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq %rsp, %rdx
callq 0x6aac0
movb $0x1, %bpl
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x52680
xorl %ebp, %ebp
movq 0x3eefa(%rip), %rsi     # 0xb1fa8
movq 0x3eedb(%rip), %rdx     # 0xb1f90
movq %rbx, %rdi
callq 0x52760
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0x52888
jmp 0x730d5
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x52888
jmp 0x730e5
movq %rax, %r14
movb $0x1, %bpl
leaq 0x60(%rsp), %rdi
callq 0x52888
jmp 0x730f7
movq %rax, %r14
movb $0x1, %bpl
leaq 0x40(%rsp), %rdi
callq 0x52888
jmp 0x73109
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x52888
testb %bpl, %bpl
jne 0x7311d
jmp 0x73125
movq %rax, %r14
movq %rbx, %rdi
callq 0x52350
movq %r14, %rdi
callq 0x527a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
movl 0xc(%r14), %edx
callq 0x7312e
movq 0x3ee1f(%rip), %rdi     # 0xb1f88
leaq 0x1d283(%rip), %rsi     # 0x903f3
callq 0x52450
movq %rax, %rdi
callq 0x52210
movl 0x8(%rbx), %eax
imull 0xc(%rbx), %eax
leal (%rax,%rax,2), %eax
movq (%r14), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
cmpq %rsi, %rax
je 0x731a3
movsd (%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x7318f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x731be
movq %r14, %rdi
callq 0x527a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xa0, %rsp
movl %esi, %r14d
cmpl %esi, 0xc(%rdi)
jbe 0x734c5
movl 0x8(%rdi), %edx
imull %edx, %r14d
leal (%r14,%r14,2), %eax
shlq $0x3, %rax
addq (%rdi), %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x52220
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movl %r14d, %esi
callq 0x72430
leaq 0x1cf67(%rip), %rsi     # 0x9044b
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x6e761
leaq 0x1cf61(%rip), %rdx     # 0x9045b
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5a4df
movq %rsp, %rdi
movl %r14d, %esi
callq 0x72430
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq %rsp, %rdx
callq 0x6aac0
movb $0x1, %bpl
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x52680
xorl %ebp, %ebp
movq 0x3ea63(%rip), %rsi     # 0xb1fa8
movq 0x3ea44(%rip), %rdx     # 0xb1f90
movq %rbx, %rdi
callq 0x52760
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0x52888
jmp 0x7356c
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x52888
jmp 0x7357c
movq %rax, %r14
movb $0x1, %bpl
leaq 0x60(%rsp), %rdi
callq 0x52888
jmp 0x7358e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x40(%rsp), %rdi
callq 0x52888
jmp 0x735a0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x52888
testb %bpl, %bpl
jne 0x735b4
jmp 0x735bc
movq %rax, %r14
movq %rbx, %rdi
callq 0x52350
movq %r14, %rdi
callq 0x527a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1d4d5(%rip), %rsi     # 0x90f61
movq %rdx, %rdi
callq 0x52520
testq %rax, %rax
je 0x73ab9
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x52850
movq %r15, %rdi
callq 0x52460
xorl %eax, %eax
jmp 0x73abc
pushq $0x4f
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lode_png_test_bitreader(unsigned char const*, unsigned long, unsigned long, unsigned long const*, unsigned int*)
unsigned lode_png_test_bitreader(const unsigned char* data, size_t size,
                                 size_t numsteps, const size_t* steps, unsigned* result) {
  size_t i;
  LodePNGBitReader reader;
  LodePNGBitReader_init(&reader, data, size);
  for(i = 0; i < numsteps; i++) {
    size_t step = steps[i];
    unsigned ok;
    if(step > 25) ok = ensureBits32(&reader, step);
    else if(step > 17) ok = ensureBits25(&reader, step);
    else if(step > 9) ok = ensureBits17(&reader, step);
    else ok = ensureBits9(&reader, step);
    if(!ok) return 0;
    result[i] = readBits(&reader, step);
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, (%rsp)
movq %rsi, 0x8(%rsp)
leaq (,%rsi,8), %rax
movq %rax, 0x10(%rsp)
shrq $0x3d, %rsi
setne %cl
cmpq $-0x40, %rax
setae %al
orb %cl, %al
jne 0x73b15
andq $0x0, 0x18(%rsp)
andl $0x0, 0x20(%rsp)
xorl %ebp, %ebp
movq %rsp, %r12
cmpq %rbp, %r15
je 0x73b7c
movq (%r14,%rbp,8), %r13
movq %r12, %rdi
movq %r13, %rsi
cmpq $0x1a, %r13
jb 0x73b36
callq 0x73b92
jmp 0x73b55
cmpq $0x12, %r13
jb 0x73b43
callq 0x73c53
jmp 0x73b55
cmpq $0xa, %r13
jb 0x73b50
callq 0x73cdb
jmp 0x73b55
callq 0x73d52
testl %eax, %eax
je 0x73b81
pushq $-0x1
popq %rax
movl %r13d, %ecx
shll %cl, %eax
movl 0x20(%rsp), %edx
notl %eax
andl %edx, %eax
shrl %cl, %edx
movl %edx, 0x20(%rsp)
addq %r13, 0x18(%rsp)
movl %eax, (%rbx,%rbp,4)
incq %rbp
jmp 0x73b1a
pushq $0x1
popq %rax
jmp 0x73b83
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: ensureBits32(LodePNGBitReader*, unsigned long)
static LODEPNG_INLINE unsigned ensureBits32(LodePNGBitReader* reader, size_t nbits) {
  size_t start = reader->bp >> 3u;
  size_t size = reader->size;
  if(start + 4u < size) {
    reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u) |
                     ((unsigned)reader->data[start + 2] << 16u) | ((unsigned)reader->data[start + 3] << 24u);
    reader->buffer >>= (reader->bp & 7u);
    reader->buffer |= (((unsigned)reader->data[start + 4] << 24u) << (8u - (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);
    if(start + 2u < size) reader->buffer |= ((unsigned)reader->data[start + 2] << 16u);
    if(start + 3u < size) reader->buffer |= ((unsigned)reader->data[start + 3] << 24u);
    reader->buffer >>= (reader->bp & 7u);
    return reader->bp + nbits <= reader->bitsize;
  }
}

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x18(%rdi), %rax
movq %rax, %rdx
shrq $0x3, %rdx
leaq 0x4(%rdx), %r8
cmpq %rcx, %r8
jae 0x73bd4
movq (%rdi), %rsi
movl (%rsi,%rdx), %r8d
andb $0x7, %al
movl %eax, %ecx
shrl %cl, %r8d
movl %r8d, 0x20(%rdi)
movzbl 0x4(%rsi,%rdx), %edx
shll $0x18, %edx
movb $0x8, %cl
subb %al, %cl
shll %cl, %edx
orl %r8d, %edx
movl %edx, 0x20(%rdi)
pushq $0x1
popq %rax
retq
andl $0x0, 0x20(%rdi)
xorl %r8d, %r8d
cmpq %rcx, %rdx
jae 0x73bec
movq (%rdi), %r8
movzbl (%r8,%rdx), %r8d
movl %r8d, 0x20(%rdi)
leaq 0x1(%rdx), %r9
cmpq %rcx, %r9
jae 0x73c08
movq (%rdi), %r10
movzbl (%r10,%r9), %r9d
shll $0x8, %r9d
orl %r9d, %r8d
movl %r8d, 0x20(%rdi)
leaq 0x2(%rdx), %r9
cmpq %rcx, %r9
jae 0x73c24
movq (%rdi), %r10
movzbl (%r10,%r9), %r9d
shll $0x10, %r9d
orl %r9d, %r8d
movl %r8d, 0x20(%rdi)
addq $0x3, %rdx
cmpq %rcx, %rdx
jae 0x73c3a
movq (%rdi), %rcx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
orl %ecx, %r8d
movl %eax, %ecx
andb $0x7, %cl
shrl %cl, %r8d
movl %r8d, 0x20(%rdi)
addq %rax, %rsi
xorl %eax, %eax
cmpq 0x10(%rdi), %rsi
setbe %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: ensureBits25(LodePNGBitReader*, unsigned long)
static LODEPNG_INLINE unsigned ensureBits25(LodePNGBitReader* reader, size_t nbits) {
  size_t start = reader->bp >> 3u;
  size_t size = reader->size;
  if(start + 3u < size) {
    reader->buffer = (unsigned)reader->data[start + 0] | ((unsigned)reader->data[start + 1] << 8u) |
                     ((unsigned)reader->data[start + 2] << 16u) | ((unsigned)reader->data[start + 3] << 24u);
    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);
    if(start + 2u < size) reader->buffer |= ((unsigned)reader->data[start + 2] << 16u);
    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 0x3(%rcx), %rdx
cmpq %r8, %rdx
jae 0x73c7e
movq (%rdi), %rdx
movl (%rdx,%rcx), %edx
andb $0x7, %al
movl %eax, %ecx
shrl %cl, %edx
movl %edx, 0x20(%rdi)
pushq $0x1
popq %rax
retq
andl $0x0, 0x20(%rdi)
xorl %edx, %edx
cmpq %r8, %rcx
jae 0x73c93
movq (%rdi), %rdx
movzbl (%rdx,%rcx), %edx
movl %edx, 0x20(%rdi)
leaq 0x1(%rcx), %r9
cmpq %r8, %r9
jae 0x73cae
movq (%rdi), %r10
movzbl (%r10,%r9), %r9d
shll $0x8, %r9d
orl %r9d, %edx
movl %edx, 0x20(%rdi)
addq $0x2, %rcx
cmpq %r8, %rcx
jae 0x73cc4
movq (%rdi), %r8
movzbl (%r8,%rcx), %ecx
shll $0x10, %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