LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
jne 0x11eb2
movq 0x29146(%rip), %r14     # 0x3afd0
leaq 0x1bff6(%rip), %rsi     # 0x2de87
movl $0x17, %edx
movq %r14, %rdi
callq 0x4210
leaq 0x1bb8c(%rip), %rsi     # 0x2da31
movl $0x1, %edx
movq %r14, %rdi
callq 0x4210
movq 0x29117(%rip), %r14     # 0x3afd0
leaq 0x1bfdf(%rip), %rsi     # 0x2de9f
movl $0x19, %edx
movq %r14, %rdi
callq 0x4210
leaq 0x1bb5d(%rip), %r15     # 0x2da31
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
leaq 0x1bfce(%rip), %rsi     # 0x2deb9
movl $0xf, %edx
movq %r14, %rdi
callq 0x4210
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
leaq 0x1bfba(%rip), %rsi     # 0x2dec9
movl $0xa, %edx
movq %r14, %rdi
callq 0x4210
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
leaq 0x1bfa1(%rip), %rsi     # 0x2ded4
movl $0xe, %edx
movq %r14, %rdi
callq 0x4210
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
leaq 0x1bf8c(%rip), %rsi     # 0x2dee3
movl $0xd, %edx
movq %r14, %rdi
callq 0x4210
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4210
movq 0x29065(%rip), %rdi     # 0x3afe0
leaq -0x24(%rbp), %rsi
callq 0x4110
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x11fcf
movq 0x29039(%rip), %rbx     # 0x3afd0
leaq 0x1ba93(%rip), %r14     # 0x2da31
movq (%r15), %rdi
callq 0x79a4
cmpl -0x24(%rbp), %eax
jne 0x11fc6
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x7a1b
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x4210
addq $0x10, %r15
cmpq %r12, %r15
jne 0x11f9e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x1bf4e(%rip), %rsi     # 0x2df48
leaq -0x228(%rbp), %rdi
movl $0x10, %edx
callq 0x41f0
movq 0x28fbe(%rip), %rdi     # 0x3afd0
leaq 0x1bf40(%rip), %rsi     # 0x2df59
movl $0x2b, %edx
callq 0x4210
movq 0x28fa6(%rip), %rdi     # 0x3afd0
leaq 0x1b9ff(%rip), %rsi     # 0x2da30
movl $0x2, %edx
callq 0x4210
movq 0x28(%rbx), %rax
cmpq 0x20(%rbx), %rax
jne 0x120ad
movq 0x28f84(%rip), %rdi     # 0x3afd0
leaq 0x1bf32(%rip), %rsi     # 0x2df85
movl $0x59, %edx
callq 0x4210
movq 0x28f6c(%rip), %rdi     # 0x3afd0
leaq 0x1b9c6(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x28f54(%rip), %rdi     # 0x3afd0
leaq 0x1bf5c(%rip), %rsi     # 0x2dfdf
movl $0xa, %edx
callq 0x4210
movq 0x28f3c(%rip), %rdi     # 0x3afd0
leaq 0x1b996(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq %rbx, %rdi
callq 0x10be2
movq 0x20(%rbx), %r12
movq 0x28(%rbx), %r13
cmpq %r13, %r12
je 0x12141
movq 0x28f0b(%rip), %rbx     # 0x3afd0
leaq -0x228(%rbp), %r14
movq (%r12), %rsi
movq %rbx, %rdi
callq 0xb894
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4120
movq (%r12), %rsi
movq %r14, %rdi
callq 0xb894
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4120
addq $0x10, %r12
cmpq %r13, %r12
jne 0x120cc
movq 0x28e78(%rip), %rax     # 0x3afc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x220(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x228(%rbp,%rcx)
callq 0x4180
leaq -0x130(%rbp), %rdi
callq 0x40a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1218b
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x4270
movq %rbx, %rdi
callq 0x42f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x11fdc
movq 0x2871a(%rip), %rdi     # 0x3afd0
leaq 0x1c3fa(%rip), %rsi     # 0x2ecb7
movl $0x24, %edx
callq 0x4210
movq 0x28712(%rip), %rdi     # 0x3afe0
leaq -0x2c(%rbp), %rsi
callq 0x4110
movq 0x20(%rbx), %r14
movq 0x28(%rbx), %r13
cmpq %r13, %r14
je 0x1296e
addq $0x10, %r14
leaq 0x1c3a3(%rip), %r15     # 0x2ec96
movl -0x2c(%rbp), %ebx
movq -0x10(%r14), %rdi
callq 0xb784
movl %eax, %r12d
cmpl %eax, %ebx
jne 0x1292c
movq -0x10(%r14), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%r14), %rax
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x12946
movq 0x286a6(%rip), %rcx     # 0x3afc8
cmpb $0x0, (%rcx)
je 0x12942
incl 0x8(%rax)
jmp 0x12946
movl $0x20, %edx
movq 0x28698(%rip), %rdi     # 0x3afd0
movq %r15, %rsi
callq 0x4210
jmp 0x1295d
lock
incl 0x8(%rax)
leaq -0x40(%rbp), %rsi
callq 0x1d70e
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x1295d
callq 0x4eac
cmpl %r12d, %ebx
je 0x1296e
leaq 0x10(%r14), %rax
cmpq %r13, %r14
movq %rax, %r14
jne 0x128f3
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x12990
callq 0x4eac
movq %rbx, %rdi
callq 0x42f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x1b634(%rip), %rsi     # 0x2dfea
leaq -0x228(%rbp), %rdi
movl $0x10, %edx
callq 0x41f0
movq 0x28602(%rip), %rdi     # 0x3afd0
leaq 0x1b627(%rip), %rsi     # 0x2dffc
movl $0x25, %edx
callq 0x4210
movq 0x285ea(%rip), %rdi     # 0x3afd0
leaq 0x1b043(%rip), %rsi     # 0x2da30
movl $0x2, %edx
callq 0x4210
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
jne 0x12a68
movq 0x285c9(%rip), %rdi     # 0x3afd0
leaq 0x1b614(%rip), %rsi     # 0x2e022
movl $0x4f, %edx
callq 0x4210
movq 0x285b1(%rip), %rdi     # 0x3afd0
leaq 0x1b00b(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x28599(%rip), %rdi     # 0x3afd0
leaq 0x1b5a1(%rip), %rsi     # 0x2dfdf
movl $0xa, %edx
callq 0x4210
movq 0x28581(%rip), %rdi     # 0x3afd0
leaq 0x1afdb(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq %rbx, %rdi
callq 0x10be2
movq (%rbx), %r12
movq 0x8(%rbx), %r13
cmpq %r13, %r12
je 0x12afb
movq 0x28551(%rip), %rbx     # 0x3afd0
leaq -0x228(%rbp), %r14
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x7a1b
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4120
movq (%r12), %rsi
movq %r14, %rdi
callq 0x7a1b
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x41b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4120
addq $0x10, %r12
cmpq %r13, %r12
jne 0x12a86
movq 0x284be(%rip), %rax     # 0x3afc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x220(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x228(%rbp,%rcx)
callq 0x4180
leaq -0x130(%rbp), %rdi
callq 0x40a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12b45
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x4270
movq %rbx, %rdi
callq 0x42f0
// File: /workspace/github_cpp_makefile_star2_O1/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::pegarVeterinario()
std::shared_ptr<Funcionario> Petfera::pegarVeterinario()
{
	std::shared_ptr<Funcionario> novo;

	int id;
	cout << "O IBAMA nos obriga a escolher um veterinario para cuidar do animal"
			 << "\n";

	cout << "Para continuar o cadastro escolha pelo ID um dos tratadores que temos na loja"
			 << "\n";

	for (auto &funcionario : funcionarioStore)
	{
		if (funcionario->getClassicicacao() == Veterinario)
		{
			cout << *(funcionario) << "\n";
		}
	}

	cout << "Escolha um veterinario (Utilizando o ID por favor)"
			 << "\n";

	cin >> id;

	for (auto &funcionario : funcionarioStore)
	{
		if (funcionario->getId() == id)
		{
			novo = funcionario;
		}
	}
	return novo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x27918(%rip), %rdi     # 0x3afd0
leaq 0x1a694(%rip), %rsi     # 0x2dd53
movl $0x42, %edx
callq 0x4210
movq 0x27900(%rip), %rdi     # 0x3afd0
leaq 0x1a35a(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x278e8(%rip), %rdi     # 0x3afd0
leaq 0x1a6a7(%rip), %rsi     # 0x2dd96
movl $0x4d, %edx
callq 0x4210
movq 0x278d0(%rip), %rdi     # 0x3afd0
leaq 0x1a32a(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x20(%r14), %r13
movq %r14, -0x38(%rbp)
movq 0x28(%r14), %r14
cmpq %r14, %r13
je 0x13762
movq 0x278a7(%rip), %r15     # 0x3afd0
leaq 0x1a301(%rip), %r12     # 0x2da31
movq (%r13), %rdi
callq 0xb7ea
testl %eax, %eax
jne 0x13759
movq (%r13), %rsi
movq %r15, %rdi
callq 0xb894
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4210
addq $0x10, %r13
cmpq %r14, %r13
jne 0x13730
movq 0x27867(%rip), %rdi     # 0x3afd0
leaq 0x1a674(%rip), %rsi     # 0x2dde4
movl $0x32, %edx
callq 0x4210
movq -0x38(%rbp), %r14
movq 0x2784b(%rip), %rdi     # 0x3afd0
leaq 0x1a2a5(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x27843(%rip), %rdi     # 0x3afe0
leaq -0x2c(%rbp), %rsi
callq 0x4110
movq 0x20(%r14), %r15
movq 0x28(%r14), %r12
cmpq %r12, %r15
je 0x137df
leaq 0x8(%rbx), %r14
movq (%r15), %rdi
callq 0xb784
cmpl -0x2c(%rbp), %eax
jne 0x137d6
movq (%r15), %rax
movq %rax, (%rbx)
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x7c72
addq $0x10, %r15
cmpq %r12, %r15
jne 0x137b7
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x137f5
jmp 0x137f5
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x13806
callq 0x4eac
movq %r14, %rdi
callq 0x42f0
// File: /workspace/github_cpp_makefile_star2_O1/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::pegarTratador()
std::shared_ptr<Funcionario> Petfera::pegarTratador()
{
	std::shared_ptr<Funcionario> novo;

	int id;
	cout << "O IBAMA nos obriga a escolher um tratador para cuidar do animal"
			 << "\n";

	cout << "Para continuar o cadastro escolha pelo ID um dos tratadores que temos na loja"
			 << "\n";

	for (auto &funcionario : funcionarioStore)
	{
		if (funcionario->getClassicicacao() == Tratador)
		{
			cout << *(funcionario) << "\n";
		}
	}

	cout << "Escolha um tratador (Utilizando o ID por favor)"
			 << "\n";

	cin >> id;

	for (auto &funcionario : funcionarioStore)
	{
		if (funcionario->getId() == id)
		{
			novo = funcionario;
		}
	}
	return novo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x2779e(%rip), %rdi     # 0x3afd0
leaq 0x1a5de(%rip), %rsi     # 0x2de17
movl $0x3f, %edx
callq 0x4210
movq 0x27786(%rip), %rdi     # 0x3afd0
leaq 0x1a1e0(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x2776e(%rip), %rdi     # 0x3afd0
leaq 0x1a52d(%rip), %rsi     # 0x2dd96
movl $0x4d, %edx
callq 0x4210
movq 0x27756(%rip), %rdi     # 0x3afd0
leaq 0x1a1b0(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x20(%r14), %r13
movq %r14, -0x38(%rbp)
movq 0x28(%r14), %r14
cmpq %r14, %r13
je 0x138dd
movq 0x2772d(%rip), %r15     # 0x3afd0
leaq 0x1a187(%rip), %r12     # 0x2da31
movq (%r13), %rdi
callq 0xb7ea
cmpl $0x1, %eax
jne 0x138d4
movq (%r13), %rsi
movq %r15, %rdi
callq 0xb894
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4210
addq $0x10, %r13
cmpq %r14, %r13
jne 0x138aa
movq 0x276ec(%rip), %rdi     # 0x3afd0
leaq 0x1a56c(%rip), %rsi     # 0x2de57
movl $0x2f, %edx
callq 0x4210
movq -0x38(%rbp), %r14
movq 0x276d0(%rip), %rdi     # 0x3afd0
leaq 0x1a12a(%rip), %rsi     # 0x2da31
movl $0x1, %edx
callq 0x4210
movq 0x276c8(%rip), %rdi     # 0x3afe0
leaq -0x2c(%rbp), %rsi
callq 0x4110
movq 0x20(%r14), %r15
movq 0x28(%r14), %r12
cmpq %r12, %r15
je 0x1395a
leaq 0x8(%rbx), %r14
movq (%r15), %rdi
callq 0xb784
cmpl -0x2c(%rbp), %eax
jne 0x13951
movq (%r15), %rax
movq %rax, (%rbx)
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x7c72
addq $0x10, %r15
cmpq %r12, %r15
jne 0x13932
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13970
jmp 0x13970
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x13981
callq 0x4eac
movq %r14, %rdi
callq 0x42f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq 0x26d42(%rip), %rdi     # 0x3afd0
callq 0x4210
movq 0x26d46(%rip), %rdi     # 0x3afe0
movq %rbx, %rsi
callq 0x4220
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x142c6
movq (%r15), %rsi
incq %rsi
callq 0x41d0
movq %r14, %rdi
callq 0x42f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x26ce4(%rip), %r15     # 0x3afe0
leaq -0x48(%rbp), %r12
leaq 0x1a94a(%rip), %r13     # 0x2ec51
leaq 0x1b0cb(%rip), %r14     # 0x2f3d9
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x26cb4(%rip), %rdi     # 0x3afd0
callq 0x4210
movq %r15, %rdi
movq %r12, %rsi
callq 0x4220
movq %r12, %rdi
movq %r13, %rsi
callq 0x4090
testl %eax, %eax
je 0x143c1
movq %r12, %rdi
movq %r14, %rsi
callq 0x4090
testl %eax, %eax
je 0x143c1
movq %r12, %rdi
leaq 0x18dbe(%rip), %rsi     # 0x2d116
callq 0x4090
testl %eax, %eax
je 0x143c1
movq %r12, %rdi
leaq 0x1a8e8(%rip), %rsi     # 0x2ec53
callq 0x4090
testl %eax, %eax
je 0x1439e
movq %r12, %rdi
leaq 0x199d3(%rip), %rsi     # 0x2dd51
callq 0x4090
testl %eax, %eax
je 0x1439e
movq %r12, %rdi
leaq 0x18d8b(%rip), %rsi     # 0x2d11c
callq 0x4090
testl %eax, %eax
jne 0x1430e
movl $0xa, %ebx
leaq -0x48(%rbp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x1a8a1(%rip), %rcx     # 0x2ec53
movl $0x1, %r8d
xorl %esi, %esi
callq 0x42a0
jmp 0x143e2
movl $0xb, %ebx
leaq -0x48(%rbp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x1a87c(%rip), %rcx     # 0x2ec51
movl $0x1, %r8d
xorl %esi, %esi
callq 0x42a0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x143fb
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x41d0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1440e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1442a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x41d0
movq %rbx, %rdi
callq 0x42f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x26b80(%rip), %r15     # 0x3afe0
leaq -0x48(%rbp), %r12
leaq 0x1a7ea(%rip), %r13     # 0x2ec55
leaq 0x1ae33(%rip), %r14     # 0x2f2a5
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x26b50(%rip), %rdi     # 0x3afd0
callq 0x4210
movq %r15, %rdi
movq %r12, %rsi
callq 0x4220
movq %r12, %rdi
movq %r13, %rsi
callq 0x4090
testl %eax, %eax
je 0x144fe
movq %r12, %rdi
movq %r14, %rsi
callq 0x4090
testl %eax, %eax
je 0x144fe
movq %r12, %rdi
leaq 0x18cb8(%rip), %rsi     # 0x2d170
callq 0x4090
testl %eax, %eax
je 0x144fe
movq %r12, %rdi
leaq 0x1a78c(%rip), %rsi     # 0x2ec57
callq 0x4090
testl %eax, %eax
je 0x144fe
movq %r12, %rdi
leaq 0x1a77b(%rip), %rsi     # 0x2ec59
callq 0x4090
testl %eax, %eax
je 0x144fe
movq %r12, %rdi
leaq 0x18c83(%rip), %rsi     # 0x2d174
callq 0x4090
testl %eax, %eax
jne 0x14472
leaq 0x1a750(%rip), %rsi     # 0x2ec55
leaq -0x48(%rbp), %rdi
callq 0x4090
movb $0x1, %bl
testl %eax, %eax
je 0x1453d
leaq 0x1ad8a(%rip), %rsi     # 0x2f2a5
leaq -0x48(%rbp), %rdi
callq 0x4090
testl %eax, %eax
je 0x1453d
leaq 0x18c41(%rip), %rsi     # 0x2d170
leaq -0x48(%rbp), %rdi
callq 0x4090
testl %eax, %eax
sete %bl
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x14556
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x41d0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x14583
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x41d0
movq %rbx, %rdi
callq 0x42f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::lePelo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
pelos Petfera::lePelo(string str_prompt)
{
	int resposta;

	cout << str_prompt;
	cin >> resposta;

	return pelos(resposta - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq 0x214f2(%rip), %rdi     # 0x3afd0
movq %rax, %rsi
callq 0x4210
movq 0x214f3(%rip), %rdi     # 0x3afe0
leaq -0xc(%rbp), %rbx
movq %rbx, %rsi
callq 0x4110
movl (%rbx), %eax
decl %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/viniciu21[P]PetLolja/./src/PetFera.cpp
// Function: Petfera::leGestacao(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
TipoDeGestacao Petfera::leGestacao(string str_prompt)
{
	int resposta;

	cout << str_prompt;
	cin >> resposta;

	return TipoDeGestacao(resposta - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq 0x214b8(%rip), %rdi     # 0x3afd0
movq %rax, %rsi
callq 0x4210
movq 0x214b9(%rip), %rdi     # 0x3afe0
leaq -0xc(%rbp), %rbx
movq %rbx, %rsi
callq 0x4110
movl (%rbx), %eax
decl %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x1e940(%rip), %rbx     # 0x3afd0
leaq 0x1253d(%rip), %rsi     # 0x2ebd4
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x4210
leaq 0x11386(%rip), %r14     # 0x2da31
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4210
leaq 0x12542(%rip), %rsi     # 0x2ec04
movl $0x11, %edx
movq %rbx, %rdi
callq 0x4210
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4210
leaq 0x12530(%rip), %rsi     # 0x2ec16
movl $0x10, %edx
movq %rbx, %rdi
callq 0x4210
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4210
leaq 0x1251d(%rip), %rsi     # 0x2ec27
movl $0x14, %edx
movq %rbx, %rdi
callq 0x4210
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4210
movq 0x1e8b2(%rip), %rdi     # 0x3afe0
leaq -0x12(%rbp), %rbx
movq %rbx, %rsi
callq 0x4050
movzwl (%rbx), %eax
xorl %ecx, %ecx
cmpw $0x6, %ax
sete %cl
addl $0x5, %ecx
cmpw $0x7, %ax
movl $0x7, %eax
cmovnel %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0xbe81(%rip)      # 0x122b0
je 0x64db
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rbx
xorl %r13d, %r13d
movq 0xbb67(%rip), %r14      # 0x11fb8
leaq 0x5c7e(%rip), %r12      # 0xc0d6
cmpl $0x0, 0xbe51(%rip)      # 0x122b0
je 0x64a4
movq %rbx, %rbp
xorl %r15d, %r15d
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%r14,%rax)
movl (%rbp), %esi
movq %r14, %rdi
callq 0x5190
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x5290
incq %r15
movl 0xbe15(%rip), %eax      # 0x122b0
addq $0x48, %rbp
cmpq %rax, %r15
jb 0x6467
movl $0x1, %edx
movq %r14, %rdi
leaq 0x5bd5(%rip), %rsi      # 0xc088
callq 0x5290
incq %r13
movl 0xbdef(%rip), %eax      # 0x122b0
addq $0x708, %rbx            # imm = 0x708
cmpq %rax, %r13
jb 0x6458
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xb(%rsp), %rsi
movb $0x28, (%rsi)
movq 0xbabe(%rip), %rdi      # 0x11fb8
movl $0x1, %edx
callq 0x5290
movl (%rbx), %esi
incl %esi
movq %rax, %rdi
callq 0x5190
movb $0x2c, %bpl
leaq 0xc(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x5290
movl 0x4(%rbx), %esi
incl %esi
movq %rax, %rdi
callq 0x5190
leaq 0xd(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x5290
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x5190
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x5290
movq 0x28(%rbx), %r12
cmpq 0x30(%rbx), %r12
je 0x65a8
movq 0xba3d(%rip), %r14      # 0x11fb8
leaq 0x5b54(%rip), %r15      # 0xc0d6
movl (%r12), %esi
movq %r14, %rdi
callq 0x53f0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x5290
addq $0x4, %r12
cmpq 0x30(%rbx), %r12
jne 0x6582
leaq 0xf(%rsp), %rsi
movb $0x29, (%rsi)
movq 0xba01(%rip), %rdi      # 0x11fb8
movl $0x1, %edx
callq 0x5290
leaq 0x5ac0(%rip), %rsi      # 0xc088
movl $0x1, %edx
movq %rax, %rdi
callq 0x5290
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %bpl
cmpb $0x0, 0xb110(%rdi)
jne 0x69d4
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb0f8(%rdi), %rax
movq 0xb100(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rsi, %rcx
jne 0x6953
movq 0xb69a(%rip), %r14      # 0x11fb8
leaq 0x5818(%rip), %rsi      # 0xc13d
movl $0xb, %edx
movq %r14, %rdi
callq 0x5290
leaq 0x5755(%rip), %rsi      # 0xc08e
movl $0x3c, %edx
movq %r14, %rdi
callq 0x5290
movq %rbx, %rdi
callq 0x6428
jmp 0x69d4
movq (%rax,%r14,8), %r15
movq 0x28(%r15), %r12
movq 0x30(%r15), %r13
cmpq %r13, %r12
setne %bpl
je 0x69d4
incq %r14
movl (%r12), %ecx
movq 0x10(%r15), %rax
movq 0x18(%r15), %rdx
movl (%rdx), %edi
orl (%rax), %edi
movq 0x20(%r15), %rsi
orl (%rsi), %edi
btl %ecx, %edi
jb 0x69c7
movl %ecx, 0x8(%r15)
movb (%r12), %cl
movl $0x1, %edi
shll %cl, %edi
orl %edi, (%rax)
orl %edi, (%rdx)
orl %edi, (%rsi)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x68dc
testb %al, %al
jne 0x69d4
movb (%r12), %cl
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
roll %cl, %eax
movq 0x10(%r15), %rcx
andl %eax, (%rcx)
movq 0x18(%r15), %rcx
andl %eax, (%rcx)
movq 0x20(%r15), %rcx
andl %eax, (%rcx)
addq $0x4, %r12
cmpq %r13, %r12
setne %bpl
jne 0x696b
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
leaq 0x39a7(%rip), %rax      # 0x5cf8
movq %rax, (%rdi)
leaq 0x20(%rdi), %rbx
leaq 0x30(%rdi), %r12
movq %r12, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
movaps 0x1c9d(%rip), %xmm0     # 0x4010
movups %xmm0, 0x8(%rdi)
movabsq $0x140000001e, %rax     # imm = 0x140000001E
movq %rax, 0x40(%rdi)
movl $0x5, 0x48(%rdi)
movl $0x3f800000, 0x18(%rdi) # imm = 0x3F800000
movq 0x3c3e(%rip), %rdi      # 0x5fd8
leaq 0x1c7f(%rip), %rsi      # 0x4020
movl $0x9, %edx
callq 0x2110
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x3c1f(%rip), %rdi      # 0x5fd8
callq 0x2110
movq %rax, %r15
leaq 0x1c62(%rip), %rsi      # 0x402a
movl $0x9, %edx
movq %rax, %rdi
callq 0x2110
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2070
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x2427
movq (%r12), %rsi
incq %rsi
callq 0x2100
movq %r14, %rdi
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0xc(%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movl 0x14(%rsi), %eax
movl %eax, 0x14(%rdi)
addq $0x20, %rsi
addq $0x20, %rdi
callq 0x2070
movl 0x40(%rbx), %eax
movl %eax, 0x40(%r14)
movl 0x44(%rbx), %eax
movl %eax, 0x44(%r14)
movl 0x48(%rbx), %eax
movl %eax, 0x48(%r14)
movss 0x18(%rbx), %xmm0
movss %xmm0, 0x18(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e44
movq %rbx, %rdi
movq %r14, %rsi
callq 0x233c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2905
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2100
leaq 0x342c(%rip), %rax      # 0x5d38
movq %rax, (%rbx)
movabsq $0x6400000064, %rax     # imm = 0x6400000064
movq %rax, 0x10(%rbx)
movabsq $0x140000001e, %rax     # imm = 0x140000001E
movq %rax, 0x40(%rbx)
movl $0x5, 0x48(%rbx)
movl $0x3f800000, 0x18(%rbx) # imm = 0x3F800000
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq 0x3690(%rip), %rdi      # 0x5fd8
callq 0x2110
movq %rax, %r14
leaq 0x1773(%rip), %rsi      # 0x40ca
movl $0x12, %edx
movq %rax, %rdi
callq 0x2110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x29bb
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x29bb
movq %rax, %r14
movq %rbx, %rdi
callq 0x2558
movq %r14, %rdi
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e44
movq %rbx, %rdi
movq %r14, %rsi
callq 0x233c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2f31
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2100
leaq 0x2e48(%rip), %rax      # 0x5d80
movq %rax, (%rbx)
movabsq $0x3200000032, %rax     # imm = 0x3200000032
movq %rax, 0x10(%rbx)
movabsq $0xf00000014, %rax      # imm = 0xF00000014
movq %rax, 0x40(%rbx)
movl $0x3, 0x48(%rbx)
movl $0x3f800000, 0x18(%rbx) # imm = 0x3F800000
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq 0x3064(%rip), %rdi      # 0x5fd8
callq 0x2110
movq %rax, %r14
leaq 0x12a5(%rip), %rsi      # 0x4228
movl $0x18, %edx
movq %rax, %rdi
callq 0x2110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2fe7
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x2fe7
movq %rax, %r14
movq %rbx, %rdi
callq 0x2558
movq %r14, %rdi
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x289c
callq 0x2210
movslq %ebp, %r15
movq 0x96fa(%rip), %rsi      # 0xbfa0
movq %r15, %rdi
callq 0x22d0
movq %rax, (%r14)
testq %rax, %rax
je 0x28ce
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2130
movq 0x96eb(%rip), %rdi      # 0xbfc0
leaq 0x5728(%rip), %rsi      # 0x8004
callq 0x2170
movl $0x1, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x292f
callq 0x2210
movq (%rbx), %rax
movslq (%rax), %rdi
movq 0x9664(%rip), %rsi      # 0xbfa0
callq 0x22d0
movq %rax, (%r14)
testq %rax, %rax
je 0x295e
movq (%rbx), %rsi
movslq (%rsi), %rdx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2130
movq 0x965b(%rip), %rdi      # 0xbfc0
leaq 0x5698(%rip), %rsi      # 0x8004
callq 0x2170
movl $0x1, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/PrarabdhJoshi[P]DatabaseImplementation/Record.cc
// Function: Record::Print(Schema*)
void Record :: Print (Schema *mySchema) {

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

	// loop through all of the attributes
	for (int i = 0; i < n; i++) {

		// print the attribute name
		cout << atts[i].name << ": ";

		// use the i^th slot at the head of the record to get the
		// offset to the correct attribute in the record
		int pointer = ((int *) bits)[i + 1];

		// here we determine the type, which given in the schema;
		// depending on the type we then print out the contents
		cout << "[";

		// first is integer
		if (atts[i].myType == Int) {
			int *myInt = (int *) &(bits[pointer]);
			cout << *myInt;	

		// then is a double
		} else if (atts[i].myType == Double) {
			double *myDouble = (double *) &(bits[pointer]);
			cout << *myDouble;	

		// then is a character string
		} else if (atts[i].myType == String) {
			char *myString = (char *) &(bits[pointer]);
			cout << myString;	
		} 

		cout << "]";

		// print out a comma as needed to make things pretty
		if (i != n - 1) {
			cout << ", ";
		}
	}

	cout << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x438a
movl %eax, %r15d
movq %r14, %rdi
callq 0x438e
testl %r15d, %r15d
jle 0x2de3
movq %rax, %r14
leal -0x1(%r15), %eax
movl %r15d, %ecx
shlq $0x2, %rax
movq %rax, 0x10(%rsp)
shlq $0x2, %rcx
movq %rcx, 0x8(%rsp)
xorl %r13d, %r13d
movq 0x92f4(%rip), %r15      # 0xbfc0
movq (%r14,%r13,4), %r12
testq %r12, %r12
je 0x2ced
movq %r12, %rdi
callq 0x20d0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x21c0
jmp 0x2d05
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x22e0
movl $0x2, %edx
movq %r15, %rdi
leaq 0x5ed9(%rip), %rsi      # 0x8bed
callq 0x21c0
movq (%rbx), %rax
movslq 0x4(%rax,%r13), %rbp
movl $0x1, %edx
movq %r15, %rdi
leaq 0x52f9(%rip), %rsi      # 0x8029
callq 0x21c0
movl 0x8(%r14,%r13,4), %eax
cmpl $0x2, %eax
je 0x2d6a
cmpl $0x1, %eax
je 0x2d58
testl %eax, %eax
jne 0x2da5
movq (%rbx), %rax
movl (%rax,%rbp), %esi
movq %r15, %rdi
callq 0x22f0
jmp 0x2da5
movq (%rbx), %rax
movsd (%rax,%rbp), %xmm0
movq %r15, %rdi
callq 0x22a0
jmp 0x2da5
movq (%rbx), %r12
testq %r12, %r12
je 0x2d8d
addq %rbp, %r12
movq %r12, %rdi
callq 0x20d0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x21c0
jmp 0x2da5
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x22e0
movl $0x1, %edx
movq %r15, %rdi
leaq 0x5277(%rip), %rsi      # 0x802b
callq 0x21c0
cmpq %r13, 0x10(%rsp)
je 0x2dd4
movl $0x2, %edx
movq %r15, %rdi
leaq 0x525e(%rip), %rsi      # 0x802d
callq 0x21c0
addq $0x4, %r13
cmpq %r13, 0x8(%rsp)
jne 0x2ccc
movq 0x91d6(%rip), %rdi      # 0xbfc0
leaq 0x5d64(%rip), %rsi      # 0x8b55
movl $0x1, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21c0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x9194(%rip), %r14      # 0xbfc0
leaq 0x5249(%rip), %rsi      # 0x807c
movl $0x4, %edx
movq %r14, %rdi
callq 0x21c0
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x22f0
leaq 0x5d6d(%rip), %rsi      # 0x8bbf
movl $0x6, %edx
movq %rax, %rdi
callq 0x21c0
movl (%rbx), %eax
movq 0x9158(%rip), %rdi      # 0xbfc0
cmpl $0x1, %eax
je 0x2e7f
testl %eax, %eax
jne 0x2e8d
leaq 0x5209(%rip), %rsi      # 0x8081
movl $0xc, %edx
jmp 0x2e99
leaq 0x5208(%rip), %rsi      # 0x808e
movl $0xd, %edx
jmp 0x2e99
leaq 0x5208(%rip), %rsi      # 0x809c
movl $0xf, %edx
callq 0x21c0
movl 0x14(%rbx), %eax
cmpl $0x1, %eax
leaq 0x5204(%rip), %rcx      # 0x80af
leaq 0x5200(%rip), %rdx      # 0x80b2
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x51ed(%rip), %rsi      # 0x80ac
cmovneq %rdx, %rsi
movq 0x90f6(%rip), %r14      # 0xbfc0
movl $0x2, %edx
movq %r14, %rdi
callq 0x21c0
leaq 0x519e(%rip), %rsi      # 0x807c
movl $0x4, %edx
movq %r14, %rdi
callq 0x21c0
movl 0xc(%rbx), %esi
movq %r14, %rdi
callq 0x22f0
leaq 0x5cc2(%rip), %rsi      # 0x8bbf
movl $0x6, %edx
movq %rax, %rdi
callq 0x21c0
movl 0x8(%rbx), %eax
movq 0x90ac(%rip), %rdi      # 0xbfc0
cmpl $0x1, %eax
je 0x2f2b
testl %eax, %eax
jne 0x2f39
leaq 0x515d(%rip), %rsi      # 0x8081
movl $0xc, %edx
jmp 0x2f45
leaq 0x515c(%rip), %rsi      # 0x808e
movl $0xd, %edx
jmp 0x2f45
leaq 0x515c(%rip), %rsi      # 0x809c
movl $0xf, %edx
callq 0x21c0
movl 0x10(%rbx), %eax
movq 0x906c(%rip), %rdi      # 0xbfc0
cmpl $0x1, %eax
je 0x2f6b
testl %eax, %eax
jne 0x2f74
leaq 0x5151(%rip), %rsi      # 0x80b5
movl $0x5, %edx
jmp 0x2f80
leaq 0x5149(%rip), %rsi      # 0x80bb
jmp 0x2f7b
leaq 0x5149(%rip), %rsi      # 0x80c4
movl $0x8, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, (%rdi)
movq %rsi, %rdi
callq 0x438a
movl %eax, %ebp
movq %r14, %rdi
callq 0x438e
movl %ebp, %ecx
testl %ebp, %ebp
jle 0x2fe9
leaq 0x8(%rax), %rdx
xorl %esi, %esi
cmpl $0x0, (%rdx)
jne 0x2fdd
movslq (%rbx), %rdi
movl %esi, 0x4(%rbx,%rdi,4)
movslq (%rbx), %rdi
movl $0x0, 0x54(%rbx,%rdi,4)
incl %edi
movl %edi, (%rbx)
incq %rsi
addq $0x10, %rdx
cmpq %rsi, %rcx
jne 0x2fc2
testl %ebp, %ebp
jle 0x301a
leaq 0x8(%rax), %rdx
xorl %esi, %esi
cmpl $0x1, (%rdx)
jne 0x300e
movslq (%rbx), %rdi
movl %esi, 0x4(%rbx,%rdi,4)
movslq (%rbx), %rdi
movl $0x1, 0x54(%rbx,%rdi,4)
incl %edi
movl %edi, (%rbx)
incq %rsi
addq $0x10, %rdx
cmpq %rsi, %rcx
jne 0x2ff3
testl %ebp, %ebp
jle 0x304b
addq $0x8, %rax
xorl %edx, %edx
cmpl $0x2, (%rax)
jne 0x303f
movslq (%rbx), %rsi
movl %edx, 0x4(%rbx,%rsi,4)
movslq (%rbx), %rsi
movl $0x2, 0x54(%rbx,%rsi,4)
incl %esi
movl %esi, (%rbx)
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
jne 0x3024
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %esi
leaq 0x5066(%rip), %rdi      # 0x80cd
xorl %eax, %eax
callq 0x2060
cmpl $0x0, (%rbx)
jle 0x30c9
leaq 0x5062(%rip), %r14      # 0x80dc
leaq 0x51e2(%rip), %r12      # 0x8263
leaq 0x51d4(%rip), %r13      # 0x825c
leaq 0x51db(%rip), %rbp      # 0x826a
xorl %r15d, %r15d
movl 0x4(%rbx,%r15,4), %edx
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x2060
movl 0x54(%rbx,%r15,4), %eax
cmpl $0x1, %eax
movq %r13, %rdi
cmoveq %r12, %rdi
testl %eax, %eax
cmoveq %rbp, %rdi
callq 0x2280
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x3092
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/PrarabdhJoshi[P]DatabaseImplementation/Comparison.cc
// Function: CNF::GetSortOrders(OrderMaker&, OrderMaker&)
int CNF :: GetSortOrders (OrderMaker &left, OrderMaker &right) {

	// initialize the size of the OrderMakers
	left.numAtts = 0;
	right.numAtts = 0;

	// loop through all of the disjunctions in the CNF and find those
	// that are acceptable for use in a sort ordering
	for (int i = 0; i < numAnds; i++) {
		
		// if we don't have a disjunction of length one, then it
		// can't be acceptable for use with a sort ordering
		if (orLens[i] != 1) {
			continue;
		}

		// made it this far, so first verify that it is an equality check
		if (orList[i][0].op != Equals) {
			continue;
		}

		// now verify that it operates over atts from both tables
		if (!((orList[i][0].operand1 == Left && orList[i][0].operand2 == Right) ||
		      (orList[i][0].operand2 == Left && orList[i][0].operand1 == Right))) {
			continue;		
		}

		// since we are here, we have found a join attribute!!!
		// so all we need to do is add the new comparison info into the
		// relevant structures
		if (orList[i][0].operand1 == Left) {
			left.whichAtts[left.numAtts] = orList[i][0].whichAtt1;
			left.whichTypes[left.numAtts] = orList[i][0].attType;	
		}	

		if (orList[i][0].operand1 == Right) {
                        right.whichAtts[right.numAtts] = orList[i][0].whichAtt1;
                        right.whichTypes[right.numAtts] = orList[i][0].attType;
                }

		if (orList[i][0].operand2 == Left) {
                        left.whichAtts[left.numAtts] = orList[i][0].whichAtt2;
                        left.whichTypes[left.numAtts] = orList[i][0].attType;
                }

		if (orList[i][0].operand2 == Right) {
                        right.whichAtts[right.numAtts] = orList[i][0].whichAtt2;
                        right.whichTypes[right.numAtts] = orList[i][0].attType;
                }

		// note that we have found two new attributes
		left.numAtts++;
		right.numAtts++;
	}
	
	return left.numAtts;

}

// Assembly:
xorl %eax, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
cmpl %eax, 0x25d0(%rdi)
jle 0x31a7
leaq 0x14(%rdi), %rax
xorl %ecx, %ecx
cmpl $0x1, 0x2580(%rdi,%rcx,4)
jne 0x318e
cmpl $0x2, (%rax)
jne 0x318e
movl -0x14(%rax), %r8d
testl %r8d, %r8d
jne 0x3116
cmpl $0x1, -0xc(%rax)
je 0x3122
cmpl $0x1, %r8d
jne 0x318e
cmpl $0x0, -0xc(%rax)
jne 0x318e
testl %r8d, %r8d
jne 0x313f
movl -0x10(%rax), %r9d
movslq (%rsi), %r10
movl %r9d, 0x4(%rsi,%r10,4)
movl -0x4(%rax), %r9d
movslq (%rsi), %r10
movl %r9d, 0x54(%rsi,%r10,4)
cmpl $0x1, %r8d
jne 0x315d
movl -0x10(%rax), %r8d
movslq (%rdx), %r9
movl %r8d, 0x4(%rdx,%r9,4)
movl -0x4(%rax), %r8d
movslq (%rdx), %r9
movl %r8d, 0x54(%rdx,%r9,4)
movl -0xc(%rax), %r9d
movq %rsi, %r8
testl %r9d, %r9d
je 0x3172
cmpl $0x1, %r9d
jne 0x318a
movq %rdx, %r8
movl -0x8(%rax), %r9d
movslq (%r8), %r10
movl %r9d, 0x4(%r8,%r10,4)
movl -0x4(%rax), %r9d
movslq (%r8), %r10
movl %r9d, 0x54(%r8,%r10,4)
incl (%rsi)
incl (%rdx)
incq %rcx
movslq 0x25d0(%rdi), %r8
addq $0x1e0, %rax            # imm = 0x1E0
cmpq %r8, %rcx
jl 0x30f0
movl (%rsi), %eax
retq