LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: swirl(manifold*, tetra*, int)
tetra *swirl(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() == 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.
	}
	
	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() != 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, %r15
movq %rdi, %rbx
leaq 0xd8b1(%rip), %r13      # 0x1e650
xorl %r12d, %r12d
cmpq $0x0, 0x10(%r15,%r12,8)
jne 0x10dd3
movq %r15, %rdi
movl %r12d, %esi
callq 0xe150
movq 0x10(%r15,%r12,8), %rax
cmpl %ebp, 0x90(%rax)
jne 0x10dc8
cmpl $0x6, 0x70(%rax)
je 0x10e44
movq %r15, %rdi
movl %r12d, %esi
callq 0xdf6a
incq %r12
addq $0x10, %r13
cmpq $0x3, %r12
jne 0x10da2
movq %r15, %r14
leaq 0xd866(%rip), %r12      # 0x1e650
xorl %r15d, %r15d
cmpq $0x0, 0x10(%r14,%r15,8)
jne 0x10e22
movq %r14, %rdi
movl %r15d, %esi
callq 0xe150
movq 0x10(%r14,%r15,8), %rax
cmpl %ebp, 0x90(%rax)
jne 0x10e17
cmpl $0x6, 0x70(%rax)
jne 0x10e9b
movq %r14, %rdi
movl %r15d, %esi
callq 0xdf6a
incq %r15
addq $0x10, %r12
cmpq $0x3, %r15
jne 0x10ded
movq %r14, %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, %r14
movq $0x0, (%rsp)
movq %rax, %rdi
movq %rbx, %rsi
movl $0x7, %edx
movl $0x3, %ecx
movl $0x2, %r8d
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0xdc7c
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movq %r13, %rcx
callq 0xe02c
movq %r15, %rdi
movl %r12d, %esi
callq 0xe150
jmp 0x10de3
movl $0xc0, %edi
callq 0x3210
movq %rax, %r13
movq $0x0, (%rsp)
movq %rax, %rdi
movq %rbx, %rsi
movl $0x7, %edx
movl $0x3, %ecx
movl $0x2, %r8d
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0xdc7c
movq %r14, %rdi
movq %r13, %rsi
movl %r15d, %edx
movq %r12, %rcx
callq 0xe02c
movq %r14, %rdi
movl %r15d, %esi
callq 0xe150
jmp 0x10e32
movq %rax, %rbx
movq %r13, %r14
jmp 0x10efd
movq %rax, %rbx
movl $0xc0, %esi
movq %r14, %rdi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd724(%rip), %r15      # 0x1e650
xorl %r14d, %r14d
cmpq $0x0, 0x10(%rbx,%r14,8)
jne 0x10f66
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe150
movq 0x10(%rbx,%r14,8), %rax
cmpl %ebp, 0x90(%rax)
jne 0x10f5b
movl 0x70(%rax), %eax
movq 0x28(%rbx), %rcx
cmpl 0x70(%rcx), %eax
je 0x10f88
movq %rbx, %rdi
movl %r14d, %esi
callq 0xdf6a
incq %r14
addq $0x10, %r15
cmpq $0x3, %r14
jne 0x10f2f
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 0xdc7c
movq %rbx, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %r15, %rcx
callq 0xe02c
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe150
jmp 0x10f76
movq %rax, %rbx
movl $0xc0, %esi
movq %r13, %rdi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd642(%rip), %r15      # 0x1e650
xorl %r14d, %r14d
cmpq $0x0, 0x10(%rbx,%r14,8)
jne 0x11055
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe150
movq 0x10(%rbx,%r14,8), %r13
movl 0x70(%r13), %eax
cmpl $0x8, %eax
je 0x110b9
cmpl %ebp, 0x90(%r13)
setne %cl
cmpl $0x6, %eax
sete %al
orb %cl, %al
je 0x11067
movq %rbx, %rdi
movl %r14d, %esi
callq 0xdf6a
incq %r14
addq $0x10, %r15
cmpq $0x3, %r14
jne 0x11011
movq %rbx, %r13
jmp 0x110b9
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 0xdc7c
movq %rbx, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %r15, %rcx
callq 0xe02c
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe150
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_O1/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 0x61d5(%rip), %rsi      # 0x17886
leaq 0x61d6(%rip), %rdx      # 0x1788e
leaq 0x8(%rsp), %rdi
callq 0x86fe
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x4209
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x116e8
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 0x11733
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x11736
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
jmp 0x11736
movq %rax, %r15
leaq 0x40(%r14), %r13
movq 0x58(%r14), %rdi
testq %rdi, %rdi
je 0x1174f
movq 0x68(%r14), %rsi
subq %rdi, %rsi
callq 0x3220
movq (%r13), %rdi
testq %rdi, %rdi
je 0x11764
movq 0x50(%r14), %rsi
subq %rdi, %rsi
callq 0x3220
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x11778
movq (%r12), %rsi
incq %rsi
callq 0x3220
movq %r15, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5ef6(%rip), %rsi      # 0x17690
leaq 0x5ef9(%rip), %rdx      # 0x1769a
leaq 0x8(%rsp), %rdi
callq 0x86fe
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x4209
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x117d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x117e3
movq %rbx, %rdi
callq 0x1187a
jmp 0x117d1
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x11826
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x1180c
movl $0x40, %esi
callq 0x3220
incq %r14
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r14
jl 0x117f9
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x1183b
movq 0x68(%rbx), %rsi
subq %rdi, %rsi
callq 0x3220
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x11850
movq 0x50(%rbx), %rsi
subq %rdi, %rsi
callq 0x3220
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x11868
movq (%rbx), %rsi
incq %rsi
callq 0x3220
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x11872
movq %rax, %rdi
callq 0x86f2
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdf6a
incl %ebp
cmpl $0x4, %ebp
jne 0x11886
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
movq %rcx, %rdx
cmoveq %r14, %rdx
movq %rax, (%rdx)
movq (%rbx), %rax
testq %rax, %rax
cmoveq %r14, %rax
movq %rcx, 0x8(%rax)
callq 0xde22
movl $0xc0, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11ac7
leal 0x1(%rcx), %eax
leal 0x4(%rcx), %r8d
testl %eax, %eax
cmovnsl %eax, %r8d
andl $-0x4, %r8d
negl %r8d
addl %r8d, %ecx
incl %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 0x11add
cmpl %ecx, %r8d
jne 0x11add
cmpl %edx, %r9d
jne 0x11add
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb061(%rip), %r15      # 0x1e22a
cmpb $0x1, (%r15)
jne 0x131d7
movq %rbx, %rdi
callq 0x105e6
movq %rbx, %rdi
callq 0x118d0
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11b16
cmpb $0x1, (%r15)
jne 0x131fe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12396
leaq 0xb024(%rip), %rax      # 0x1e229
cmpb $0x1, (%rax)
jne 0x1321a
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x12e40
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x139b0
incq %rcx
cmpq $0x4, %rcx
jne 0x139ab
testb $0x1, %al
je 0x13a10
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x3f68(%rip), %rsi      # 0x17948
leaq 0x3f76(%rip), %rdx      # 0x1795d
movq %rsp, %r15
movq %r15, %rdi
callq 0x86fe
movq %r15, %rdi
callq 0x4397
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x13a10
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 0x13a46
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r13
cmpq 0x8(%rsi), %r13
je 0x2599
movq %rdx, %r14
movq %rsi, %r15
leaq 0x6c9(%rip), %r12       # 0x2c05
movq %r13, %rbx
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %r12, %r8
callq 0x2ec1
cmpq %rdx, %rax
je 0x258b
movq %rbx, %rcx
subq (%r15), %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rcx
movq %rdx, -0x48(%rbp)
movq %rax, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x31d8
addq $0x18, %r13
addq $0x18, %rbx
cmpq 0x8(%r15), %r13
jne 0x253f
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25ae
movq %rax, %r14
movq -0x30(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x25cd
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x2150
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x480d
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2659
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2cfc
jmp 0x2633
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x26ae
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 -0x285(%rip), %rcx      # 0x240c
movq %r14, %rdi
movq %r15, %rsi
callq 0x366a
leaq -0x297(%rip), %rdx      # 0x240c
movq %r14, %rdi
movq %r15, %rsi
callq 0x3769
leaq -0x258(%rbp), %rdi
callq 0x2040
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x26cf
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 0x26f8
jmp 0x26e9
movq %rax, %r14
leaq -0x258(%rbp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2d60
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x2715
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2150
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b8a
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 0x25d5
leaq -0x50(%rbp), %rdi
movq %r13, %rsi
callq 0x430a
movq %r13, %rdi
callq 0x2d60
movq -0x270(%rbp), %rdi
leaq -0x260(%rbp), %rax
cmpq %rax, %rdi
je 0x2b2a
movq -0x260(%rbp), %rsi
incq %rsi
callq 0x2150
incq %r12
cmpq %r12, %r14
jne 0x2ad9
leaq 0x253c(%rip), %rsi      # 0x5075
leaq -0x270(%rbp), %rdi
movl $0x8, %edx
callq 0x2210
movq 0x4487(%rip), %rsi      # 0x6fd8
leaq -0x270(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x271d
leaq -0x270(%rbp), %rdi
callq 0x2040
leaq -0x50(%rbp), %rdi
callq 0x2dca
xorl %eax, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24b8(%rip), %rdi      # 0x5049
leaq 0x24ba(%rip), %rsi      # 0x5052
leaq 0x24bf(%rip), %rcx      # 0x505e
movl $0x7f, %edx
callq 0x20b0
movq %rax, %rbx
leaq -0x270(%rbp), %rdi
callq 0x2040
jmp 0x2bf4
jmp 0x2bbc
movq %rax, %rbx
jmp 0x2bf4
movq %rax, %rbx
jmp 0x2bd2
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2d60
movq -0x270(%rbp), %rdi
leaq -0x260(%rbp), %rax
cmpq %rax, %rdi
je 0x2bf4
movq -0x260(%rbp), %rsi
incq %rsi
callq 0x2150
leaq -0x50(%rbp), %rdi
callq 0x2dca
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x1030
movq 0x2e2e(%rip), %rax      # 0x3fe0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %rbx, 0xd8(%rax,%rcx)
movq 0x2e08(%rip), %rax      # 0x3fd0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %rbx, 0xd8(%rax,%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xda0(%rip), %xmm0      # 0x2014
leaq -0x70(%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 0x1446
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq %rsi
leaq -0x70(%rbp), %rdi
xorl %edx, %edx
callq 0x148c
movq %rax, %r14
movq %rax, %rbx
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %r15
subq %rsi, %r15
je 0x12d5
movq %rbx, %rdi
movq %r15, %rdx
callq 0x10e0
addq %r15, %r14
movq -0x40(%rbp), %rax
subq -0x48(%rbp), %rax
je 0x12f5
xorl %ecx, %ecx
movl $0x2a, (%r14,%rcx)
addq $0x4, %rcx
cmpq %rcx, %rax
jne 0x12e4
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x1340
xorl %r13d, %r13d
movq 0x2ccf(%rip), %r15      # 0x3fd8
leaq 0xd18(%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 0x1310
movq 0x2c91(%rip), %rdi      # 0x3fd8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq 0x2c76(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x13ba
xorl %r15d, %r15d
movq 0x2c55(%rip), %r12      # 0x3fd8
leaq 0xc9e(%rip), %r13       # 0x2028
movl (%r14,%r15,4), %esi
movq %r12, %rdi
callq 0x10f0
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x10c0
incq %r15
movq -0x40(%rbp), %rax
subq -0x48(%rbp), %rax
sarq $0x2, %rax
cmpq %rax, %r15
jne 0x138a
movq 0x2c17(%rip), %rdi      # 0x3fd8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq 0x2bfc(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq -0x40(%rbp), %rsi
subq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x10b0
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x140e
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x10b0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1425
jmp 0x1425
jmp 0x1425
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x143d
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x10b0
movq %rbx, %rdi
callq 0x1100
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
testq %rdi, %rdi
je 0x145c
movq %rdi, %rbx
leaq 0x2993(%rip), %rsi      # 0x3cd8
leaq 0x29bc(%rip), %rdx      # 0x3d08
xorl %ecx, %ecx
callq 0x10a0
testq %rax, %rax
je 0x139a
movq 0x2c79(%rip), %r14      # 0x3fd8
leaq 0xca7(%rip), %rsi       # 0x200d
movl $0x1, %edx
movq %r14, %rdi
callq 0x10b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
leaq 0x2937(%rip), %rsi      # 0x3cd8
leaq 0x2978(%rip), %rdx      # 0x3d20
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x10a0
testq %rax, %rax
je 0x13f9
movq 0x2c1a(%rip), %r14      # 0x3fd8
leaq 0xc4a(%rip), %rsi       # 0x200f
movl $0x1, %edx
movq %r14, %rdi
callq 0x10b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
leaq 0x28d8(%rip), %rsi      # 0x3cd8
leaq 0x2931(%rip), %rdx      # 0x3d38
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x10a0
testq %rax, %rax
je 0x145c
movq 0x2bbb(%rip), %rbx      # 0x3fd8
leaq 0xbed(%rip), %rsi       # 0x2011
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1050
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2866(%rip), %rsi      # 0x3cd8
leaq 0x288f(%rip), %rdx      # 0x3d08
xorl %ecx, %ecx
callq 0x10a0
testq %rax, %rax
je 0x159e
movq 0x2b48(%rip), %r14      # 0x3fd8
leaq 0xb76(%rip), %rsi       # 0x200d
movl $0x1, %edx
movq %r14, %rdi
callq 0x10b0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq 0x2b16(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1050
leaq 0x2802(%rip), %rsi      # 0x3cd8
leaq 0x2843(%rip), %rdx      # 0x3d20
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x10a0
testq %rax, %rax
je 0x15a3
movq 0x2ae1(%rip), %r14      # 0x3fd8
leaq 0xb11(%rip), %rsi       # 0x200f
movl $0x1, %edx
movq %r14, %rdi
callq 0x10b0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq 0x2aaf(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1050
leaq 0x279b(%rip), %rsi      # 0x3cd8
leaq 0x27f4(%rip), %rdx      # 0x3d38
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x10a0
testq %rax, %rax
je 0x15a8
movq 0x2a7e(%rip), %rbx      # 0x3fd8
leaq 0xab0(%rip), %rsi       # 0x2011
movl $0x1, %edx
movq %rbx, %rdi
callq 0x10b0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq 0x2a4c(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1050
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1110
callq 0x1110
callq 0x1110
cmpl $0x1, %edx
jne 0x15e6
movq %rax, %rdi
movl %edx, %esi
callq 0x11b6
jmp 0x1599
cmpl $0x1, %edx
jne 0x15e6
movq %rax, %rdi
movl %edx, %esi
callq 0x1173
jmp 0x1536
cmpl $0x1, %edx
jne 0x15e6
movq %rax, %rdi
movl %edx, %esi
callq 0x1130
jmp 0x14cf
movq %rax, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl $0x8, %edi
callq 0x1080
movq %rax, %rbx
leaq 0x2753(%rip), %rax      # 0x3d60
movq %rax, (%rbx)
movl $0x8, %edi
callq 0x1080
movq %rax, %r14
leaq 0x275c(%rip), %rax      # 0x3d80
movq %rax, (%r14)
movl $0x8, %edi
callq 0x1080
movq %rax, %r15
leaq 0x2765(%rip), %rax      # 0x3da0
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x132b
movq %r14, %rdi
callq 0x132b
movq %r15, %rdi
callq 0x132b
movq 0x297b(%rip), %r12      # 0x3fd8
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %r12, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x1461
movq %r14, %rdi
callq 0x1461
movq %r15, %rdi
callq 0x1461
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
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Lut99[P]RayTracer/src/RayTracer.cpp
// Function: update_camera(RayTracer::Camera*, unsigned int, unsigned int, unsigned int, bool)
void update_camera(Camera* cam, unsigned int screen_width, unsigned int screen_height, unsigned int number_of_rays, bool correct_gamma) {
    cam->width = screen_width;
    cam->height = screen_height;
    cam->rays = number_of_rays;
    cam->gamma = correct_gamma;
}

// Assembly:
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %ecx, 0x10(%rdi)
movb %r8b, 0x14(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a460
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
movsd 0x47303(%rip), %xmm0    # 0x84058
movsd 0x47303(%rip), %xmm1    # 0x84060
movaps %xmm1, %xmm2
callq 0x729ee
leaq 0x30(%rsp), %rdi
movsd 0x47296(%rip), %xmm2    # 0x84008
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x729ee
leaq 0x10(%rsp), %rdi
movsd 0x472b6(%rip), %xmm1    # 0x84040
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
callq 0x729ee
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x79cc6
movl %r12d, 0x8(%rbx)
movl %r15d, 0xc(%rbx)
movl %r14d, 0x10(%rbx)
movb %bpl, 0x14(%rbx)
movq %rbx, %rdi
callq 0x79a6a
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 0x3a470
movq %r14, %rdi
callq 0x3a780
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x47420
movq %rax, %r15
testq %rax, %rax
jne 0x4131f
movq %r14, %rdi
callq 0x48654
leaq 0x68(%rbx), %rdi
movq %r15, %rcx
addq $0x28, %rcx
movq 0x28(%r15), %r8
movq %r8, %rax
xorl %edx, %edx
divq 0x70(%rbx)
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq 0x4827c
movq (%rax), %rax
addq $0x18, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, (%rdi)
jne 0x413a4
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x447f3(%rip), %rsi     # 0x85b67
leaq 0x447f4(%rip), %rdx     # 0x85b6f
movq %rsp, %r14
movq %r14, %rdi
callq 0x44728
movq %r14, %rdi
callq 0x57faa
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x413a4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3a470
movq (%rbx), %rdi
leaq 0x62392(%rip), %rsi     # 0xa3740
leaq 0x623cb(%rip), %rdx     # 0xa3780
xorl %ecx, %ecx
callq 0x3a4e0
testq %rax, %rax
je 0x413db
movq 0x28(%rax), %rcx
testq %rcx, %rcx
jne 0x413ce
movq 0x18(%rax), %rcx
movq %rcx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x3a7f0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x413f9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3a470
movq %rbx, %rdi
callq 0x3a780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a6b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x3a2e0
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
je 0x57854
movq %rbx, %rdi
callq 0x54fd6
movq 0x4d6cd(%rip), %rsi     # 0xa4f28
leaq 0x8(%rsp), %rdi
callq 0x3a350
leaq 0x88(%rsp), %rdi
callq 0x3a150
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x4d69f(%rip), %rsi     # 0xa4f28
leaq 0x8(%rsp), %rdi
callq 0x3a350
leaq 0x88(%rsp), %rdi
callq 0x3a150
movq %rbx, %rdi
callq 0x3a780
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x58c5d
movzbl (%rax), %ebp
incq %rax
movq %rax, 0x10(%rdi)
cmpl $-0x1, %ebp
jne 0x58c54
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x2, %esi
callq 0x3a740
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rdi), %rax
callq *0x50(%rax)
movl %eax, %ebp
jmp 0x58c34
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x48976
movb 0x38(%r15), %al
movb %al, 0x38(%r14)
movdqu 0x3c(%r15), %xmm0
movdqu %xmm0, 0x3c(%r14)
cmpb $0x1, %al
jne 0x62a7a
movl $0x10, %edi
callq 0x3a460
movq %rax, %r12
movq (%r15), %rsi
movq %rax, %rdi
callq 0x63e56
jmp 0x62acb
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 0x3a460
movq %rax, %r12
movq 0x8(%r15), %rax
movq (%rax,%rbp,8), %rsi
movq %r12, %rdi
callq 0x63e56
movq 0x8(%r14), %rax
movq %r12, (%rax,%rbp,8)
incq %rbp
movq 0x10(%r14), %rax
cmpq %rax, %rbp
jbe 0x62a92
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 0x62ae6
jmp 0x62ae1
movq %rax, %r14
jmp 0x62af6
movq %rax, %r14
movl $0x10, %esi
movq %r12, %rdi
callq 0x3a470
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x62b0a
movq (%r13), %rsi
incq %rsi
callq 0x3a470
movq %r14, %rdi
callq 0x3a780
// File: /workspace/github_cpp_makefile_star2_O1/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 0x48976
movb 0x38(%rbx), %cl
movb %cl, 0x38(%r14)
movups 0x3c(%rbx), %xmm0
movups %xmm0, 0x3c(%r14)
movq %rbx, %rax
testb %cl, %cl
jne 0x62b67
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_O1/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 0x62ba9
movq (%rbx), %r14
testq %r14, %r14
je 0x62be5
movq %r14, %rdi
callq 0x63f0c
movl $0x10, %esi
movq %r14, %rdi
callq 0x3a470
jmp 0x62be5
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x62bce
movq %r14, %rdi
callq 0x63f0c
movl $0x10, %esi
movq %r14, %rdi
callq 0x3a470
incq %r15
cmpq 0x10(%rbx), %r15
jbe 0x62bac
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x62be5
callq 0x3a580
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x62c02
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3a470
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Lut99[P]RayTracer/src/lib/Image.cpp
// Function: RayTracer::Pixel::operator=(RayTracer::Pixel const&)
Pixel& Pixel::operator=(const Pixel& other) {
    this->data[0] = other.data[0];
    this->data[1] = other.data[1];
    this->data[2] = other.data[2];
    return *this;
}

// Assembly:
movq %rdi, %rax
movq (%rsi), %rcx
movsd (%rcx), %xmm0
movq (%rdi), %rdx
movsd %xmm0, (%rdx)
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rdx)
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/Lut99[P]RayTracer/src/lib/Image.cpp
// Function: RayTracer::Pixel::operator=(RayTracer::Vec3 const&)
Pixel& Pixel::operator=(const Vec3& other) {
    // Simply set our own data to given vector
    this->data[0] = other.x;
    this->data[1] = other.y;
    this->data[2] = other.z;
    return *this;
}

// Assembly:
movq %rdi, %rax
movsd 0x8(%rsi), %xmm0
movq (%rdi), %rcx
movsd %xmm0, (%rcx)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x8(%rcx)
movsd 0x18(%rsi), %xmm0
movsd %xmm0, 0x10(%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x63c98
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 0x48(%rsp), %rdi
movl %r14d, %esi
callq 0x6481e
leaq 0x2558e(%rip), %rsi     # 0x89247
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x5d118
leaq 0x2558c(%rip), %rsi     # 0x8925b
leaq 0x68(%rsp), %rdi
callq 0x3a800
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x63cfa
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x63d07
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 0x28(%rsp), %rdi
movl %r14d, %esi
callq 0x6481e
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x6489e
movb $0x1, %bpl
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x3a670
xorl %ebp, %ebp
movq 0x41249(%rip), %rsi     # 0xa4fa8
movq 0x4122a(%rip), %rdx     # 0xa4f90
movq %rbx, %rdi
callq 0x3a750
movq %rax, %r14
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63d9a
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x3a470
jmp 0x63d9a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63dbd
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3a470
jmp 0x63dbd
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x63ddc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3a470
jmp 0x63ddc
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63dff
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3a470
jmp 0x63dff
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63e22
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3a470
jmp 0x63e22
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x63e2f
movq %rbx, %rdi
callq 0x3a330
movq %r14, %rdi
callq 0x3a780
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41102(%rip), %r15     # 0xa4f88
leaq 0x253e6(%rip), %rsi     # 0x89273
movl $0x10, %edx
movq %r15, %rdi
callq 0x3a4f0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x3a430
movsbl %al, %esi
movq 0x410d0(%rip), %rdi     # 0xa4f88
callq 0x3a050
movq %rax, %rdi
callq 0x3a300
movl 0x8(%rbx), %eax
imull 0xc(%rbx), %eax
leal (%rax,%rax,2), %eax
testl %eax, %eax
je 0x63eed
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 0x63edb
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x63f03
callq 0x3a580
movq %r14, %rdi
callq 0x3a780
nop