LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::listarAnimaisPorFunca()
void Petfera::listarAnimaisPorFunca()
{
	int id;
	listarTodosFuncaionarios();
	cout << "Por favor escolha o id do funcionario que voce quer listar os animais atribuidos a ele"
			 << "\n";
	cin >> id;
	for (auto &&animal : this->animalStore)
	{
		if (animal->getVeterinario()->getId() == id)
		{
			cout << *(animal) << "\n";
		}
		if (animal->getTratador()->getId() == id)
		{
			cout << *(animal) << "\n";
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x10a90
movq 0x4b875(%rip), %rdi     # 0x5bfc8
leaq 0x36707(%rip), %rsi     # 0x46e61
callq 0x41c0
movq %rax, %rdi
leaq 0x36238(%rip), %rsi     # 0x469a1
callq 0x41c0
movq 0x4b86b(%rip), %rdi     # 0x5bfe0
leaq -0xc(%rbp), %rsi
callq 0x4130
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20a00
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20a30
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20a60
testb $0x1, %al
jne 0x107b6
jmp 0x108f2
leaq -0x20(%rbp), %rdi
callq 0x20aa0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20ac0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x7420
movq -0x78(%rbp), %rdi
callq 0x7950
movq %rax, %rdi
callq 0xaab0
movl %eax, -0x6c(%rbp)
jmp 0x107f2
movl -0xc(%rbp), %eax
movl %eax, -0x7c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5010
movl -0x7c(%rbp), %ecx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jne 0x1084e
movq -0x30(%rbp), %rdi
callq 0x20ae0
movq %rax, %rsi
movq 0x4b7aa(%rip), %rdi     # 0x5bfc8
callq 0x7700
movq %rax, %rdi
leaq 0x36174(%rip), %rsi     # 0x469a1
callq 0x41c0
jmp 0x1084e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5010
jmp 0x108fb
movq -0x30(%rbp), %rdi
callq 0x20ac0
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x7450
movq -0x88(%rbp), %rdi
callq 0x7950
movq %rax, %rdi
callq 0xaab0
movl %eax, -0x80(%rbp)
jmp 0x10883
movl -0xc(%rbp), %eax
movl %eax, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5010
movl -0x8c(%rbp), %ecx
movl -0x80(%rbp), %eax
cmpl %ecx, %eax
jne 0x108e2
movq -0x30(%rbp), %rdi
callq 0x20ae0
movq %rax, %rsi
movq 0x4b713(%rip), %rdi     # 0x5bfc8
callq 0x7700
movq %rax, %rdi
leaq 0x360dd(%rip), %rsi     # 0x469a1
callq 0x41c0
jmp 0x108e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5010
jmp 0x108fb
jmp 0x108e4
leaq -0x20(%rbp), %rdi
callq 0x20b10
jmp 0x107a0
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4320
nopw %cs:(%rax,%rax)
// File: viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::listarAnimaisPorClasse()
void Petfera::listarAnimaisPorClasse()
{
	int escolha;

	if (animalStore.size() == 0)
	{
		cout << "Sem animais cadastrados"
				 << "\n";
	};

	cout << "# Escolha uma das classes"
			 << "\n"
			 << "0 --> Mamiferos"
			 << "\n"
			 << "1 --> Aves"
			 << "\n"
			 << "2 --> Anfibios"
			 << "\n"
			 << "3 --> Repteis"
			 << "\n";

	cin >> escolha;

	for (auto &animal : animalStore)
	{
		if (animal->getFamilia() == escolha)
		{
			cout << *(animal) << "\n";
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x209e0
cmpq $0x0, %rax
jne 0x10951
movq 0x4b692(%rip), %rdi     # 0x5bfc8
leaq 0x364ba(%rip), %rsi     # 0x46df7
callq 0x41c0
movq %rax, %rdi
leaq 0x36055(%rip), %rsi     # 0x469a1
callq 0x41c0
movq 0x4b670(%rip), %rdi     # 0x5bfc8
leaq 0x364b0(%rip), %rsi     # 0x46e0f
callq 0x41c0
movq %rax, %rdi
leaq 0x36033(%rip), %rsi     # 0x469a1
callq 0x41c0
movq %rax, %rdi
leaq 0x364ac(%rip), %rsi     # 0x46e29
callq 0x41c0
movq %rax, %rdi
leaq 0x36015(%rip), %rsi     # 0x469a1
callq 0x41c0
movq %rax, %rdi
leaq 0x3649e(%rip), %rsi     # 0x46e39
callq 0x41c0
movq %rax, %rdi
leaq 0x35ff7(%rip), %rsi     # 0x469a1
callq 0x41c0
movq %rax, %rdi
leaq 0x3648b(%rip), %rsi     # 0x46e44
callq 0x41c0
movq %rax, %rdi
leaq 0x35fd9(%rip), %rsi     # 0x469a1
callq 0x41c0
movq %rax, %rdi
leaq 0x3647c(%rip), %rsi     # 0x46e53
callq 0x41c0
movq %rax, %rdi
leaq 0x35fbb(%rip), %rsi     # 0x469a1
callq 0x41c0
movq 0x4b5ee(%rip), %rdi     # 0x5bfe0
leaq -0xc(%rbp), %rsi
callq 0x4130
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20a00
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20a30
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20a60
testb $0x1, %al
jne 0x10a30
jmp 0x10a87
leaq -0x20(%rbp), %rdi
callq 0x20aa0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20ac0
movq %rax, %rdi
callq 0x7590
cmpl -0xc(%rbp), %eax
jne 0x10a7a
movq -0x30(%rbp), %rdi
callq 0x20ae0
movq %rax, %rsi
movq 0x4b562(%rip), %rdi     # 0x5bfc8
callq 0x7700
movq %rax, %rdi
leaq 0x35f2c(%rip), %rsi     # 0x469a1
callq 0x41c0
jmp 0x10a7c
leaq -0x20(%rbp), %rdi
callq 0x20b10
jmp 0x10a1d
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::listarTodosFuncaionarios()
void Petfera::listarTodosFuncaionarios()
{

	ofstream arqCache_funcio("cache_funcio.dat");
	cout << "Aqui estao todo os Funcionários do Petfera"
			 << "\n\n";

	if (funcionarioStore.size() == 0)
	{
		cout << "Não temos nenhum funcionario em nosso Banco de dados, por favor, cadastre um funcionario"
				 << "\n"
				 << "retornando"
				 << "\n";

		inicio();
	}
	for (auto &novo : this->funcionarioStore)
	{
		cout << (*novo) << endl;
		arqCache_funcio << (*novo) << endl;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x248(%rbp)
leaq 0x36407(%rip), %rsi     # 0x46eb8
leaq -0x208(%rbp), %rdi
movl $0x10, %edx
callq 0x4210
movq 0x4b4ff(%rip), %rdi     # 0x5bfc8
leaq 0x363f9(%rip), %rsi     # 0x46ec9
callq 0x41c0
movq %rax, -0x240(%rbp)
jmp 0x10ade
movq -0x240(%rbp), %rdi
leaq 0x35eb4(%rip), %rsi     # 0x469a0
callq 0x41c0
jmp 0x10af3
movq -0x248(%rbp), %rdi
addq $0x20, %rdi
callq 0x20b30
cmpq $0x0, %rax
jne 0x10ba9
movq 0x4b4b4(%rip), %rdi     # 0x5bfc8
leaq 0x363da(%rip), %rsi     # 0x46ef5
callq 0x41c0
movq %rax, -0x250(%rbp)
jmp 0x10b29
movq -0x250(%rbp), %rdi
leaq 0x35e6a(%rip), %rsi     # 0x469a1
callq 0x41c0
movq %rax, -0x258(%rbp)
jmp 0x10b45
movq -0x258(%rbp), %rdi
leaq 0x363fc(%rip), %rsi     # 0x46f4f
callq 0x41c0
movq %rax, -0x260(%rbp)
jmp 0x10b61
movq -0x260(%rbp), %rdi
leaq 0x35e32(%rip), %rsi     # 0x469a1
callq 0x41c0
jmp 0x10b76
movq -0x248(%rbp), %rdi
callq 0xf540
jmp 0x10b84
jmp 0x10ba9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x42c0
jmp 0x10caa
movq -0x248(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x220(%rbp)
movq -0x220(%rbp), %rdi
callq 0x20840
movq %rax, -0x228(%rbp)
movq -0x220(%rbp), %rdi
callq 0x20870
movq %rax, -0x230(%rbp)
leaq -0x228(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x208a0
testb $0x1, %al
jne 0x10bfd
jmp 0x10c95
leaq -0x228(%rbp), %rdi
callq 0x208e0
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rdi
callq 0x20900
movq %rax, %rsi
movq 0x4b3a2(%rip), %rdi     # 0x5bfc8
callq 0xac90
movq %rax, -0x268(%rbp)
jmp 0x10c34
movq -0x268(%rbp), %rdi
movq 0x4b36e(%rip), %rsi     # 0x5bfb0
callq 0x41f0
jmp 0x10c49
movq -0x238(%rbp), %rdi
callq 0x20900
movq %rax, %rsi
leaq -0x208(%rbp), %rdi
callq 0xac90
movq %rax, -0x270(%rbp)
jmp 0x10c6d
movq -0x270(%rbp), %rdi
movq 0x4b335(%rip), %rsi     # 0x5bfb0
callq 0x41f0
jmp 0x10c82
jmp 0x10c84
leaq -0x228(%rbp), %rdi
callq 0x20930
jmp 0x10be1
leaq -0x208(%rbp), %rdi
callq 0x42c0
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x4320
nopw %cs:(%rax,%rax)
// File: viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::atualizar_dados_funcionario()
bool Petfera::atualizar_dados_funcionario()
{
	int id_funcionario;

	listarTodosFuncaionarios();

	cout << "ID do funcionario a ser atualizado: ";
	cin >> id_funcionario;

	for (auto &funcionario : this->funcionarioStore)
	{
		if (id_funcionario == funcionario->getId())
		{
			atualizar_funcionario(funcionario);
			break;
		}
		else
		{
			cout << "ID nao encontrado, retornando...";
		}
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x10a90
movq 0x4a688(%rip), %rdi     # 0x5bfc8
leaq 0x36303(%rip), %rsi     # 0x47c4a
callq 0x41c0
movq 0x4a68d(%rip), %rdi     # 0x5bfe0
leaq -0xc(%rbp), %rsi
callq 0x4130
movq -0x58(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20840
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20870
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x208a0
testb $0x1, %al
jne 0x11998
jmp 0x11a2a
leaq -0x20(%rbp), %rdi
callq 0x208e0
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x7950
movq %rax, %rdi
callq 0xaab0
movl %eax, %ecx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jne 0x11a07
movq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4fe0
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x1e370
jmp 0x119e5
leaq -0x40(%rbp), %rdi
callq 0x5010
jmp 0x11a2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5010
jmp 0x11a34
movq 0x4a5ba(%rip), %rdi     # 0x5bfc8
leaq 0x36214(%rip), %rsi     # 0x47c29
callq 0x41c0
jmp 0x11a1c
leaq -0x20(%rbp), %rdi
callq 0x20930
jmp 0x11982
movb $0x1, %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4320
nopl (%rax)
// File: viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::listarTodosAnimais()
void Petfera::listarTodosAnimais()
{

	ofstream arqCache_animais("cache_animais.dat");

	cout << "Aqui estao todo os animais na Petfera"
			 << "\n\n";

	if (animalStore.size() == 0)
	{
		cout << "Não temos nenhum animal em nosso Banco de dados, por favor, cadastre um animal"
				 << "\n"
				 << "retornando"
				 << "\n";

		inicio();
	}
	for (auto &novo : this->animalStore)
	{
		cout << (*novo) << endl;
		arqCache_animais << (*novo) << endl;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x248(%rbp)
leaq 0x354f9(%rip), %rsi     # 0x46f5a
leaq -0x208(%rbp), %rdi
movl $0x10, %edx
callq 0x4210
movq 0x4a54f(%rip), %rdi     # 0x5bfc8
leaq 0x354ec(%rip), %rsi     # 0x46f6c
callq 0x41c0
movq %rax, -0x240(%rbp)
jmp 0x11a8e
movq -0x240(%rbp), %rdi
leaq 0x34f04(%rip), %rsi     # 0x469a0
callq 0x41c0
jmp 0x11aa3
movq -0x248(%rbp), %rdi
callq 0x209e0
cmpq $0x0, %rax
jne 0x11b55
movq 0x4a508(%rip), %rdi     # 0x5bfc8
leaq 0x354cb(%rip), %rsi     # 0x46f92
callq 0x41c0
movq %rax, -0x250(%rbp)
jmp 0x11ad5
movq -0x250(%rbp), %rdi
leaq 0x34ebe(%rip), %rsi     # 0x469a1
callq 0x41c0
movq %rax, -0x258(%rbp)
jmp 0x11af1
movq -0x258(%rbp), %rdi
leaq 0x35450(%rip), %rsi     # 0x46f4f
callq 0x41c0
movq %rax, -0x260(%rbp)
jmp 0x11b0d
movq -0x260(%rbp), %rdi
leaq 0x34e86(%rip), %rsi     # 0x469a1
callq 0x41c0
jmp 0x11b22
movq -0x248(%rbp), %rdi
callq 0xf540
jmp 0x11b30
jmp 0x11b55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x42c0
jmp 0x11c52
movq -0x248(%rbp), %rax
movq %rax, -0x220(%rbp)
movq -0x220(%rbp), %rdi
callq 0x20a00
movq %rax, -0x228(%rbp)
movq -0x220(%rbp), %rdi
callq 0x20a30
movq %rax, -0x230(%rbp)
leaq -0x228(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x20a60
testb $0x1, %al
jne 0x11ba5
jmp 0x11c3d
leaq -0x228(%rbp), %rdi
callq 0x20aa0
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rdi
callq 0x20ae0
movq %rax, %rsi
movq 0x4a3fa(%rip), %rdi     # 0x5bfc8
callq 0x7700
movq %rax, -0x268(%rbp)
jmp 0x11bdc
movq -0x268(%rbp), %rdi
movq 0x4a3c6(%rip), %rsi     # 0x5bfb0
callq 0x41f0
jmp 0x11bf1
movq -0x238(%rbp), %rdi
callq 0x20ae0
movq %rax, %rsi
leaq -0x208(%rbp), %rdi
callq 0x7700
movq %rax, -0x270(%rbp)
jmp 0x11c15
movq -0x270(%rbp), %rdi
movq 0x4a38d(%rip), %rsi     # 0x5bfb0
callq 0x41f0
jmp 0x11c2a
jmp 0x11c2c
leaq -0x228(%rbp), %rdi
callq 0x20b10
jmp 0x11b89
leaq -0x208(%rbp), %rdi
callq 0x42c0
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x4320
nop
// File: viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::leString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Petfera::leString(string str_prompt)
{
	string var;
	cout << str_prompt;
	cin >> var;
	// getline(cin, var);
	return var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x4280
movq -0x38(%rbp), %rsi
movq 0x47c81(%rip), %rdi     # 0x5bfc8
callq 0x41b0
jmp 0x1434e
movq -0x48(%rbp), %rsi
movq 0x47c87(%rip), %rdi     # 0x5bfe0
callq 0x4240
jmp 0x14360
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1438c
jmp 0x14383
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4140
jmp 0x14396
movq -0x48(%rbp), %rdi
callq 0x4140
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4320
nop
// File: viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::leGenero(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
t_genero Petfera::leGenero(string str_prompt)
{
	string genero_string;
	t_genero genero;

	do
	{
		cout << str_prompt;
		cin >> genero_string;

		if (genero_string == "F" || genero_string == "f" || genero_string == "Femea")
		{
			genero = F;
			genero_string = "F";
			break;
		}
		else if (genero_string == "M" || genero_string == "m" || genero_string == "Macho")
		{
			genero = M;
			genero_string = "M";
			break;
		}

	} while (true);

	return genero;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4280
movq -0x50(%rbp), %rsi
movq 0x47c00(%rip), %rdi     # 0x5bfc8
callq 0x41b0
jmp 0x143cf
movq 0x47c0a(%rip), %rdi     # 0x5bfe0
leaq -0x30(%rbp), %rsi
callq 0x4240
jmp 0x143e1
leaq 0x337fc(%rip), %rsi     # 0x47be4
leaq -0x30(%rbp), %rdi
callq 0x1ec40
movb %al, -0x51(%rbp)
jmp 0x143f6
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x1443b
jmp 0x143ff
leaq 0x33f66(%rip), %rsi     # 0x4836c
leaq -0x30(%rbp), %rdi
callq 0x1ec40
movb %al, -0x52(%rbp)
jmp 0x14414
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0x1443b
jmp 0x1441d
leaq 0x31cc8(%rip), %rsi     # 0x460ec
leaq -0x30(%rbp), %rdi
callq 0x1ec40
movb %al, -0x53(%rbp)
jmp 0x14432
movb -0x53(%rbp), %al
testb $0x1, %al
jne 0x1443b
jmp 0x14473
movl $0xb, -0x34(%rbp)
leaq 0x3379b(%rip), %rsi     # 0x47be4
leaq -0x30(%rbp), %rdi
callq 0x4260
jmp 0x14454
jmp 0x144f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4140
jmp 0x14510
leaq 0x3376c(%rip), %rsi     # 0x47be6
leaq -0x30(%rbp), %rdi
callq 0x1ec40
movb %al, -0x54(%rbp)
jmp 0x14488
movb -0x54(%rbp), %al
testb $0x1, %al
jne 0x144cd
jmp 0x14491
leaq 0x32829(%rip), %rsi     # 0x46cc1
leaq -0x30(%rbp), %rdi
callq 0x1ec40
movb %al, -0x55(%rbp)
jmp 0x144a6
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x144cd
jmp 0x144af
leaq 0x31c3c(%rip), %rsi     # 0x460f2
leaq -0x30(%rbp), %rdi
callq 0x1ec40
movb %al, -0x56(%rbp)
jmp 0x144c4
movb -0x56(%rbp), %al
testb $0x1, %al
jne 0x144cd
jmp 0x144e8
movl $0xa, -0x34(%rbp)
leaq 0x3370b(%rip), %rsi     # 0x47be6
leaq -0x30(%rbp), %rdi
callq 0x4260
jmp 0x144e6
jmp 0x144f8
jmp 0x144ea
jmp 0x144ec
movb $0x1, %al
testb $0x1, %al
jne 0x143bd
jmp 0x144f8
movl -0x34(%rbp), %eax
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4140
movl -0x5c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4320
nopl (%rax)
// File: viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::leBool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Petfera::leBool(string str_prompt)
{
	string resposta;
	do
	{
		cout << str_prompt;
		cin >> resposta;
	} while ((resposta != "S" && resposta != "s" && resposta != "sim") && (resposta != "N" && resposta != "n" && resposta != "nao"));
	if (resposta == "S" || resposta == "s" || resposta == "sim")
	{
		return true;
	}
	else
	{
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4280
movq -0x50(%rbp), %rsi
movq 0x47a80(%rip), %rdi     # 0x5bfc8
callq 0x41b0
jmp 0x1454f
movq 0x47a8a(%rip), %rdi     # 0x5bfe0
leaq -0x38(%rbp), %rsi
callq 0x4240
jmp 0x14561
jmp 0x14563
leaq 0x3367e(%rip), %rsi     # 0x47be8
leaq -0x38(%rbp), %rdi
callq 0x221b0
movb %al, -0x51(%rbp)
jmp 0x14578
movb -0x51(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x52(%rbp)
jne 0x1458a
jmp 0x14640
leaq 0x33ca7(%rip), %rsi     # 0x48238
leaq -0x38(%rbp), %rdi
callq 0x221b0
movb %al, -0x53(%rbp)
jmp 0x1459f
movb -0x53(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x52(%rbp)
jne 0x145b1
jmp 0x14640
leaq 0x31b8e(%rip), %rsi     # 0x46146
leaq -0x38(%rbp), %rdi
callq 0x221b0
movb %al, -0x54(%rbp)
jmp 0x145c6
movb -0x54(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x52(%rbp)
jne 0x145d5
jmp 0x14640
leaq 0x3360e(%rip), %rsi     # 0x47bea
leaq -0x38(%rbp), %rdi
callq 0x221b0
movb %al, -0x55(%rbp)
jmp 0x145ea
movb -0x55(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x56(%rbp)
jne 0x145f9
jmp 0x1463a
leaq 0x335ec(%rip), %rsi     # 0x47bec
leaq -0x38(%rbp), %rdi
callq 0x221b0
movb %al, -0x57(%rbp)
jmp 0x1460e
movb -0x57(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x56(%rbp)
jne 0x1461d
jmp 0x1463a
leaq 0x31b26(%rip), %rsi     # 0x4614a
leaq -0x38(%rbp), %rdi
callq 0x221b0
movb %al, -0x58(%rbp)
jmp 0x14632
movb -0x58(%rbp), %al
movb %al, -0x56(%rbp)
jmp 0x1463a
movb -0x56(%rbp), %al
movb %al, -0x52(%rbp)
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0x1453d
leaq 0x33596(%rip), %rsi     # 0x47be8
leaq -0x38(%rbp), %rdi
callq 0x1ec40
movb %al, -0x59(%rbp)
jmp 0x14660
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x146a5
jmp 0x14669
leaq 0x33bc8(%rip), %rsi     # 0x48238
leaq -0x38(%rbp), %rdi
callq 0x1ec40
movb %al, -0x5a(%rbp)
jmp 0x1467e
movb -0x5a(%rbp), %al
testb $0x1, %al
jne 0x146a5
jmp 0x14687
leaq 0x31ab8(%rip), %rsi     # 0x46146
leaq -0x38(%rbp), %rdi
callq 0x1ec40
movb %al, -0x5b(%rbp)
jmp 0x1469c
movb -0x5b(%rbp), %al
testb $0x1, %al
jne 0x146a5
jmp 0x146c9
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x146d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4140
jmp 0x146e8
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4140
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4320
nopw %cs:(%rax,%rax)
// File: viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::leNivelDeSeguranca()
nivelDeSeguranca Petfera::leNivelDeSeguranca()
{
	nivelDeSeguranca nivel;
	short escolha;
	cout << "Escolha o nivel de segurança para seu tratador"
			 << "\n";

	cout << "5 --> Nivel verde"
			 << "\n";
	cout << "6 --> Nivel azul"
			 << "\n";
	cout << "7 --> Nivel vermelho"
			 << "\n";

	cin >> escolha;
	if (escolha == 5)
		nivel = Verde;
	if (escolha == 6)
		nivel = Azul;
	if (escolha == 7)
		nivel = Vermelho;

	return nivel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3ee25(%rip), %rdi     # 0x5bfc8
leaq 0x2a9bd(%rip), %rsi     # 0x47b67
callq 0x41c0
movq %rax, %rdi
leaq 0x297e8(%rip), %rsi     # 0x469a1
callq 0x41c0
movq 0x3ee03(%rip), %rdi     # 0x5bfc8
leaq 0x2a9cb(%rip), %rsi     # 0x47b97
callq 0x41c0
movq %rax, %rdi
leaq 0x297c6(%rip), %rsi     # 0x469a1
callq 0x41c0
movq 0x3ede1(%rip), %rdi     # 0x5bfc8
leaq 0x2a9bb(%rip), %rsi     # 0x47ba9
callq 0x41c0
movq %rax, %rdi
leaq 0x297a4(%rip), %rsi     # 0x469a1
callq 0x41c0
movq 0x3edbf(%rip), %rdi     # 0x5bfc8
leaq 0x2a9aa(%rip), %rsi     # 0x47bba
callq 0x41c0
movq %rax, %rdi
leaq 0x29782(%rip), %rsi     # 0x469a1
callq 0x41c0
movq 0x3edb5(%rip), %rdi     # 0x5bfe0
leaq -0xe(%rbp), %rsi
callq 0x4050
movswl -0xe(%rbp), %eax
cmpl $0x5, %eax
jne 0x1d244
movl $0x5, -0xc(%rbp)
movswl -0xe(%rbp), %eax
cmpl $0x6, %eax
jne 0x1d254
movl $0x6, -0xc(%rbp)
movswl -0xe(%rbp), %eax
cmpl $0x7, %eax
jne 0x1d264
movl $0x7, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: shancheng[P]shancheng/src/sudoku.cpp
// Function: (anonymous namespace)::Options::Print(std::ostream&)
void Print(ostream& os) {
    os << "Options: \n";
    os << "---------------------------------------------------------------\n";
    os << "File:       " << opt_file << "\n";
    os << "Size:       " << opt_size << "\n";
    os << "Block size: " << opt_blocksize << "\n";
    os << "\n";
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0xfe50(%rip), %rsi      # 0x17063
callq 0x62e0
movq 0x8(%rsp), %rdi
leaq 0xfe4a(%rip), %rsi      # 0x1706e
callq 0x62e0
movq 0x8(%rsp), %rdi
leaq 0xfe7a(%rip), %rsi      # 0x170af
callq 0x62e0
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x62c0
movq %rax, %rdi
leaq 0xfe1c(%rip), %rsi      # 0x1706c
callq 0x62e0
movq 0x8(%rsp), %rdi
leaq 0xfe5b(%rip), %rsi      # 0x170bc
callq 0x62e0
movq %rax, %rdi
movq (%rsp), %rax
movl 0x20(%rax), %esi
callq 0x6450
movq %rax, %rdi
leaq 0xfded(%rip), %rsi      # 0x1706c
callq 0x62e0
movq 0x8(%rsp), %rdi
leaq 0xfe39(%rip), %rsi      # 0x170c9
callq 0x62e0
movq %rax, %rdi
movq (%rsp), %rax
movl 0x24(%rax), %esi
callq 0x6450
movq %rax, %rdi
leaq 0xfdbe(%rip), %rsi      # 0x1706c
callq 0x62e0
movq 0x8(%rsp), %rdi
leaq 0xfdad(%rip), %rsi      # 0x1706c
callq 0x62e0
addq $0x18, %rsp
retq
nopl (%rax)
// File: shancheng[P]shancheng/src/sudoku.cpp
// Function: (anonymous namespace)::Sudoku::Sudoku()
Sudoku() {
    memset(&cells_, 0, sizeof(cells_));
    memset(&rowflags_, 0, sizeof(rowflags_));
    memset(&colflags_, 0, sizeof(colflags_));
    memset(&blockflags_, 0, sizeof(blockflags_));
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, %rcx
addq $0xafc8, %rcx           # imm = 0xAFC8
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x79d0
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
addq $0x48, %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x72f7
movq 0x8(%rsp), %rdi
addq $0xb0f8, %rdi           # imm = 0xB0F8
callq 0x7a10
movq 0x8(%rsp), %rdi
movb $0x0, 0xb110(%rdi)
xorl %esi, %esi
movl $0xafc8, %edx           # imm = 0xAFC8
callq 0x6170
movq 0x8(%rsp), %rdi
addq $0xafc8, %rdi           # imm = 0xAFC8
xorl %esi, %esi
movl $0x64, %edx
callq 0x6170
movq 0x8(%rsp), %rdi
addq $0xb02c, %rdi           # imm = 0xB02C
xorl %esi, %esi
movl $0x64, %edx
callq 0x6170
movq 0x8(%rsp), %rdi
addq $0xb090, %rdi           # imm = 0xB090
xorl %esi, %esi
movl $0x64, %edx
callq 0x6170
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: shancheng[P]shancheng/src/sudoku.cpp
// Function: (anonymous namespace)::Cell::SetFlag(unsigned int)
void SetFlag(uint32_t value) {
    uint32_t bitval = 0x01 << value; 
    *rowflag |= bitval;
    *colflag |= bitval;
    *blockflag |= bitval;
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, -0x10(%rsp)
movl -0x10(%rsp), %edx
movq 0x10(%rax), %rcx
orl (%rcx), %edx
movl %edx, (%rcx)
movl -0x10(%rsp), %edx
movq 0x18(%rax), %rcx
orl (%rcx), %edx
movl %edx, (%rcx)
movl -0x10(%rsp), %ecx
movq 0x20(%rax), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: shancheng[P]shancheng/src/sudoku.cpp
// Function: (anonymous namespace)::Sudoku::Print(std::ostream&)
void Print(ostream& os) {
    for (uint32_t row = 0; row < options.opt_size; ++row) {
      for (uint32_t col = 0; col < options.opt_size; ++col) {
        os << setw(2) << cells_[row][col].value << " ";
      }
      os << "\n";
    }
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x1986e(%rip), %eax     # 0x21398
jae 0x7bd0
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x19856(%rip), %eax     # 0x21398
jae 0x7baf
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x2, %edi
callq 0xae30
movq 0x8(%rsp), %rdi
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %esi
callq 0x6390
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x24(%rsp), %ecx
imulq $0x708, %rcx, %rcx      # imm = 0x708
addq %rcx, %rax
movl 0x20(%rsp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
callq 0x6450
movq %rax, %rdi
leaq 0xf51d(%rip), %rsi      # 0x170ba
callq 0x62e0
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x7b38
movq 0x28(%rsp), %rdi
leaq 0xf4b1(%rip), %rsi      # 0x1706c
callq 0x62e0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x7b20
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: shancheng[P]shancheng/src/sudoku.cpp
// Function: (anonymous namespace)::operator<<(std::ostream&, (anonymous namespace)::Cell const&)
ostream& operator<<(ostream& os, const Cell& cell) {
  os << '(' << (cell.row + 1) << ',' << (cell.col + 1) << ',' << cell.value << ',';
  for (auto it = cell.candidates.begin(); it != cell.candidates.end(); ++it) {
    os << *it << " ";
  }
  os << ')' << "\n";
  return os;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x28, %esi
callq 0x63b0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl (%rax), %esi
addl $0x1, %esi
callq 0x6450
movq %rax, %rdi
movl $0x2c, %esi
callq 0x63b0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl 0x4(%rax), %esi
addl $0x1, %esi
callq 0x6450
movq %rax, %rdi
movl $0x2c, %esi
callq 0x63b0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x6450
movq %rax, %rdi
movl $0x2c, %esi
callq 0x63b0
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
callq 0xb770
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
callq 0xb7e0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb7a0
testb $0x1, %al
jne 0x7cf4
jmp 0x7d2d
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
callq 0xb810
movq (%rsp), %rdi
movl (%rax), %esi
callq 0x6590
movq %rax, %rdi
leaq 0xf39e(%rip), %rsi      # 0x170ba
callq 0x62e0
leaq 0x10(%rsp), %rdi
callq 0xb820
jmp 0x7ccc
movq 0x20(%rsp), %rdi
movl $0x29, %esi
callq 0x63b0
movq %rax, %rdi
leaq 0xf326(%rip), %rsi      # 0x1706c
callq 0x62e0
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: shancheng[P]shancheng/src/sudoku.cpp
// Function: (anonymous namespace)::Sudoku::Solve(unsigned long)
bool Solve(size_t index) {
    if (found_) {
      return true;
    }
    if (index == vec_.size()) {
      cout << "\nSolution:\n";
      cout << "-----------------------------------------------------------\n";
      Print(cout);
      return true;
    }
    Cell& cell = *vec_[index];
    auto endit = cell.candidates.end();
    for (auto it = cell.candidates.begin(); it != endit; ++it) {
      if (IsOk(cell, *it)) {
        cell.value = *it;
        cell.SetFlag(*it);
        if (Solve(index + 1)) {
          return true;
        }
        cell.ClearFlag(*it);
      }
    }
    return false;
  }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
testb $0x1, 0xb110(%rax)
je 0x9bbb
movb $0x1, 0x57(%rsp)
jmp 0x9d33
movq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0xb0f8, %rdi           # imm = 0xB0F8
callq 0x8380
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x9c24
movq 0x173ce(%rip), %rdi     # 0x20fb8
leaq 0xd530(%rip), %rsi      # 0x17121
callq 0x62e0
movq 0x173bb(%rip), %rdi     # 0x20fb8
leaq 0xd46e(%rip), %rsi      # 0x17072
callq 0x62e0
movq 0x20(%rsp), %rdi
movq 0x173a3(%rip), %rsi     # 0x20fb8
callq 0x7b00
movb $0x1, 0x57(%rsp)
jmp 0x9d33
movq 0x20(%rsp), %rdi
addq $0xb0f8, %rdi           # imm = 0xB0F8
movq 0x40(%rsp), %rsi
callq 0x9d40
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
addq $0x28, %rdi
callq 0xb0c0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
addq $0x28, %rdi
callq 0xb280
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xb890
testb $0x1, %al
jne 0x9c80
jmp 0x9d2e
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xb760
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl (%rax), %edx
callq 0x9d60
testb $0x1, %al
jne 0x9cab
jmp 0x9d1d
leaq 0x28(%rsp), %rdi
callq 0xb760
movl (%rax), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xb760
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x7ab0
movq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rsi
addq $0x1, %rsi
callq 0x9b90
testb $0x1, %al
jne 0x9cf8
jmp 0x9cff
movb $0x1, 0x57(%rsp)
jmp 0x9d33
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0xb760
movq (%rsp), %rdi
movl (%rax), %esi
callq 0x9db0
jmp 0x9d1f
leaq 0x28(%rsp), %rdi
callq 0xb8d0
jmp 0x9c68
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nop
// File: shancheng[P]shancheng/src/sudoku.cpp
// Function: (anonymous namespace)::Cell::ClearFlag(unsigned int)
void ClearFlag(uint32_t value) {
    uint32_t bitval = ~(0x01 << value); 
    *rowflag &= bitval;
    *colflag &= bitval;
    *blockflag &= bitval;
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
movl %ecx, -0x10(%rsp)
movl -0x10(%rsp), %edx
movq 0x10(%rax), %rcx
andl (%rcx), %edx
movl %edx, (%rcx)
movl -0x10(%rsp), %edx
movq 0x18(%rax), %rcx
andl (%rcx), %edx
movl %edx, (%rcx)
movl -0x10(%rsp), %ecx
movq 0x20(%rax), %rax
andl (%rax), %ecx
movl %ecx, (%rax)
retq
nopw (%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day03/ex02/ClapTrap.cpp
// Function: ClapTrap::ClapTrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ClapTrap::ClapTrap(std::string name)
{
	this->hitPoints = 100;
	this->maxHit = 100;
	this->energyPoints = 100;
	this->maxEnergyPoints = 100;
	this->meleeAttackDamage = 30;
	this->rangedAttackDamage = 20;
	this->armorDamageReduction = 5;
	this->level = 1.0;
	std::cout << "ClapTrap " << name << " spawned." << std::endl;
	this->name = name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x386d(%rip), %rax      # 0x5cf0
movq %rax, (%rdi)
addq $0x20, %rdi
movq %rdi, -0x38(%rbp)
callq 0x21d0
movq -0x30(%rbp), %rax
movl $0x64, 0x8(%rax)
movl $0x64, 0xc(%rax)
movl $0x64, 0x10(%rax)
movl $0x64, 0x14(%rax)
movl $0x1e, 0x40(%rax)
movl $0x14, 0x44(%rax)
movl $0x5, 0x48(%rax)
movl $0x3f800000, 0x18(%rax) # imm = 0x3F800000
movq 0x3b02(%rip), %rdi      # 0x5fd8
leaq 0x1b27(%rip), %rsi      # 0x4004
callq 0x2130
movq %rax, -0x28(%rbp)
jmp 0x24e8
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x2100
movq %rax, -0x48(%rbp)
jmp 0x24fb
movq -0x48(%rbp), %rdi
leaq 0x1b08(%rip), %rsi      # 0x400e
callq 0x2130
movq %rax, -0x50(%rbp)
jmp 0x2511
movq -0x50(%rbp), %rdi
movq 0x3aac(%rip), %rsi      # 0x5fc8
callq 0x2150
jmp 0x2523
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x2030
jmp 0x2536
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20a0
movq -0x18(%rbp), %rdi
callq 0x2220
nopw (%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day03/ex02/ClapTrap.cpp
// Function: ClapTrap::operator=(ClapTrap const&)
ClapTrap	&ClapTrap::operator=(ClapTrap const &other)
{
	this->hitPoints = other.hitPoints;
	this->maxHit = other.maxHit;
	this->energyPoints = other.energyPoints;
	this->maxEnergyPoints = other.maxEnergyPoints;
	this->name = other.name;
	this->meleeAttackDamage = other.meleeAttackDamage;
	this->rangedAttackDamage = other.rangedAttackDamage;
	this->armorDamageReduction = other.armorDamageReduction;
	this->level = other.level;
	return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rdi)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x10(%rdi)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, 0x14(%rdi)
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x40(%rcx), %ecx
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movl 0x44(%rcx), %ecx
movl %ecx, 0x44(%rax)
movq -0x10(%rbp), %rcx
movl 0x48(%rcx), %ecx
movl %ecx, 0x48(%rax)
movq -0x10(%rbp), %rcx
movss 0x18(%rcx), %xmm0
movss %xmm0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day03/ex02/FragTrap.cpp
// Function: FragTrap::FragTrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
FragTrap::FragTrap(std::string name) : ClapTrap(name)
{
	this->energyPoints = 100;
	this->maxEnergyPoints = 100;
	this->meleeAttackDamage = 30;
	this->rangedAttackDamage = 20;
	this->armorDamageReduction = 5;
	this->level = 1.0;
	std::cout << this->name << ": Hi ! I'm ready !" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2080
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x2460
jmp 0x2a34
leaq -0x30(%rbp), %rdi
callq 0x20a0
movq -0x50(%rbp), %rsi
leaq 0x32e8(%rip), %rax      # 0x5d30
movq %rax, (%rsi)
movl $0x64, 0x10(%rsi)
movl $0x64, 0x14(%rsi)
movl $0x1e, 0x40(%rsi)
movl $0x14, 0x44(%rsi)
movl $0x5, 0x48(%rsi)
movl $0x3f800000, 0x18(%rsi) # imm = 0x3F800000
addq $0x20, %rsi
movq 0x3558(%rip), %rdi      # 0x5fd8
callq 0x2100
movq %rax, -0x58(%rbp)
jmp 0x2a8b
movq -0x58(%rbp), %rdi
leaq 0x1638(%rip), %rsi      # 0x40ce
callq 0x2130
movq %rax, -0x60(%rbp)
jmp 0x2aa1
movq -0x60(%rbp), %rdi
movq 0x351c(%rip), %rsi      # 0x5fc8
callq 0x2150
jmp 0x2ab3
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20a0
jmp 0x2ae5
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x26b0
movq -0x38(%rbp), %rdi
callq 0x2220
nop
// File: t0mm4rx[P]piscine_cpp/day03/ex02/ScavTrap.cpp
// Function: ScavTrap::ScavTrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ScavTrap::ScavTrap(std::string name) : ClapTrap(name)
{
	this->energyPoints = 50;
	this->maxEnergyPoints = 50;
	this->meleeAttackDamage = 20;
	this->rangedAttackDamage = 15;
	this->armorDamageReduction = 3;
	this->level = 1.0;
	std::cout << this->name << ": Hey ! At your service." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2080
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x2460
jmp 0x2fe4
leaq -0x30(%rbp), %rdi
callq 0x20a0
movq -0x50(%rbp), %rsi
leaq 0x2d80(%rip), %rax      # 0x5d78
movq %rax, (%rsi)
movl $0x32, 0x10(%rsi)
movl $0x32, 0x14(%rsi)
movl $0x14, 0x40(%rsi)
movl $0xf, 0x44(%rsi)
movl $0x3, 0x48(%rsi)
movl $0x3f800000, 0x18(%rsi) # imm = 0x3F800000
addq $0x20, %rsi
movq 0x2fa8(%rip), %rdi      # 0x5fd8
callq 0x2100
movq %rax, -0x58(%rbp)
jmp 0x303b
movq -0x58(%rbp), %rdi
leaq 0x1190(%rip), %rsi      # 0x41d6
callq 0x2130
movq %rax, -0x60(%rbp)
jmp 0x3051
movq -0x60(%rbp), %rdi
movq 0x2f6c(%rip), %rsi      # 0x5fc8
callq 0x2150
jmp 0x3063
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20a0
jmp 0x3095
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x26b0
movq -0x38(%rbp), %rdi
callq 0x2220
nop
// File: PrarabdhJoshi[P]DatabaseImplementation/Record.cc
// Function: Record::CopyBits(char*, int)
void Record :: CopyBits(char *bits, int b_len) {

	delete [] this->bits;

	this->bits = new (std::nothrow) char[b_len];
	if (this->bits == NULL)
	{
		cout << "ERROR : Not enough memory. EXIT !!!\n";
		exit(1);
	}

	memcpy (this->bits, bits, b_len);
	
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2b13
movq 0x8(%rsp), %rdi
callq 0x21e0
movslq 0x14(%rsp), %rdi
movq 0xd471(%rip), %rsi      # 0xff90
callq 0x2280
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x2b51
movq 0xd47d(%rip), %rdi      # 0xffb8
leaq 0x94c2(%rip), %rsi      # 0xc004
callq 0x2140
movl $0x1, %edi
callq 0x21c0
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x2110
addq $0x28, %rsp
retq
nopl (%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/Record.cc
// Function: Record::Copy(Record*)
void Record :: Copy (Record *copyMe) {
	// this is a deep copy, so allocate the bits and move them over!
	delete [] bits;
	bits = new (std::nothrow) char[((int *) copyMe->bits)[0]];
	if (bits == NULL)
	{
		cout << "ERROR : Not enough memory. EXIT !!!\n";
		exit(1);
	}

	memcpy (bits, copyMe->bits, ((int *) copyMe->bits)[0]);

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x2c00
movq 0x10(%rsp), %rdi
callq 0x21e0
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq (%rax), %rdi
movq 0xd37e(%rip), %rsi      # 0xff90
callq 0x2280
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x2c45
movq 0xd389(%rip), %rdi      # 0xffb8
leaq 0x93ce(%rip), %rsi      # 0xc004
callq 0x2140
movl $0x1, %edi
callq 0x21c0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq (%rax), %rdx
callq 0x2110
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/Comparison.cc
// Function: Comparison::Comparison(Comparison const&)
Comparison::Comparison(const Comparison &copy_me)
{
	operand1 = copy_me.operand1;
	whichAtt1 = copy_me.whichAtt1;
	operand2 = copy_me.operand2;
	whichAtt2 = copy_me.whichAtt2;

	attType = copy_me.attType;

	op = copy_me.op;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rsp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rsp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x14(%rax)
retq
// File: PrarabdhJoshi[P]DatabaseImplementation/Comparison.cc
// Function: Comparison::Print()
void Comparison :: Print () {

	cout << "Att " << whichAtt1 << " from ";

	if (operand1 == Left)
		cout << "left record ";
	else if (operand1 == Right)
		cout << "right record ";
	else 
		cout << "literal record ";


	if (op == LessThan)
		cout << "< ";
	else if (op == GreaterThan)
		cout << "> ";
	else
		cout << "= ";


	cout << "Att " << whichAtt2 << " from ";

	if (operand2 == Left)
		cout << "left record ";
	else if (operand2 == Right)
		cout << "right record ";
	else
		cout << "literal record ";
 

	if (attType == Int)
		cout << "(Int)";
	else if (attType == Double)
		cout << "(Double)";
	else
		cout << "(String)";
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xcb6e(%rip), %rdi      # 0xffb8
leaq 0x8bdf(%rip), %rsi      # 0xc030
callq 0x2140
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x4(%rax), %esi
callq 0x2290
movq %rax, %rdi
leaq 0x976f(%rip), %rsi      # 0xcbdf
callq 0x2140
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x3494
movq 0xcb32(%rip), %rdi      # 0xffb8
leaq 0x8ba8(%rip), %rsi      # 0xc035
callq 0x2140
jmp 0x34c8
movq 0x8(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x34b3
movq 0xcb13(%rip), %rdi      # 0xffb8
leaq 0x8b96(%rip), %rsi      # 0xc042
callq 0x2140
jmp 0x34c6
movq 0xcafe(%rip), %rdi      # 0xffb8
leaq 0x8b8f(%rip), %rsi      # 0xc050
callq 0x2140
jmp 0x34c8
movq 0x8(%rsp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x34e8
movq 0xcade(%rip), %rdi      # 0xffb8
leaq 0x8b7f(%rip), %rsi      # 0xc060
callq 0x2140
jmp 0x351d
movq 0x8(%rsp), %rax
cmpl $0x1, 0x14(%rax)
jne 0x3508
movq 0xcabe(%rip), %rdi      # 0xffb8
leaq 0x8b62(%rip), %rsi      # 0xc063
callq 0x2140
jmp 0x351b
movq 0xcaa9(%rip), %rdi      # 0xffb8
leaq 0x8b50(%rip), %rsi      # 0xc066
callq 0x2140
jmp 0x351d
movq 0xca94(%rip), %rdi      # 0xffb8
leaq 0x8b05(%rip), %rsi      # 0xc030
callq 0x2140
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %esi
callq 0x2290
movq %rax, %rdi
leaq 0x9695(%rip), %rsi      # 0xcbdf
callq 0x2140
movq 0x8(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x356f
movq 0xca57(%rip), %rdi      # 0xffb8
leaq 0x8acd(%rip), %rsi      # 0xc035
callq 0x2140
jmp 0x35a4
movq 0x8(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x358f
movq 0xca37(%rip), %rdi      # 0xffb8
leaq 0x8aba(%rip), %rsi      # 0xc042
callq 0x2140
jmp 0x35a2
movq 0xca22(%rip), %rdi      # 0xffb8
leaq 0x8ab3(%rip), %rsi      # 0xc050
callq 0x2140
jmp 0x35a4
movq 0x8(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x35c4
movq 0xca02(%rip), %rdi      # 0xffb8
leaq 0x8aac(%rip), %rsi      # 0xc069
callq 0x2140
jmp 0x35f9
movq 0x8(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x35e4
movq 0xc9e2(%rip), %rdi      # 0xffb8
leaq 0x8a92(%rip), %rsi      # 0xc06f
callq 0x2140
jmp 0x35f7
movq 0xc9cd(%rip), %rdi      # 0xffb8
leaq 0x8a86(%rip), %rsi      # 0xc078
callq 0x2140
jmp 0x35f9
addq $0x18, %rsp
retq
nop
// File: PrarabdhJoshi[P]DatabaseImplementation/Comparison.cc
// Function: OrderMaker::OrderMaker(Schema*)
OrderMaker :: OrderMaker(Schema *schema) {
	numAtts = 0;

	int n = schema->GetNumAtts();
	Attribute *atts = schema->GetAtts();

	for (int i = 0; i < n; i++) {
		if (atts[i].myType == Int) {
			whichAtts[numAtts] = i;
			whichTypes[numAtts] = Int;
			numAtts++;
		}
	}

	// now add in the doubles
	for (int i = 0; i < n; i++) {
                if (atts[i].myType == Double) {
                        whichAtts[numAtts] = i;
                        whichTypes[numAtts] = Double;
                        numAtts++;
                }
        }

	// and finally the strings
        for (int i = 0; i < n; i++) {
                if (atts[i].myType == String) {
                        whichAtts[numAtts] = i;
                        whichTypes[numAtts] = String;
                        numAtts++;
                }
        }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, (%rax)
movq 0x28(%rsp), %rdi
callq 0x5d30
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
callq 0x5d40
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x36b3
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0x36a4
movq (%rsp), %rax
movl 0x14(%rsp), %edx
movslq (%rax), %rcx
movl %edx, 0x4(%rax,%rcx,4)
movslq (%rax), %rcx
movl $0x0, 0x54(%rax,%rcx,4)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x36a6
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3662
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x370c
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x1, 0x8(%rax)
jne 0x36fd
movq (%rsp), %rax
movl 0x10(%rsp), %edx
movslq (%rax), %rcx
movl %edx, 0x4(%rax,%rcx,4)
movslq (%rax), %rcx
movl $0x1, 0x54(%rax,%rcx,4)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x36ff
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x36bb
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x3765
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x2, 0x8(%rax)
jne 0x3756
movq (%rsp), %rax
movl 0xc(%rsp), %edx
movslq (%rax), %rcx
movl %edx, 0x4(%rax,%rcx,4)
movslq (%rax), %rcx
movl $0x2, 0x54(%rax,%rcx,4)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x3758
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3714
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: PrarabdhJoshi[P]DatabaseImplementation/Comparison.cc
// Function: OrderMaker::Print()
void OrderMaker :: Print () {
	printf("NumAtts = %5d\n", numAtts);
	for (int i = 0; i < numAtts; i++)
	{
		printf("%3d: %5d ", i, whichAtts[i]);
		if (whichTypes[i] == Int)
			printf("Int\n");
		else if (whichTypes[i] == Double)
			printf("Double\n");
		else
			printf("String\n");
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl (%rax), %esi
leaq 0x88f6(%rip), %rdi      # 0xc081
movb $0x0, %al
callq 0x2050
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jge 0x382b
movq (%rsp), %rax
movl 0xc(%rsp), %esi
movslq 0xc(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %edx
leaq 0x88ce(%rip), %rdi      # 0xc090
movb $0x0, %al
callq 0x2050
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpl $0x0, 0x54(%rax,%rcx,4)
jne 0x37e9
leaq 0x88d5(%rip), %rdi      # 0xc0b5
movb $0x0, %al
callq 0x2050
jmp 0x3819
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpl $0x1, 0x54(%rax,%rcx,4)
jne 0x3809
leaq 0x88c0(%rip), %rdi      # 0xc0c0
movb $0x0, %al
callq 0x2050
jmp 0x3817
leaq 0x88be(%rip), %rdi      # 0xc0ce
movb $0x0, %al
callq 0x2050
jmp 0x3819
jmp 0x381b
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x379a
addq $0x18, %rsp
retq
// File: PrarabdhJoshi[P]DatabaseImplementation/Comparison.cc
// Function: CNF::Print()
void CNF :: Print () {

	for (int i = 0; i < numAnds; i++) {
		
		cout << "( ";
		for (int j = 0; j < orLens[i]; j++) {
			orList[i][j].Print ();
			if (j < orLens[i] - 1)
				cout << " OR ";
		}
		cout << ") ";
		if (i < numAnds - 1)
			cout << " AND\n";
		else
			cout << "\n";
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x25d0(%rcx), %eax
jge 0x3c12
movq 0xc493(%rip), %rdi      # 0xffb8
leaq 0x856e(%rip), %rsi      # 0xc09a
callq 0x2140
movl $0x0, 0x8(%rsp)
movq (%rsp), %rcx
movl 0x8(%rsp), %eax
movslq 0xc(%rsp), %rdx
cmpl 0x2580(%rcx,%rdx,4), %eax
jge 0x3bb0
movq (%rsp), %rdi
movslq 0xc(%rsp), %rax
imulq $0x1e0, %rax, %rax      # imm = 0x1E0
addq %rax, %rdi
movslq 0x8(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x3430
movq (%rsp), %rcx
movl 0x8(%rsp), %eax
movslq 0xc(%rsp), %rdx
movl 0x2580(%rcx,%rdx,4), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3ba1
movq 0xc423(%rip), %rdi      # 0xffb8
leaq 0x8501(%rip), %rsi      # 0xc09d
callq 0x2140
jmp 0x3ba3
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3b39
movq 0xc401(%rip), %rdi      # 0xffb8
leaq 0x84e4(%rip), %rsi      # 0xc0a2
callq 0x2140
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
movl 0x25d0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3bed
movq 0xc3d9(%rip), %rdi      # 0xffb8
leaq 0x84bf(%rip), %rsi      # 0xc0a5
callq 0x2140
jmp 0x3c00
movq 0xc3c4(%rip), %rdi      # 0xffb8
leaq 0x8f7a(%rip), %rsi      # 0xcb75
callq 0x2140
jmp 0x3c02
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3b0a
addq $0x18, %rsp
retq
nopw (%rax,%rax)