LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: tetra::ungluesym(int)
void tetra::ungluesym(int whichface)
{
	if (gluedto[whichface] == NULL) 
		return;  // This is correct as it simplifies later loops.
	
	if (gluedto[whichface]->get_gluedto(gluing[whichface][whichface]) == NULL)
		output_error("Non-symmetric gluing detected.");
	
	gluedto[whichface]->set_gluedto(gluing[whichface][whichface], NULL);  // Unglue him from me.
	this->set_gluedto(whichface, NULL);  // Then unglue me from him.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq -0xc(%rbp), %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
jne 0x17548
jmp 0x17638
movq -0x50(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq 0x10(%rdi,%rax,8), %rax
movq %rax, -0x58(%rbp)
addq $0x30, %rdi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x16f80
movq -0x58(%rbp), %rdi
movl %eax, %esi
callq 0x20b60
cmpq $0x0, %rax
jne 0x175f1
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3560
movq -0x60(%rbp), %rdx
leaq 0xff3c(%rip), %rsi      # 0x274d5
leaq -0x30(%rbp), %rdi
callq 0x4e10
jmp 0x175a4
leaq -0x30(%rbp), %rdi
callq 0x4d40
jmp 0x175af
leaq -0x30(%rbp), %rdi
callq 0x35f8
leaq -0x31(%rbp), %rdi
callq 0x3360
jmp 0x175f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x175e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x35f8
leaq -0x31(%rbp), %rdi
callq 0x3360
jmp 0x1763e
movq -0x50(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq 0x10(%rdi,%rax,8), %rax
movq %rax, -0x68(%rbp)
addq $0x30, %rdi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x16f80
movq -0x68(%rbp), %rdi
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x209e0
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x209e0
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3550
nopw (%rax,%rax)
// File: MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: tetra::subbedby(tetra*, int, perm const&)
void tetra::subbedby(tetra *whereglue, int whichface, const perm &how)
{
	// before:    A-B   D free
	// after:     A free   D-B
	
	// A: this
	// D: whereglue
	// B: *gluedto[whichface]
	
	// "how" maps vertices of A to vertices of D
	// (Identity means glue D to B just like A was glued)
	// "how" should be an even permutation.
	
	if (gluedto[whichface] == NULL)
		return;
	if (whereglue->gluedto[how[whichface]] != NULL)
		output_error("Invalid subbedby. Attempted to substitute non-free face.");
	
	perm AtoB = gluing[whichface];
	
	tetra *B = gluedto[whichface];
	ungluesym(whichface);  // Separate A & B.
	B->gluesym(whereglue, AtoB[whichface], how.of(AtoB.inverse()));  // Glue B to D.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movslq -0x14(%rbp), %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
jne 0x17686
jmp 0x177dc
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x16f80
movl %eax, %ecx
movq -0xa0(%rbp), %rax
movslq %ecx, %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
je 0x1772a
leaq -0x41(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3560
movq -0xa8(%rbp), %rdx
leaq 0xfe25(%rip), %rsi      # 0x274f4
leaq -0x40(%rbp), %rdi
callq 0x4e10
jmp 0x176da
leaq -0x40(%rbp), %rdi
callq 0x4d40
jmp 0x176e5
leaq -0x40(%rbp), %rdi
callq 0x35f8
leaq -0x41(%rbp), %rdi
callq 0x3360
jmp 0x1772a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1771c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x35f8
leaq -0x41(%rbp), %rdi
callq 0x3360
jmp 0x177e5
movq -0x98(%rbp), %rsi
addq $0x30, %rsi
movslq -0x14(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
leaq -0x64(%rbp), %rdi
callq 0x16ee0
movq -0x98(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq 0x10(%rdi,%rax,8), %rax
movq %rax, -0x70(%rbp)
movl -0x14(%rbp), %esi
callq 0x17520
movq -0x70(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl -0x14(%rbp), %esi
leaq -0x64(%rbp), %rdi
callq 0x16f80
movl %eax, -0xac(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x16fa0
movq -0xc8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x17000
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movl -0xac(%rbp), %edx
leaq -0x80(%rbp), %rcx
callq 0x17390
addq $0xd0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3550
nop
// File: MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: tetra::walk_about(int)
void tetra::walk_about(int fromface)
{
	output_debugging("walk", 3);
	
	if (gluedto[fromface] != NULL)
		return;
	
	// Here's how we start.
	tetra *currenttetra = this;
	perm init_how = perm_walk_about_list[fromface];
	perm how = init_how;
	
	// Now walk around the edge.
	while ((currenttetra->gluedto[how[fromface]]) != NULL)
	{
		int dir = how[fromface];
		how = (currenttetra->get_gluing(dir)).of(how.of(init_how));  // Composition of 3 odd permutations is also odd.
		currenttetra = currenttetra->get_gluedto(dir);
	}
	
	// We've found the last tetra next to the edge
	// so glue it to the first one.
	gluesym(currenttetra, fromface, how);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3560
movq -0xb0(%rbp), %rdx
leaq 0xfd02(%rip), %rsi      # 0x2752d
leaq -0x30(%rbp), %rdi
callq 0x4e10
jmp 0x17836
leaq -0x30(%rbp), %rdi
movl $0x3, %esi
callq 0x4c10
jmp 0x17846
leaq -0x30(%rbp), %rdi
callq 0x35f8
leaq -0x31(%rbp), %rdi
callq 0x3360
movq -0xb8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
je 0x178a1
jmp 0x1798e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x17893
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x35f8
leaq -0x31(%rbp), %rdi
callq 0x3360
jmp 0x17997
movq -0xb8(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq -0xc(%rbp), %rax
leaq 0x1de49(%rip), %rsi     # 0x35700
shlq $0x4, %rax
addq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x16ee0
leaq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x16ee0
movq -0x50(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl -0xc(%rbp), %esi
leaq -0x70(%rbp), %rdi
callq 0x16f80
movl %eax, %ecx
movq -0xc0(%rbp), %rax
movslq %ecx, %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
je 0x17977
movl -0xc(%rbp), %esi
leaq -0x70(%rbp), %rdi
callq 0x16f80
movl %eax, -0x74(%rbp)
movq -0x50(%rbp), %rsi
movl -0x74(%rbp), %edx
leaq -0x94(%rbp), %rdi
callq 0x20b80
leaq -0xa4(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x17000
leaq -0x84(%rbp), %rdi
leaq -0x94(%rbp), %rsi
leaq -0xa4(%rbp), %rdx
callq 0x17000
movq -0x84(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x7c(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rdi
movl -0x74(%rbp), %esi
callq 0x20b60
movq %rax, -0x50(%rbp)
jmp 0x178d4
movq -0xb8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x70(%rbp), %rcx
callq 0x17390
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3550
// File: MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: annulus::annulus(annulus const&)
annulus::annulus(const annulus &a)
{
	length = a.length;
	
	sq = new cube*[length];
	upright = new bool[length];
	
	for (int i = 0; i < length; i++)
	{
		sq[i] = a.sq[i];
		upright[i] = a.upright[i];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq (%rax), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x1995c
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19909
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: rectangle::rectangle(rectangle const&)
rectangle::rectangle(const rectangle &r)
{
	length = r.length;
	
	sq = new cube*[length];
	upright = new bool[length];
	
	for (int i = 0; i < length; i++)
	{
		sq[i] = r.sq[i];
		upright[i] = r.upright[i];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq (%rax), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0x1bfbc
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1bf69
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jge 0x1c984
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x20b60
cmpq $0x0, %rax
je 0x1c85b
jmp 0x1c976
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x177f0
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x20b60
movq %rax, %rdi
callq 0x211e0
cmpl -0x14(%rbp), %eax
je 0x1c891
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x17520
jmp 0x1c974
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x20b60
movq %rax, %rdi
callq 0x21200
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x20b60
movq %rax, %rdi
callq 0x21200
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jne 0x1c966
movl $0xc0, %edi
callq 0x3300
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rsi
movq %rsp, %rax
movq $0x0, (%rax)
movl $0x7, %edx
movl $0x3, %ecx
movl $0x2, %r8d
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0x17070
jmp 0x1c90a
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x18(%rbp), %edx
movslq -0x18(%rbp), %rax
leaq 0x18e08(%rip), %rcx     # 0x35730
shlq $0x4, %rax
addq %rax, %rcx
callq 0x17650
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x177f0
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1c984
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0xc0, %esi
callq 0x3310
jmp 0x1c98e
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x17520
jmp 0x1c974
jmp 0x1c976
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c83a
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3550
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x1cb17
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x20b60
cmpq $0x0, %rax
je 0x1c9db
jmp 0x1cb09
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x177f0
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x20b60
movq %rax, %rdi
callq 0x21200
cmpl $0x8, %eax
jne 0x1ca15
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x20b60
movq %rax, -0x8(%rbp)
jmp 0x1cb1f
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x20b60
movq %rax, %rdi
callq 0x211e0
cmpl -0x1c(%rbp), %eax
je 0x1ca3f
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x17520
jmp 0x1cb05
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x20b60
movq %rax, %rdi
callq 0x21200
cmpl $0x6, %eax
je 0x1caf7
movl $0xc0, %edi
callq 0x3300
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq %rsp, %rax
movq $0x0, (%rax)
movl $0x7, %edx
movl $0x3, %ecx
movl $0x2, %r8d
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0x17070
jmp 0x1ca9b
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %edx
movslq -0x20(%rbp), %rax
leaq 0x18c77(%rip), %rcx     # 0x35730
shlq $0x4, %rax
addq %rax, %rcx
callq 0x17650
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x177f0
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x1cb17
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0xc0, %esi
callq 0x3310
jmp 0x1cb29
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x17520
jmp 0x1cb05
jmp 0x1cb07
jmp 0x1cb09
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1c9ba
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3550
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x18, %rdi
movq %rdi, -0x78(%rbp)
callq 0x3430
movq -0x68(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x70(%rbp)
callq 0x9080
movq -0x68(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x60(%rbp)
callq 0x21220
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3560
movq -0x58(%rbp), %rdx
leaq 0xa2f9(%rip), %rsi      # 0x27802
leaq -0x38(%rbp), %rdi
callq 0x4e10
jmp 0x1d514
leaq -0x38(%rbp), %rdi
movl $0x2, %esi
callq 0x4c10
jmp 0x1d524
leaq -0x38(%rbp), %rdi
callq 0x35f8
leaq -0x39(%rbp), %rdi
callq 0x3360
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rsi
addq $0x18, %rdi
callq 0x3050
jmp 0x1d549
movq -0x68(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl $0x0, 0x38(%rax)
movl $0x0, 0x3c(%rax)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1d59c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35f8
leaq -0x39(%rbp), %rdi
callq 0x3360
jmp 0x1d5b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movq -0x60(%rbp), %rdi
callq 0x21240
movq -0x70(%rbp), %rdi
callq 0x9540
movq -0x78(%rbp), %rdi
callq 0x35f8
movq -0x48(%rbp), %rdi
callq 0x3550
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3560
movq -0x38(%rbp), %rdx
leaq 0xa000(%rip), %rsi      # 0x2760c
leaq -0x28(%rbp), %rdi
callq 0x4e10
jmp 0x1d617
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x4c10
jmp 0x1d627
leaq -0x28(%rbp), %rdi
callq 0x35f8
leaq -0x29(%rbp), %rdi
callq 0x3360
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1d653
movq -0x40(%rbp), %rdi
movq (%rdi), %rsi
callq 0x1d6f0
jmp 0x1d651
jmp 0x1d639
movl $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, -0x44(%rbp)
addq $0x40, %rdi
callq 0x9b10
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0x1d6b0
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
movslq -0x30(%rbp), %rsi
callq 0x8d20
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x1d6a3
movq -0x50(%rbp), %rdi
movl $0x40, %esi
callq 0x3310
jmp 0x1d6a5
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1d65a
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
callq 0x21240
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
callq 0x9540
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x35f8
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x5280
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x1d72c
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x17520
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1d70f
movq -0x10(%rbp), %rdi
callq 0x212e0
cmpq $0x0, %rax
je 0x1d75f
movq -0x10(%rbp), %rdi
callq 0x212e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21300
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x212a0
jmp 0x1d772
movq -0x10(%rbp), %rdi
callq 0x21300
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x21300
cmpq $0x0, %rax
je 0x1d7a5
movq -0x10(%rbp), %rdi
callq 0x21300
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x212e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x212c0
jmp 0x1d7b9
movq -0x10(%rbp), %rdi
callq 0x212e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1d7de
movq -0x38(%rbp), %rdi
callq 0x17330
movq -0x38(%rbp), %rdi
movl $0xc0, %esi
callq 0x3310
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0x1db7c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
addl -0x14(%rbp), %ecx
movl $0x6, %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
leaq -0x3c(%rbp), %rdi
callq 0x20b80
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x20b60
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x24(%rbp), %esi
leaq -0x3c(%rbp), %rdi
callq 0x16f80
movl %eax, -0x28(%rbp)
movl -0x40(%rbp), %esi
leaq -0x3c(%rbp), %rdi
callq 0x16f80
movl %eax, -0x24(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x41(%rbp)
jne 0x1dc1f
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x41(%rbp)
jne 0x1dc1f
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1dbaa
movl -0x2c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MarkCBell[P]twister/./twister/kernel/twister.cpp
// Function: dual_direction(tetra*)
int dual_direction(tetra *A)
{
	tetra *T = A->get_gluedto(3);
	int T_index = 3 * (T->get_side()) + T->get_position();
	int T_face = A->get_gluing(3)[3];
	
	int move = dual_moves[T_index][T_face];
	if (move == -1) output_error("Face gluing error.");
	
	return T->get_gluing(T_face)[move];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x20b60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21340
imull $0x3, %eax, %eax
movl %eax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21320
movl %eax, %ecx
movl -0x78(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movl $0x3, %edx
callq 0x20b80
leaq -0x28(%rbp), %rdi
movl $0x3, %esi
callq 0x16f80
movl %eax, -0x18(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x92cf(%rip), %rax      # 0x27940
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x1e6f8
leaq -0x51(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3560
movq -0x80(%rbp), %rdx
leaq 0x90be(%rip), %rsi      # 0x2775e
leaq -0x50(%rbp), %rdi
callq 0x4e10
jmp 0x1e6ab
leaq -0x50(%rbp), %rdi
callq 0x4d40
jmp 0x1e6b6
leaq -0x50(%rbp), %rdi
callq 0x35f8
leaq -0x51(%rbp), %rdi
callq 0x3360
jmp 0x1e6f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x1e6ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x35f8
leaq -0x51(%rbp), %rdi
callq 0x3360
jmp 0x1e71d
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
leaq -0x74(%rbp), %rdi
callq 0x20b80
movl -0x2c(%rbp), %esi
leaq -0x74(%rbp), %rdi
callq 0x16f80
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3550
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x14faf(%rip), %rax     # 0x3530a
testb $0x1, (%rax)
je 0x20369
movq -0x18(%rbp), %rdi
callq 0x1b770
movq -0x18(%rbp), %rdi
callq 0x1d7f0
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1dc40
leaq 0x14f80(%rip), %rax     # 0x3530a
testb $0x1, (%rax)
je 0x2039c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e730
leaq 0x14f66(%rip), %rax     # 0x35309
testb $0x1, (%rax)
je 0x203b9
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1fce0
movq %rax, -0x10(%rbp)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x1, -0x19(%rbp)
movl $0x1, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x20aa6
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x20a99
movq -0x70(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x16f80
movq -0x70(%rbp), %rdi
movl %eax, -0x74(%rbp)
movl -0x20(%rbp), %esi
callq 0x16f80
movl %eax, %ecx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jle 0x20a8c
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
xorl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x20a8e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x20a4a
jmp 0x20a9b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x20a3d
testb $0x1, -0x19(%rbp)
je 0x20b1c
leaq -0x49(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3560
movq -0x80(%rbp), %rdx
leaq 0x6e00(%rip), %rsi      # 0x278c4
leaq -0x48(%rbp), %rdi
callq 0x4e10
jmp 0x20acf
leaq -0x48(%rbp), %rdi
callq 0x4d40
jmp 0x20ada
leaq -0x48(%rbp), %rdi
callq 0x35f8
leaq -0x49(%rbp), %rdi
callq 0x3360
jmp 0x20b1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x20b11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x35f8
leaq -0x49(%rbp), %rdi
callq 0x3360
jmp 0x20b4a
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %rax
addq $0x30, %rax
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3550
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0x20f37
movq -0x20(%rbp), %rax
leaq 0x6589(%rip), %rcx      # 0x27464
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x20f3f
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x20f3f
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x20f3f
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x20f3f
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x20f3f
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x20f3f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0xd0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x2cc0
movq -0x10(%rbp), %rdi
callq 0x2ce0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2d50
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2d10
testb $0x1, %al
jne 0x24d1
jmp 0x25f9
leaq -0x28(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x2e00
movq %rax, %rdi
callq 0x2e20
movq -0xc8(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x2e00
movq %rax, %rdi
callq 0x2e50
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq 0x968(%rip), %rcx       # 0x2e80
callq 0x2d80
movq %rdx, -0xc0(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x252d
movq -0xc0(%rbp), %rax
movq -0xb8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x40(%rbp), %rsi
addq $0x8, %rsi
callq 0x2f00
testb $0x1, %al
jne 0x255d
jmp 0x25e9
movq -0x10(%rbp), %rdi
callq 0x2ce0
movq %rax, -0xa0(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2fb0
movq %rax, -0x98(%rbp)
leaq -0x38(%rbp), %rcx
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x2f70
jmp 0x25a1
leaq -0x78(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x3000
movq -0xb0(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x2f40
jmp 0x25cd
jmp 0x25e9
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x3050
jmp 0x261f
jmp 0x25eb
leaq -0x28(%rbp), %rdi
callq 0x3030
jmp 0x24ae
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x260f
movq -0xb0(%rbp), %rdi
callq 0x3050
movq -0xa8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2230
nopl (%rax,%rax)
// File: 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
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x278(%rbp)
movq %rdi, %rax
movq %rax, -0x280(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x30b0
movq -0x278(%rbp), %rdi
movb $0x0, -0x41(%rbp)
callq 0x30f0
movq -0x10(%rbp), %rsi
leaq -0x250(%rbp), %rdi
movl $0x8, %edx
callq 0x2210
jmp 0x2684
jmp 0x2686
leaq -0x250(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7e10
movq %rax, -0x288(%rbp)
jmp 0x269f
movq -0x288(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x21a0
movb %al, -0x289(%rbp)
jmp 0x26bd
movb -0x289(%rbp), %al
testb $0x1, %al
jne 0x26c9
jmp 0x2714
movq -0x278(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3110
jmp 0x26db
jmp 0x2686
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
jmp 0x2791
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x2060
jmp 0x2791
movq -0x278(%rbp), %rdi
callq 0x31d0
movq -0x278(%rbp), %rdi
movq %rax, -0x268(%rbp)
callq 0x3200
movq %rax, -0x270(%rbp)
movq -0x268(%rbp), %rdi
movq -0x270(%rbp), %rsi
leaq -0x35f(%rip), %rdx      # 0x23f0
callq 0x3180
jmp 0x2756
movb $0x1, -0x41(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x2060
testb $0x1, -0x41(%rbp)
jne 0x2778
movq -0x278(%rbp), %rdi
callq 0x3230
leaq -0x40(%rbp), %rdi
callq 0x3290
movq -0x280(%rbp), %rax
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x278(%rbp), %rdi
callq 0x3230
leaq -0x40(%rbp), %rdi
callq 0x3290
movq -0x258(%rbp), %rdi
callq 0x2230
nopw %cs:(%rax,%rax)
// File: 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
subq $0x2a0, %rsp            # imm = 0x2A0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x2ac1
jmp 0x2ae0
leaq 0x5565(%rip), %rdi      # 0x802d
leaq 0x5567(%rip), %rsi      # 0x8036
movl $0x7f, %edx
leaq 0x5567(%rip), %rcx      # 0x8042
callq 0x20f0
leaq -0x28(%rbp), %rdi
callq 0x3500
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
je 0x2bc4
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x298(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x290(%rbp)
callq 0x2240
movq -0x298(%rbp), %rsi
movq -0x290(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x21d0
jmp 0x2b38
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2630
jmp 0x2b47
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3520
jmp 0x2b56
leaq -0x48(%rbp), %rdi
callq 0x3230
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq -0x69(%rbp), %rdi
callq 0x2180
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2af0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x2bb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x2bb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3230
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq -0x69(%rbp), %rdi
callq 0x2180
jmp 0x2c3e
leaq 0x548e(%rip), %rsi      # 0x8059
leaq -0x288(%rbp), %rdi
movl $0x8, %edx
callq 0x2250
jmp 0x2bde
movq 0xa3f3(%rip), %rsi      # 0xcfd8
leaq -0x288(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x27c0
jmp 0x2bf7
leaq -0x288(%rbp), %rdi
callq 0x2060
leaq -0x28(%rbp), %rdi
callq 0x3550
movl -0x4(%rbp), %eax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x2c3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x288(%rbp), %rdi
callq 0x2060
leaq -0x28(%rbp), %rdi
callq 0x3550
movq -0x78(%rbp), %rdi
callq 0x2230
// File: 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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
xorl %edi, %edi
callq 0x1030
movq 0x2e13(%rip), %rax      # 0x3fe0
movq (%rax), %rax
movq 0x2e09(%rip), %rdi      # 0x3fe0
addq -0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1040
movq 0x2de5(%rip), %rax      # 0x3fd0
movq (%rax), %rax
movq 0x2ddb(%rip), %rdi      # 0x3fd0
addq -0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: ctSkennerton[P]fxtract/util/sort_x.c
// Function: simpl3
static void
simpl3(MEMREF *v)
{
    MEMREF  a = v[0], b = v[1], c = v[2];
    if (refcmp(a, b) <= 0)
        if (refcmp(b, c) <= 0)
            ;
        else 
        if (refcmp(a, c) <= 0)
            v[1] = c, v[2] = b;
        else
            v[0] = c, v[1] = a, v[2] = b;
    else
    if (refcmp(a, c) <= 0)
        v[1] = c, v[2] = b;
    else
    if (refcmp(b, c) <= 0)
        v[0] = b, v[1] = c, v[2] = a;
    else
        v[0] = c, v[1] = b, v[2] = a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x54a0
cmpl $0x0, %eax
jg 0x39aa
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x54a0
cmpl $0x0, %eax
jg 0x3924
jmp 0x39a5
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x54a0
cmpl $0x0, %eax
jg 0x3968
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
jmp 0x39a3
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
jmp 0x39a5
jmp 0x3a87
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x54a0
cmpl $0x0, %eax
jg 0x39f1
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
jmp 0x3a85
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x54a0
cmpl $0x0, %eax
jg 0x3a48
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x28(%rax)
jmp 0x3a83
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x28(%rax)
jmp 0x3a85
jmp 0x3a87
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/sort_x.c
// Function: simple
static void
simple(MEMREF *v, int n)
{
    MEMREF      *rp = v + 1, *omega = v + n;
    do {
        MEMREF   *qp = rp, r = *rp;
        while (refcmp(*--qp, r) > 0 && qp > v) qp[1] = qp[0];
        qp[1] = r;
    } while (++rp != omega);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $-0x10, %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rax), %rdi
movq -0x8(%rax), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x54a0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
jle 0x3b17
movq -0x28(%rbp), %rax
cmpq -0x8(%rbp), %rax
seta %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3b20
jmp 0x3b39
movq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x3ad9
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x3abe
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/sort_x.c
// Function: owsort
static void
owsort(MEMREF *v, int n)
{
    //float   fstep = n;
    int     step = n, i;
    while ((step = step * 25 >> 5))
        for (i = n - step; --i >= 0;)
            if (refpcmp(&v[i], &v[i + step]) > 0)
                SWAP(v[i], v[i + step]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
imull $0x19, -0x10(%rbp), %eax
sarl $0x5, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
je 0x3c8f
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0x3c8a
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
addl -0x10(%rbp), %eax
cltq
shlq $0x4, %rax
addq %rax, %rsi
callq 0x55f0
cmpl $0x0, %eax
jle 0x3c85
jmp 0x3c11
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
addl -0x10(%rbp), %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x3c85
jmp 0x3bd1
jmp 0x3bb5
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x12cb
movq -0x10(%rbp), %rdi
leaq 0x2a13(%rip), %rsi      # 0x3cc8
leaq 0x2a3c(%rip), %rdx      # 0x3cf8
xorl %eax, %eax
movl %eax, %ecx
callq 0x10a0
movq %rax, -0x18(%rbp)
jmp 0x12d3
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x12d3
movq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0x12ff
movq 0x2cf4(%rip), %rdi      # 0x3fd8
leaq 0xd22(%rip), %rsi       # 0x200d
callq 0x1060
movq %rax, %rdi
movq 0x2cbe(%rip), %rsi      # 0x3fb8
callq 0x1090
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x132e
movq -0x20(%rbp), %rdi
leaq 0x29b0(%rip), %rsi      # 0x3cc8
leaq 0x29f1(%rip), %rdx      # 0x3d10
xorl %eax, %eax
movl %eax, %ecx
callq 0x10a0
movq %rax, -0x28(%rbp)
jmp 0x1336
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x1336
movq -0x28(%rbp), %rax
cmpq $0x0, %rax
je 0x1362
movq 0x2c91(%rip), %rdi      # 0x3fd8
leaq 0xcc1(%rip), %rsi       # 0x200f
callq 0x1060
movq %rax, %rdi
movq 0x2c5b(%rip), %rsi      # 0x3fb8
callq 0x1090
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1391
movq -0x30(%rbp), %rdi
leaq 0x294d(%rip), %rsi      # 0x3cc8
leaq 0x29a6(%rip), %rdx      # 0x3d28
xorl %eax, %eax
movl %eax, %ecx
callq 0x10a0
movq %rax, -0x38(%rbp)
jmp 0x1399
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x1399
movq -0x38(%rbp), %rax
cmpq $0x0, %rax
je 0x13c5
movq 0x2c2e(%rip), %rdi      # 0x3fd8
leaq 0xc60(%rip), %rsi       # 0x2011
callq 0x1060
movq %rax, %rdi
movq 0x2bf8(%rip), %rsi      # 0x3fb8
callq 0x1090
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl $0x8, %edi
callq 0x1070
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1040
movq -0x40(%rbp), %rdi
callq 0x1820
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x8, %edi
callq 0x1070
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1040
movq -0x38(%rbp), %rdi
callq 0x1860
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x8, %edi
callq 0x1070
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1040
movq -0x30(%rbp), %rdi
callq 0x18a0
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1290
movq -0x18(%rbp), %rdi
callq 0x1290
movq -0x20(%rbp), %rdi
callq 0x1290
movq 0x28bd(%rip), %rdi      # 0x3fd8
movq 0x2896(%rip), %rsi      # 0x3fb8
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x13d0
movq -0x18(%rbp), %rdi
callq 0x13d0
movq -0x20(%rbp), %rdi
callq 0x13d0
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x175a
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x1772
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x178a
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
movb %r8b, %al
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
andb $0x1, %al
movb %al, -0x15(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
movl -0x14(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movb -0x15(%rsp), %cl
movq -0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x14(%rax)
retq
nop