LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/Scorer.cpp
// Function: Scorer::getGroupScore(Learner*, std::vector<unsigned int, std::allocator<unsigned int>>&, std::vector<unsigned int, std::allocator<unsigned int>>&, ScoreInfo&, int)
void Scorer::getGroupScore(Learner* weak,std::vector<unsigned int> &ind, std::vector<unsigned int> &cand, ScoreInfo &si, int treeType) {
	Score score;
	weak->setLS(&ind);
	if (treeType == RANDOMTTSTUMP || treeType == EXTRATTSTUMP)
		((GStump*)weak)->setAttCand(&cand);
	else 
		weak->setAttCand(&cand);
	weak->learn();

	Result result = weak->test(&ind);
	result.shrink();
	
	ContingencyTable ctable = result.getContingencyTable();	
	std::vector<double> th = result.getPossibleProbTh();

	if (treeType == EXTRATREE || treeType == EXTRATTSTUMP)
		th = Sampler::random(th, 1);
	
	for (int t = 0 ; t < th.size() ; ++t) {
		ctable = result.getContingencyTable(th[t]);
		ctable.compact(th[t]);
		si.update(weak,th[t],score.getScore(ctable));
	}
	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movl %r9d, %r15d
movq %r8, 0x20(%rsp)
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r14
movl $0x1, 0x4(%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xdeb0
leal -0x5(%r15), %eax
movq %r14, %rdi
movq %r13, %rsi
cmpl $0x1, %eax
ja 0x108dd
callq 0xc84e
jmp 0x108e2
callq 0xdebc
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq (%r14), %rax
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq *0x20(%rax)
leaq 0x38(%rsp), %rdi
callq 0x11654
leaq 0x100(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movsd 0x26f6(%rip), %xmm0     # 0x13010
callq 0xfbe4
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xfb1e
cmpl $0x6, %r15d
je 0x1093a
cmpl $0x3, %r15d
jne 0x1096c
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x114fe
leaq 0x8(%rsp), %rdi
leaq 0x88(%rsp), %r15
movq %r15, %rsi
callq 0x11c3e
movq %r15, %rdi
callq 0x6de4
xorl %ebx, %ebx
leaq 0x88(%rsp), %r15
leaq 0x30(%rsp), %r12
leaq 0x100(%rsp), %r13
leaq 0x4(%rsp), %rbp
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
jbe 0x10a0c
movsd (%rax,%rbx,8), %xmm0
movq %r15, %rdi
movq %r12, %rsi
callq 0xfbe4
movq %r13, %rdi
movq %r15, %rsi
callq 0x115de
movq %r15, %rdi
callq 0xa982
movq 0x8(%rsp), %rax
movsd (%rax,%rbx,8), %xmm0
movq %r13, %rdi
callq 0xaaae
movq 0x8(%rsp), %rax
movsd (%rax,%rbx,8), %xmm0
movsd %xmm0, 0x28(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x101dc
movaps %xmm0, %xmm1
movq 0x20(%rsp), %rdi
movq %r14, %rsi
movsd 0x28(%rsp), %xmm0
callq 0x10608
incq %rbx
jmp 0x10988
leaq 0x8(%rsp), %rdi
callq 0x6de4
leaq 0x100(%rsp), %rdi
callq 0xa982
leaq 0x30(%rsp), %rdi
callq 0xfa56
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10a61
movq %rax, %rbx
jmp 0x10a6e
jmp 0x10a48
movq %rax, %rbx
jmp 0x10a7b
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xa982
jmp 0x10a64
jmp 0x10a61
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6de4
leaq 0x100(%rsp), %rdi
callq 0xa982
leaq 0x30(%rsp), %rdi
callq 0xfa56
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/Scorer.cpp
// Function: Scorer::getRandSNPScore(std::vector<unsigned int, std::allocator<unsigned int>>&, std::vector<unsigned int, std::allocator<unsigned int>>&)
ScoreInfo Scorer::getRandSNPScore(std::vector<unsigned int> &ind, std::vector<unsigned int> &snp) {
	ScoreInfo si;
	for (int s = 0 ; s < snp.size() ; ++s) 
		getRandSNPScore(ind,snp[s],si);
	return si;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0x105b4
xorl %r13d, %r13d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x10ad5
movl (%rax,%r13,4), %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x10ae2
incq %r13
jmp 0x10aab
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/Scorer.cpp
// Function: Scorer::getRandSNPScore(std::vector<unsigned int, std::allocator<unsigned int>>&, unsigned int, ScoreInfo&)
void Scorer::getRandSNPScore(std::vector<unsigned int> &ind, unsigned int snp, ScoreInfo &si) {
	Score score;
	ContingencyTable ctable(2,3); 
	for (int i = 0 ; i < ind.size() ; ++i)
		ctable.addToTable(db->getOutput(ind[i]), db->getAttVal(ind[i], snp),db->getWeight(ind[i]));
	std::vector<double> th = ctable.getPossibleTh();
	if (th.size() > 0) {
		int t = rand() % th.size();
		ctable.compact(th[t]);
		si.update(snp,th[t],score.getScore(ctable));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r14
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
movl $0x1, 0xc(%rsp)
leaq 0x30(%rsp), %r13
pushq $0x2
popq %rsi
pushq $0x3
popq %rdx
movq %r13, %rdi
callq 0xa834
xorl %ebp, %ebp
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbp, %rcx
jbe 0x10b63
movq (%r12), %rcx
movl (%rax,%rbp,4), %eax
movq 0x8(%rcx), %rdi
movq 0x28(%rcx), %rdx
movswl (%rdx,%rax,2), %esi
movl 0x24(%rcx), %edx
imull %eax, %edx
addl %ebx, %edx
movq 0x40(%rcx), %rcx
movswl (%rcx,%rdx,2), %edx
movsd (%rdi,%rax,8), %xmm0
movq %r13, %rdi
callq 0xaa90
incq %rbp
jmp 0x10b1b
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xad1a
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x10be1
callq 0x30a0
cltq
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
xorl %edx, %edx
divq %rsi
movslq %edx, %r15
movsd (%rcx,%r15,8), %xmm0
leaq 0x30(%rsp), %rdi
callq 0xaaae
movq 0x10(%rsp), %rax
movsd (%rax,%r15,8), %xmm0
movsd %xmm0, 0x28(%rsp)
leaq 0xc(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x101dc
movaps %xmm0, %xmm1
movq %r14, %rdi
movl %ebx, %esi
movsd 0x28(%rsp), %xmm0
callq 0x105c6
leaq 0x10(%rsp), %rdi
callq 0x6de4
leaq 0x30(%rsp), %rdi
callq 0xa982
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10c18
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6de4
jmp 0x10c1b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xa982
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/Scorer.cpp
// Function: Scorer::getBestSNPScore(std::vector<unsigned int, std::allocator<unsigned int>>&, std::vector<unsigned int, std::allocator<unsigned int>>&)
ScoreInfo Scorer::getBestSNPScore(std::vector<unsigned int> &ind, std::vector<unsigned int> &snp) {
	//Score score;
	//printf("getBestSNPScore\n");
	ScoreInfo si;
	for (int s = 0 ; s < snp.size() ; ++s) 
		getSNPScore(ind,snp[s],si);
	return si;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0x105b4
xorl %r13d, %r13d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x10c75
movl (%rax,%r13,4), %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x10c82
incq %r13
jmp 0x10c4b
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/Scorer.cpp
// Function: Scorer::getSNPScore(std::vector<unsigned int, std::allocator<unsigned int>>&, unsigned int, ScoreInfo&)
void Scorer::getSNPScore(std::vector<unsigned int> &ind, unsigned int snp, ScoreInfo &si) {
	Score score;
	ContingencyTable ctable(2,3); 
	for (int i = 0 ; i < ind.size() ; ++i)
		ctable.addToTable(db->getOutput(ind[i]), db->getAttVal(ind[i], snp),db->getWeight(ind[i]));
	std::vector<double> th = ctable.getPossibleTh();
	for (int t = 0 ; t < th.size() ; ++t) {
		ctable.compact(th[t]);
		//ctable.print();
		si.update(snp,th[t],score.getScore(ctable));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, 0xc(%rsp)
leaq 0x30(%rsp), %r12
pushq $0x2
popq %rsi
pushq $0x3
popq %rdx
movq %r12, %rdi
callq 0xa834
xorl %r13d, %r13d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x10d04
movq (%r15), %rcx
movl (%rax,%r13,4), %eax
movq 0x8(%rcx), %rdi
movq 0x28(%rcx), %rdx
movswl (%rdx,%rax,2), %esi
movl 0x24(%rcx), %edx
imull %eax, %edx
addl %ebp, %edx
movq 0x40(%rcx), %rcx
movswl (%rcx,%rdx,2), %edx
movsd (%rdi,%rax,8), %xmm0
movq %r12, %rdi
callq 0xaa90
incq %r13
jmp 0x10cbc
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xad1a
xorl %r12d, %r12d
leaq 0x30(%rsp), %r14
leaq 0xc(%rsp), %r15
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x10d78
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
callq 0xaaae
movq 0x18(%rsp), %rax
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x101dc
movaps %xmm0, %xmm1
movq %rbx, %rdi
movl %ebp, %esi
movsd 0x10(%rsp), %xmm0
callq 0x105c6
incq %r12
jmp 0x10d20
leaq 0x18(%rsp), %rdi
callq 0x6de4
leaq 0x30(%rsp), %rdi
callq 0xa982
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10da0
movq %rax, %rbx
jmp 0x10db2
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6de4
leaq 0x30(%rsp), %rdi
callq 0xa982
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/Scorer.cpp
// Function: Scorer::getSNPScore(std::vector<unsigned int, std::allocator<unsigned int>>&, unsigned int)
ScoreInfo Scorer::getSNPScore(std::vector<unsigned int> &ind, unsigned int snp) {
	Score score;
	ScoreInfo si;	
	ContingencyTable ctable(2,3);
	for (int i = 0 ; i < ind.size() ; ++i)
		ctable.addToTable(db->getOutput(ind[i]), db->getAttVal(ind[i], snp), db->getWeight(ind[i]));
	std::vector<double> th = ctable.getPossibleTh();
	for (int t = 0 ; t < th.size() ; ++t) {
		ctable.compact(th[t]);
		si.update(snp,th[t],score.getScore(ctable));
	}
	return si;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, 0xc(%rsp)
callq 0x105b4
leaq 0x30(%rsp), %r12
pushq $0x2
popq %rsi
pushq $0x3
popq %rdx
movq %r12, %rdi
callq 0xa834
xorl %r13d, %r13d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x10e4b
movq (%r15), %rcx
movl (%rax,%r13,4), %eax
movq 0x8(%rcx), %rdi
movq 0x28(%rcx), %rdx
movswl (%rdx,%rax,2), %esi
movl 0x24(%rcx), %edx
imull %eax, %edx
addl %ebp, %edx
movq 0x40(%rcx), %rcx
movswl (%rcx,%rdx,2), %edx
movsd (%rdi,%rax,8), %xmm0
movq %r12, %rdi
callq 0xaa90
incq %r13
jmp 0x10e03
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xad1a
xorl %r12d, %r12d
leaq 0x30(%rsp), %r14
leaq 0xc(%rsp), %r15
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x10ebf
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
callq 0xaaae
movq 0x18(%rsp), %rax
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x101dc
movaps %xmm0, %xmm1
movq %rbx, %rdi
movl %ebp, %esi
movsd 0x10(%rsp), %xmm0
callq 0x105c6
incq %r12
jmp 0x10e67
leaq 0x18(%rsp), %rdi
callq 0x6de4
leaq 0x30(%rsp), %rdi
callq 0xa982
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10eea
movq %rax, %rbx
jmp 0x10efc
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6de4
leaq 0x30(%rsp), %rdi
callq 0xa982
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/Scorer.cpp
// Function: Scorer::getContingencyTable(std::vector<unsigned int, std::allocator<unsigned int>>&, unsigned int, double)
ContingencyTable Scorer::getContingencyTable(std::vector<unsigned int> &ind, unsigned int snp, double th) {
	ContingencyTable ctable(2,2);
	for (int i = 0 ; i < ind.size(); ++i) {
		if (db->getAttVal(ind[i], snp) > th)
			ctable.addGeq(db->getOutput(ind[i]),db->getWeight(ind[i]));
			//ctable.addToTable(db->getOutput(ind[i]), db->getAttVal(ind[i], snp),db->getWeight(ind[i]));
		else
			ctable.addLess(db->getOutput(ind[i]),db->getWeight(ind[i]));
			//ctable.addToTable(db->getOutput(ind[i]), db->getAttVal(ind[i], snp),db->getWeight(ind[i]));
			
	}
	//ctable.compact(th);
	return ctable;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x2
popq %rdx
movl %edx, %esi
callq 0xa834
xorl %r12d, %r12d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x10f96
movq (%r15), %rcx
movl (%rax,%r12,4), %eax
movl 0x24(%rcx), %edx
imull %eax, %edx
addl %ebp, %edx
movq 0x40(%rcx), %rsi
movswl (%rsi,%rdx,2), %edx
cvtsi2sd %edx, %xmm0
ucomisd 0x8(%rsp), %xmm0
movq 0x8(%rcx), %rdx
movq 0x28(%rcx), %rcx
movswl (%rcx,%rax,2), %esi
movsd (%rdx,%rax,8), %xmm0
jbe 0x10f89
movq %rbx, %rdi
callq 0xab42
jmp 0x10f91
movq %rbx, %rdi
callq 0xab62
incq %r12
jmp 0x10f38
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa982
movq %r14, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/Scorer.cpp
// Function: Scorer::getRandNumericalScore(std::vector<unsigned int, std::allocator<unsigned int>>&, std::vector<unsigned int, std::allocator<unsigned int>>&)
ScoreInfo Scorer::getRandNumericalScore(std::vector<unsigned int> &obj, std::vector<unsigned int> &att) {
	//printf("getBestNumericalScore\n");
	ScoreInfo si;
	for (int a = 0 ; a < att.size() ; ++a)
		getRandNumericalScore(obj,att[a],si);
	return si;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0x105b4
xorl %r13d, %r13d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x1100f
movl (%rax,%r13,4), %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x1101c
incq %r13
jmp 0x10fe5
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/Scorer.cpp
// Function: Scorer::getBestNumericalScore(std::vector<unsigned int, std::allocator<unsigned int>>&, std::vector<unsigned int, std::allocator<unsigned int>>&)
ScoreInfo Scorer::getBestNumericalScore(std::vector<unsigned int> &obj, std::vector<unsigned int> &att) {
	//printf("getBestNumericalScore\n");
	ScoreInfo si;
	for (int a = 0 ; a < att.size() ; ++a)
		getBestNumericalScore(obj,att[a],si);
	return si;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0x105b4
xorl %r13d, %r13d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x112ad
movl (%rax,%r13,4), %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x112ba
incq %r13
jmp 0x11283
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/TrueBestFirstStack.cpp
// Function: TrueBestFirstStack::push(Node*)
void TrueBestFirstStack::push(Node* n) {
	fprintf(stderr,"\n");
	fprintf(stderr,"Error - this stack does not support basic use\n");
	fprintf(stderr,"      - True Best First push need att cand list\n");
	fprintf(stderr,"\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0xba0e(%rip), %r15      # 0x1dfd8
movq (%r15), %rsi
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x3260
movq (%r15), %rcx
leaq 0x15bf(%rip), %rdi      # 0x13ba0
pushq $0x2e
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x3370
movq (%r15), %rcx
leaq 0x15d5(%rip), %rdi      # 0x13bcf
pushq $0x30
popq %rsi
movq %r14, %rdx
callq 0x3370
movq (%r15), %rsi
movl %ebx, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/0asa[P]TTree-source/TrueBestFirstStack.cpp
// Function: TrueBestFirstStack::clearStack()
void TrueBestFirstStack::clearStack() {	
	//printf("Node left : %d\n",s.size());
	for (int i = 0 ; i < s.size() ; ++i) {
		//printf("node size : %d\n",s[i]->getLS().size());
		s[i]->setLeft(NULL);
		s[i]->setRight(NULL);
		delete s[i]->getLeft();
		delete s[i]->getRight();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
pushq $0x60
popq %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x129eb
movq (%rax,%r12,8), %rdi
xorl %esi, %esi
callq 0xe5da
movq (%rbx), %rax
movq (%rax,%r12,8), %rdi
xorl %esi, %esi
callq 0xe5e0
movq (%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0xe50c
movq %rax, %r15
testq %rax, %rax
je 0x129b4
movq %r15, %rdi
callq 0xe486
movq %r15, %rdi
movq %r14, %rsi
callq 0x3210
movq (%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0xe512
movq %rax, %r15
testq %rax, %rax
je 0x129db
movq %r15, %rdi
callq 0xe486
movq %r15, %rdi
movq %r14, %rsi
callq 0x3210
incq %r12
jmp 0x1296c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_corpo.cpp
// Function: ANIMAL::ANIMAL(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ANIMAL::ANIMAL(int i, string c, string no, string n, char s, double tam, string die, string vet, string trat, string nome){
	this->id = i;
	this->classe = c;
	this->nome = no;
	this->nome_cientifico = n;
	this->sexo = s;
	this->tamanho = tam;
	this->dieta = die;
	this->veterinario = vet;
	this->tratador = trat;
	this->nome_batismo = nome;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x2bcef(%rip), %rax     # 0x30858
movq %rax, (%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movsd %xmm0, -0x60(%rbp)
xorl %eax, %eax
movb %al, 0x20(%rdi)
addq $0x40, %rdi
movq %rdi, 0x30(%rbx)
andq $0x0, 0x38(%rbx)
movl %r9d, %r12d
movq %r8, %r13
movb %al, 0x40(%rbx)
leaq 0x60(%rbx), %rdi
movq %rdi, 0x50(%rbx)
andq $0x0, 0x58(%rbx)
movq %rcx, %r14
movb %al, 0x60(%rbx)
leaq 0x90(%rbx), %rcx
movq %rcx, 0x80(%rbx)
andq $0x0, 0x88(%rbx)
leaq 0x10(%rbx), %rdi
movb %al, 0x90(%rbx)
leaq 0xb0(%rbx), %rcx
movq %rcx, 0xa0(%rbx)
andq $0x0, 0xa8(%rbx)
leaq 0x30(%rbx), %rcx
movq %rcx, -0x50(%rbp)
leaq 0x50(%rbx), %rcx
movq %rcx, -0x48(%rbp)
movb %al, 0xb0(%rbx)
leaq 0xd0(%rbx), %rcx
movq %rcx, 0xc0(%rbx)
andq $0x0, 0xc8(%rbx)
leaq 0x80(%rbx), %rcx
movq %rcx, -0x40(%rbp)
movb %al, 0xd0(%rbx)
leaq 0xf0(%rbx), %rcx
movq %rcx, 0xe0(%rbx)
leaq 0xa0(%rbx), %rcx
movq %rcx, -0x38(%rbp)
andq $0x0, 0xe8(%rbx)
movb %al, 0xf0(%rbx)
leaq 0xc0(%rbx), %rax
movq %rax, -0x30(%rbp)
movl %esi, 0x8(%rbx)
leaq 0xe0(%rbx), %r15
movq %rdi, -0x58(%rbp)
movq %rdx, %rsi
callq 0x3120
movq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x3120
movq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x3120
movq 0x10(%rbp), %rsi
movb %r12b, 0x70(%rbx)
movsd -0x60(%rbp), %xmm0
movsd %xmm0, 0x78(%rbx)
movq -0x40(%rbp), %rdi
callq 0x3120
movq 0x18(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x3120
movq 0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x3120
movq 0x28(%rbp), %rsi
movq %r15, %rdi
callq 0x3120
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x3100
movq -0x30(%rbp), %rdi
callq 0x3100
movq -0x38(%rbp), %rdi
callq 0x3100
movq -0x40(%rbp), %rdi
callq 0x3100
movq -0x48(%rbp), %rdi
callq 0x3100
movq -0x50(%rbp), %rdi
callq 0x3100
movq -0x58(%rbp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_corpo.cpp
// Function: VETERINARIO::VETERINARIO(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
VETERINARIO::VETERINARIO(int i, string n, long int c, int ida, string t, char f, string e, string cr){
	id = i;
	nome = n;
	cpf = c;
	idade = ida;
	tipo_sanguineo = t;
	fator_rh = f;
	especialidade = e;
	crmv = cr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, -0x30(%rbp)
movl %r8d, %r12d
movq %rcx, %r13
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
callq 0xb37a
leaq 0x25fc7(%rip), %rax     # 0x30ab8
movq %rax, (%rbx)
leaq 0x98(%rbx), %rax
movq %rax, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
leaq 0x88(%rbx), %rax
movb $0x0, 0x98(%rbx)
movl %r15d, 0x8(%rbx)
movq %rax, %r15
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x3120
movq %r13, 0x30(%rbx)
movl %r12d, 0x38(%rbx)
leaq 0x40(%rbx), %rdi
movq -0x30(%rbp), %rsi
callq 0x3120
movq 0x18(%rbp), %rsi
movb 0x10(%rbp), %al
movb %al, 0x60(%rbx)
leaq 0x68(%rbx), %rdi
callq 0x3120
movq 0x20(%rbp), %rsi
movq %r15, %rdi
callq 0x3120
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x463e
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_corpo.cpp
// Function: operator<<(std::ostream&, VETERINARIO&)
ostream& operator << (ostream &out, VETERINARIO &v){
	cout << endl;
	cout << "**Veterinário**" << endl << endl;;
	out << "Id: " << v.getId() << endl;
	out << "Nome: " << v.getNome() << endl;
	out << "CPF: " << v.getCpf() << endl;
	out << "Idade: " << v.getIdade() << endl;
	out << "Tipo sanguineo: " << v.getTipo_sanguineo() << endl;
	out << "Fator RH: " << v.getFator_rh() << endl;
	out << "Especialidade: " << v.getEspecialidade() << endl;
	out << "CRMV: " << v.getCrmv() << endl;
	cout << endl;

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x26423(%rip), %r15     # 0x30fc8
movq %r15, %rdi
callq 0x3110
leaq 0x1881b(%rip), %rsi     # 0x233cf
movq %r15, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3110
leaq 0x186be(%rip), %rsi     # 0x23291
movq %rbx, %rdi
callq 0x31f0
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %r15, %rdi
movl %eax, %esi
callq 0x3360
movq %rax, %rdi
callq 0x3110
leaq 0x1869f(%rip), %rsi     # 0x2329e
movq %rbx, %rdi
callq 0x31f0
movq %rax, %r15
leaq 0x10(%r14), %rsi
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x3290
movq %r15, %rdi
movq %r12, %rsi
callq 0x31c0
movq %rax, %rdi
callq 0x3110
leaq -0x40(%rbp), %rdi
callq 0x3100
leaq 0x18b4c(%rip), %rsi     # 0x23789
movq %rbx, %rdi
callq 0x31f0
movq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0x31e0
movq %rax, %rdi
callq 0x3110
leaq 0x18780(%rip), %rsi     # 0x233e0
movq %rbx, %rdi
callq 0x31f0
movl 0x38(%r14), %esi
movq %rax, %rdi
callq 0x3360
movq %rax, %rdi
callq 0x3110
leaq 0x18765(%rip), %rsi     # 0x233e8
movq %rbx, %rdi
callq 0x31f0
movq %rax, %r15
leaq 0x40(%r14), %rsi
movq %r12, %rdi
callq 0x3290
movq %r15, %rdi
movq %r12, %rsi
callq 0x31c0
movq %rax, %rdi
callq 0x3110
leaq -0x40(%rbp), %rdi
callq 0x3100
leaq 0x1873c(%rip), %rsi     # 0x233f9
movq %rbx, %rdi
callq 0x31f0
movsbl 0x60(%r14), %esi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
callq 0x3110
leaq 0x18723(%rip), %rsi     # 0x23404
movq %rbx, %rdi
callq 0x31f0
movq %rax, %r15
leaq 0x68(%r14), %rsi
movq %r12, %rdi
callq 0x3290
movq %r15, %rdi
movq %r12, %rsi
callq 0x31c0
movq %rax, %rdi
callq 0x3110
leaq -0x40(%rbp), %rdi
callq 0x3100
leaq 0x186f9(%rip), %rsi     # 0x23414
movq %rbx, %rdi
callq 0x31f0
movq %rax, %r15
addq $0x88, %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x3290
movq %r15, %rdi
movq %r12, %rsi
callq 0x31c0
movq %rax, %rdi
callq 0x3110
leaq -0x40(%rbp), %rdi
callq 0x3100
movq 0x2626d(%rip), %rdi     # 0x30fc8
callq 0x3110
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xad76
jmp 0xad76
jmp 0xad76
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_corpo.cpp
// Function: TRATADOR::TRATADOR(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
TRATADOR::TRATADOR(int i, string n, long int c, int ida, string t, char f, string e, int nivel){
	id = i;
	nome = n;
	cpf = c;
	idade = ida;
	tipo_sanguineo = t;
	fator_rh = f;
	especialidade = e;
	nivel_seguranca = nivel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, -0x30(%rbp)
movl %r8d, %r15d
movq %rcx, %r12
movq %rdx, %r13
movl %esi, %r14d
movq %rdi, %rbx
callq 0xb37a
leaq 0x25b35(%rip), %rax     # 0x30ad0
movq %rax, (%rbx)
movl %r14d, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
movq %r13, %rsi
callq 0x3120
movq %r12, 0x30(%rbx)
movl %r15d, 0x38(%rbx)
leaq 0x40(%rbx), %rdi
movq -0x30(%rbp), %rsi
callq 0x3120
movq 0x18(%rbp), %rsi
movb 0x10(%rbp), %al
movb %al, 0x60(%rbx)
leaq 0x68(%rbx), %rdi
callq 0x3120
movl 0x20(%rbp), %eax
movl %eax, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x463e
movq %r14, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_corpo.cpp
// Function: operator<<(std::ostream&, TRATADOR&)
ostream& operator << (ostream &out, TRATADOR &t){
	cout << endl;
	cout << "**Tratador**" << endl << endl;
	out << "Id: " << t.getId() << endl;
	out << "Nome: " << t.getNome() << endl;
	out << "CPF: " << t.getCpf() << endl;
	out << "Idade: " << t.getIdade() << endl;
	out << "Tipo sanguineo: " << t.getTipo_sanguineo() << endl;
	out << "Fator RH: " << t.getFator_rh() << endl;
	out << "Especialidade: " << t.getEspecialidade() << endl;
	out << "Nivel de segurança: " << t.getNivel_seguranca() << endl;
	cout << endl;

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x25fab(%rip), %r15     # 0x30fc8
movq %r15, %rdi
callq 0x3110
leaq 0x183ef(%rip), %rsi     # 0x2341b
movq %r15, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3110
leaq 0x18246(%rip), %rsi     # 0x23291
movq %rbx, %rdi
callq 0x31f0
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq %r15, %rdi
movl %eax, %esi
callq 0x3360
movq %rax, %rdi
callq 0x3110
leaq 0x18227(%rip), %rsi     # 0x2329e
movq %rbx, %rdi
callq 0x31f0
movq %rax, %r15
leaq 0x10(%r14), %rsi
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x3290
movq %r15, %rdi
movq %r12, %rsi
callq 0x31c0
movq %rax, %rdi
callq 0x3110
leaq -0x40(%rbp), %rdi
callq 0x3100
leaq 0x186d4(%rip), %rsi     # 0x23789
movq %rbx, %rdi
callq 0x31f0
movq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0x31e0
movq %rax, %rdi
callq 0x3110
leaq 0x18308(%rip), %rsi     # 0x233e0
movq %rbx, %rdi
callq 0x31f0
movl 0x38(%r14), %esi
movq %rax, %rdi
callq 0x3360
movq %rax, %rdi
callq 0x3110
leaq 0x182ed(%rip), %rsi     # 0x233e8
movq %rbx, %rdi
callq 0x31f0
movq %rax, %r15
leaq 0x40(%r14), %rsi
movq %r12, %rdi
callq 0x3290
movq %r15, %rdi
movq %r12, %rsi
callq 0x31c0
movq %rax, %rdi
callq 0x3110
leaq -0x40(%rbp), %rdi
callq 0x3100
leaq 0x182c4(%rip), %rsi     # 0x233f9
movq %rbx, %rdi
callq 0x31f0
movsbl 0x60(%r14), %esi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
callq 0x3110
leaq 0x182ab(%rip), %rsi     # 0x23404
movq %rbx, %rdi
callq 0x31f0
movq %rax, %r15
leaq 0x68(%r14), %rsi
movq %r12, %rdi
callq 0x3290
movq %r15, %rdi
movq %r12, %rsi
callq 0x31c0
movq %rax, %rdi
callq 0x3110
leaq -0x40(%rbp), %rdi
callq 0x3100
leaq 0x18295(%rip), %rsi     # 0x23428
movq %rbx, %rdi
callq 0x31f0
movl 0x88(%r14), %esi
movq %rax, %rdi
callq 0x3360
movq %rax, %rdi
callq 0x3110
movq 0x25e0f(%rip), %rdi     # 0x30fc8
callq 0x3110
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb1d2
jmp 0xb1d2
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_pesquisar.cpp
// Function: imprimir_classe(std::map<int, ANFIBIO_NATIVO, std::less<int>, std::allocator<std::pair<int const, ANFIBIO_NATIVO>>>&, std::map<int, ANFIBIO_EXOTICO, std::less<int>, std::allocator<std::pair<int const, ANFIBIO_EXOTICO>>>&)
void imprimir_classe(map <int, ANFIBIO_NATIVO> &anfibios_nat, map <int, ANFIBIO_EXOTICO> &anfibios_ex){
	cout << endl;
	cout << "Anfíbios Nativos:" << endl;
	for(auto it = anfibios_nat.begin(); it != anfibios_nat.end(); it++){
		cout << it -> second;
	}
	cout << endl;
	cout << "Anfíbios Exóticos:" << endl;
	for(auto it = anfibios_ex.begin(); it != anfibios_ex.end(); it++){
		cout << it -> second;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x25a11(%rip), %r15     # 0x30fc8
movq %r15, %rdi
callq 0x3110
leaq 0x18023(%rip), %rsi     # 0x235e9
movq %r15, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq 0x18(%r14), %r12
addq $0x8, %r14
cmpq %r14, %r12
je 0xb5fd
leaq 0x28(%r12), %rsi
movq %r15, %rdi
callq 0x6c5a
movq %r12, %rdi
callq 0x3160
movq %rax, %r12
jmp 0xb5de
movq 0x259c4(%rip), %r14     # 0x30fc8
movq %r14, %rdi
callq 0x3110
leaq 0x17fe9(%rip), %rsi     # 0x235fc
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0xb649
leaq 0x28(%r15), %rsi
movq %r14, %rdi
callq 0x6fd7
movq %r15, %rdi
callq 0x3160
movq %rax, %r15
jmp 0xb62b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_pesquisar.cpp
// Function: imprimir_classe(std::map<int, MAMIFERO_NATIVO, std::less<int>, std::allocator<std::pair<int const, MAMIFERO_NATIVO>>>&, std::map<int, MAMIFERO_EXOTICO, std::less<int>, std::allocator<std::pair<int const, MAMIFERO_EXOTICO>>>&)
void imprimir_classe(map <int, MAMIFERO_NATIVO> &mamiferos_nat, map <int, MAMIFERO_EXOTICO> &mamiferos_ex){
	cout << endl;
	cout << "Mamiferos Nativos:" << endl;
	for(auto it = mamiferos_nat.begin(); it != mamiferos_nat.end(); it++){
		cout << it -> second;
	}
	cout << endl;
	cout << "Mamiferos Exóticos:" << endl;
	for(auto it = mamiferos_ex.begin(); it != mamiferos_ex.end(); it++){
		cout << it -> second;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2595e(%rip), %r15     # 0x30fc8
movq %r15, %rdi
callq 0x3110
leaq 0x17f98(%rip), %rsi     # 0x23611
movq %r15, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq 0x18(%r14), %r12
addq $0x8, %r14
cmpq %r14, %r12
je 0xb6b0
leaq 0x28(%r12), %rsi
movq %r15, %rdi
callq 0x7b9c
movq %r12, %rdi
callq 0x3160
movq %rax, %r12
jmp 0xb691
movq 0x25911(%rip), %r14     # 0x30fc8
movq %r14, %rdi
callq 0x3110
leaq 0x17f5e(%rip), %rsi     # 0x23624
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0xb6fc
leaq 0x28(%r15), %rsi
movq %r14, %rdi
callq 0x7f32
movq %r15, %rdi
callq 0x3160
movq %rax, %r15
jmp 0xb6de
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_pesquisar.cpp
// Function: imprimir_classe(std::map<int, REPTIL_NATIVO, std::less<int>, std::allocator<std::pair<int const, REPTIL_NATIVO>>>&, std::map<int, REPTIL_EXOTICO, std::less<int>, std::allocator<std::pair<int const, REPTIL_EXOTICO>>>&)
void imprimir_classe(map <int, REPTIL_NATIVO> &repteis_nat, map <int, REPTIL_EXOTICO> &repteis_ex){
	cout << endl;
	cout << "Répteis Nativos:" << endl;
	for(auto it = repteis_nat.begin(); it != repteis_nat.end(); it++){
		cout << it -> second;
	}
	cout << endl;
	cout << "Répteis Exóticos:" << endl;
	for(auto it = repteis_ex.begin(); it != repteis_ex.end(); it++){
		cout << it -> second;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x258ab(%rip), %r15     # 0x30fc8
movq %r15, %rdi
callq 0x3110
leaq 0x17f0d(%rip), %rsi     # 0x23639
movq %r15, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq 0x18(%r14), %r12
addq $0x8, %r14
cmpq %r14, %r12
je 0xb763
leaq 0x28(%r12), %rsi
movq %r15, %rdi
callq 0x8aec
movq %r12, %rdi
callq 0x3160
movq %rax, %r12
jmp 0xb744
movq 0x2585e(%rip), %r14     # 0x30fc8
movq %r14, %rdi
callq 0x3110
leaq 0x17ed2(%rip), %rsi     # 0x2364b
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0xb7af
leaq 0x28(%r15), %rsi
movq %r14, %rdi
callq 0x8ea9
movq %r15, %rdi
callq 0x3160
movq %rax, %r15
jmp 0xb791
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_pesquisar.cpp
// Function: imprimir_classe(std::map<int, AVE_NATIVO, std::less<int>, std::allocator<std::pair<int const, AVE_NATIVO>>>&, std::map<int, AVE_EXOTICO, std::less<int>, std::allocator<std::pair<int const, AVE_EXOTICO>>>&)
void imprimir_classe(map <int, AVE_NATIVO> &aves_nat, map <int, AVE_EXOTICO> &aves_ex){
	cout << endl;
	cout << "Aves Nativas:" << endl;
	for(auto it = aves_nat.begin(); it != aves_nat.end(); it++){
		cout << it -> second;
	}
	cout << endl;
	cout << "Aves Exóticas:" << endl;
	for(auto it = aves_ex.begin(); it != aves_ex.end(); it++){
		cout << it -> second;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x257f8(%rip), %r15     # 0x30fc8
movq %r15, %rdi
callq 0x3110
leaq 0x17e80(%rip), %rsi     # 0x2365f
movq %r15, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq 0x18(%r14), %r12
addq $0x8, %r14
cmpq %r14, %r12
je 0xb816
leaq 0x28(%r12), %rsi
movq %r15, %rdi
callq 0x9aad
movq %r12, %rdi
callq 0x3160
movq %rax, %r12
jmp 0xb7f7
movq 0x257ab(%rip), %r14     # 0x30fc8
movq %r14, %rdi
callq 0x3110
leaq 0x17e41(%rip), %rsi     # 0x2366d
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0xb862
leaq 0x28(%r15), %rsi
movq %r14, %rdi
callq 0x9e54
movq %r15, %rdi
callq 0x3160
movq %rax, %r15
jmp 0xb844
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_cadastrar.cpp
// Function: cadastrar_func(std::map<int, VETERINARIO, std::less<int>, std::allocator<std::pair<int const, VETERINARIO>>>&, std::map<int, TRATADOR, std::less<int>, std::allocator<std::pair<int const, TRATADOR>>>&)
void cadastrar_func(map <int, VETERINARIO> &vets, map <int, TRATADOR>  &tratadores){
	char tipo_func;
	char continuar = 'n';
	
	do{ // Enquanto o usuário quiser cadastrar (continuar != s), o programa roda. 
		cout << "Qual o tipo de funcionario a ser cadastrado? \n  v - Veterinário\n  t - Tratador" << endl;
		cin >> tipo_func;
		if(tipo_func != 'v' && tipo_func != 't'){
			cout << "Tipo de funcionario incorreto!! Tente novamente!\n" << endl;
			continuar = 's';
			continue;
		}
		else{
			if(tipo_func == 'v'){
				cadastrar(vets);
			}
			else{
				cadastrar(tratadores);
			}
		}
	}while (continuar == 's'); 	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movb $0x6e, %r14b
movq 0x2571d(%rip), %r15     # 0x30fc8
leaq 0x17dcb(%rip), %r12     # 0x2367d
movq 0x25727(%rip), %r13     # 0x30fe0
leaq -0x29(%rbp), %rbx
movq %r15, %rdi
movq %r12, %rsi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq %r13, %rdi
movq %rbx, %rsi
callq 0x3280
movb -0x29(%rbp), %al
movl %eax, %ecx
andb $-0x3, %cl
cmpb $0x74, %cl
jne 0xb8f7
cmpb $0x76, %al
jne 0xb913
movq -0x38(%rbp), %rdi
callq 0xb934
jmp 0xb91c
movq %r15, %rdi
leaq 0x17dcc(%rip), %rsi     # 0x236cd
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movb $0x73, %r14b
jmp 0xb91c
movq -0x40(%rbp), %rdi
callq 0xc2c7
cmpb $0x73, %r14b
movb $0x73, %r14b
je 0xb8bd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_editar.cpp
// Function: editar_func(std::map<int, VETERINARIO, std::less<int>, std::allocator<std::pair<int const, VETERINARIO>>>&, std::map<int, TRATADOR, std::less<int>, std::allocator<std::pair<int const, TRATADOR>>>&)
void editar_func(map <int, VETERINARIO> &vets, map <int, TRATADOR> &tratadores){
	char tipo_func;
	char continuar = 'n';
	
	do{ // Enquanto o usuário quiser editar (continuar != s), o programa roda. 
		cout << "Qual o tipo de funcionario a ser editado? \n -> v - Veterinário\n -> t - Tratador" << endl;
		cin >> tipo_func;
		if(tipo_func != 'v' && tipo_func != 't'){
			cout << "Tipo de funcionario incorreto!! Tente novamente!\n" << endl;
			continuar = 's';
			continue;
		}
		else{
			if(tipo_func == 'v'){
				editar(vets);
			}
			else{
				editar(tratadores);
			}
		}
		cout << "Deseja editar mais funcionarios? s - SIM n - NÃO" << endl;
		cin >> continuar;
	} while (continuar == 's'); // Parada.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
leaq -0x29(%rbp), %rax
movb $0x6e, (%rax)
movq 0x13911(%rip), %r12     # 0x30fc8
leaq 0x6beb(%rip), %r13      # 0x242a9
movq 0x1391b(%rip), %rbx     # 0x30fe0
leaq -0x2a(%rbp), %r14
leaq 0x5ffd(%rip), %r15      # 0x236cd
movq %r12, %rdi
movq %r13, %rsi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3280
movb -0x2a(%rbp), %al
movl %eax, %ecx
andb $-0x3, %cl
cmpb $0x74, %cl
jne 0x1d70a
cmpb $0x76, %al
jne 0x1d723
movq -0x38(%rbp), %rdi
callq 0x1d768
jmp 0x1d72c
movq %r12, %rdi
movq %r15, %rsi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movb $0x73, -0x29(%rbp)
jmp 0x1d6d0
movq -0x40(%rbp), %rdi
callq 0x1dbde
movq %r12, %rdi
leaq 0x6bc4(%rip), %rsi      # 0x242fa
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq %rbx, %rdi
leaq -0x29(%rbp), %rsi
callq 0x3280
cmpb $0x73, -0x29(%rbp)
je 0x1d6d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_remover.cpp
// Function: remover_funcionario(std::map<int, VETERINARIO, std::less<int>, std::allocator<std::pair<int const, VETERINARIO>>>&, std::map<int, TRATADOR, std::less<int>, std::allocator<std::pair<int const, TRATADOR>>>&)
void remover_funcionario(map <int, VETERINARIO> &vets, map <int, TRATADOR>  &tratadores){
	char tipo_func;
	char resp, op = 'n';

	do{  
		cout << "Qual funcionario deseja remover? \n v - veterinario\n t - tratador" << endl;
		cin >> tipo_func;
		if(tipo_func != 'v' && tipo_func != 't'){
			cout << "Opção inválida!! Tente novamente!\n" << endl;
			cout << endl;
			cout << "Deseja sair? s/n" << endl;
			cin >> resp;
			if(resp == 's'){
				break;
			}
		}
		else{
			if(tipo_func == 'v'){
				remover(vets); // Função remover sobrecarregada.
			}
			else{
				remover(tratadores);
			}
		} // Primeiro else.
	}while(op == 's');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x117b6(%rip), %rdi     # 0x30fc8
leaq 0x4c5b(%rip), %rsi      # 0x24474
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq 0x117b3(%rip), %rdi     # 0x30fe0
leaq -0x1a(%rbp), %r15
movq %r15, %rsi
callq 0x3280
movb (%r15), %al
movl %eax, %ecx
andb $-0x3, %cl
cmpb $0x74, %cl
jne 0x1f854
cmpb $0x76, %al
jne 0x1f8a3
movq %r14, %rdi
callq 0x1f8b6
jmp 0x1f8ab
movq 0x1176d(%rip), %rbx     # 0x30fc8
leaq 0x496f(%rip), %rsi      # 0x241d1
movq %rbx, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3110
leaq 0x3d57(%rip), %rsi      # 0x235d8
movq %rbx, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq 0x11748(%rip), %rdi     # 0x30fe0
leaq -0x19(%rbp), %rsi
callq 0x3280
jmp 0x1f8ab
movq %rbx, %rdi
callq 0x1fb31
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: check_CPF(std::map<int, VETERINARIO, std::less<int>, std::allocator<std::pair<int const, VETERINARIO>>>&, long)
bool check_CPF(map <int, VETERINARIO> &vets, long int cpf){
	int cont = 0;

	for(auto it = vets.begin(); it != vets.end();it++){
		if(it->second.getCpf() == cpf){
			cont++;
			break;
		}
	}
	return cont;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x20de4
leaq 0x28(%r15), %rdi
callq 0xaa32
cmpq %r14, %rax
je 0x20de4
movq %r15, %rdi
callq 0x3160
movq %rax, %r15
jmp 0x20dc4
cmpq %rbx, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: check_CPF(std::map<int, TRATADOR, std::less<int>, std::allocator<std::pair<int const, TRATADOR>>>&, long)
bool check_CPF(map <int, TRATADOR> &tratadores, long int cpf){
	int cont = 0;

	for(auto it = tratadores.begin(); it != tratadores.end();it++){
		if(it->second.getCpf() == cpf){
			cont++;
		}
	}
	return cont;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
xorl %r12d, %r12d
cmpq %r14, %r15
je 0x20e37
leaq 0x28(%r15), %rdi
callq 0xaa32
xorl %ecx, %ecx
cmpq %rbx, %rax
sete %cl
addl %ecx, %r12d
movq %r15, %rdi
callq 0x3160
movq %rax, %r15
jmp 0x20e11
testl %r12d, %r12d
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: check_vet(std::map<int, VETERINARIO, std::less<int>, std::allocator<std::pair<int const, VETERINARIO>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool check_vet(map <int, VETERINARIO> &vets, string nome){
	int cont = 0;

	for(auto it = vets.begin(); it != vets.end();it++){
		if(it->second.getNome() == nome){
			cont++;
			break;
		}
	}
	return cont;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %r15
addq $0x8, %rbx
leaq -0x48(%rbp), %r12
cmpq %rbx, %r15
je 0x20ea2
leaq 0x28(%r15), %rsi
movq %r12, %rdi
callq 0xaa16
movq %r12, %rdi
movq %r14, %rsi
callq 0x20d72
movl %eax, %r13d
movq %r12, %rdi
callq 0x3100
testb %r13b, %r13b
jne 0x20ea2
movq %r15, %rdi
callq 0x3160
movq %rax, %r15
jmp 0x20e69
cmpq %rbx, %r15
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_ID(std::map<int, VETERINARIO, std::less<int>, std::allocator<std::pair<int const, VETERINARIO>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_ID(map <int, VETERINARIO> &vets, string id_string, char &sucesso){
	int cont = 0, id, verificacao;
	char c;
	sucesso = 'n';
	for(int i = 0; i < (int)id_string.size(); i++){
		c = id_string[i];
		verificacao = isdigit(c);
		if(!verificacao){
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;
	}

	if(cont == (int) id_string.size()){
		stringstream ss(id_string);
		ss >> id;
		if(vets.empty()){
			sucesso = 's';
			return 1;
		}
		else{
			for(auto it = vets.begin(); it != vets.end();it++){
				if(it->second.getId() == id){
					sucesso = 'n';
					cout << "ERRO: id já cadastrado!" << endl << endl;
					return 0;				
				}
			}		
		}		
	}
	else{
		cout << "ERRO: valor inválido!" << endl << endl;
		return 0;
	}

	sucesso = 's';
	return 1;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %rbx
movq %rdi, %r14
movb $0x6e, (%rdx)
movl 0x8(%rsi), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rcx, %rdx
je 0x210cf
movq (%rsi), %rdi
movsbl (%rdi,%rcx), %edi
addl $-0x30, %edi
incq %rcx
cmpl $0xa, %edi
jb 0x210b6
jmp 0x21120
testl %eax, %eax
js 0x21120
leaq -0x1a8(%rbp), %r15
pushq $0x18
popq %rdx
movq %r15, %rdi
callq 0x3300
leaq -0x1c(%rbp), %rsi
movq %r15, %rdi
callq 0x3150
cmpq $0x0, 0x28(%r14)
je 0x21147
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x21158
leaq 0x28(%r15), %rdi
callq 0xaaba
cmpl -0x1c(%rbp), %eax
je 0x21177
movq %r15, %rdi
callq 0x3160
movq %rax, %r15
jmp 0x21100
movq 0xfea1(%rip), %rdi      # 0x30fc8
leaq 0x3515(%rip), %rsi      # 0x24643
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3110
xorl %eax, %eax
jmp 0x21169
movb $0x73, (%rbx)
leaq -0x1a8(%rbp), %rdi
callq 0x3170
jmp 0x21167
leaq -0x1a8(%rbp), %rdi
callq 0x3170
movb $0x73, (%rbx)
movb $0x1, %al
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x6e, (%rbx)
movq 0xfe47(%rip), %rdi      # 0x30fc8
leaq 0x34d2(%rip), %rsi      # 0x2465a
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3110
leaq -0x1a8(%rbp), %rdi
callq 0x3170
jmp 0x21143
jmp 0x211af
jmp 0x211af
movq %rax, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_ID(std::map<int, TRATADOR, std::less<int>, std::allocator<std::pair<int const, TRATADOR>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_ID(map <int, TRATADOR> &tratadores, string id_string, char &sucesso){
	int cont = 0, id, verificacao;
	char c;
	sucesso = 'n';
	for(int i = 0; i < (int)id_string.size(); i++){
		c = id_string[i];
		verificacao = isdigit(c);
		if(!verificacao){
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;
	}

	if(cont == (int) id_string.size()){
		stringstream ss(id_string);
		ss >> id;
		if(tratadores.empty()){
			sucesso = 's';
			return 1;
		}
		else{
			for(auto it = tratadores.begin(); it != tratadores.end();it++){
				if(it->second.getId() == id){
					sucesso = 'n';
					cout << "ERRO: id já cadastrado!" << endl << endl;
					return 0;				
				}
			}	
		}	
	}
	else{
		cout << "ERRO: valor inválido!" << endl << endl;
		return 0;
	}

	sucesso = 's';
	return 1;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %rbx
movq %rdi, %r14
movb $0x6e, (%rdx)
movl 0x8(%rsi), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rcx, %rdx
je 0x21207
movq (%rsi), %rdi
movsbl (%rdi,%rcx), %edi
addl $-0x30, %edi
incq %rcx
cmpl $0xa, %edi
jb 0x211ee
jmp 0x21258
testl %eax, %eax
js 0x21258
leaq -0x1a8(%rbp), %r15
pushq $0x18
popq %rdx
movq %r15, %rdi
callq 0x3300
leaq -0x1c(%rbp), %rsi
movq %r15, %rdi
callq 0x3150
cmpq $0x0, 0x28(%r14)
je 0x2127f
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x21290
leaq 0x28(%r15), %rdi
callq 0xaf64
cmpl -0x1c(%rbp), %eax
je 0x212af
movq %r15, %rdi
callq 0x3160
movq %rax, %r15
jmp 0x21238
movq 0xfd69(%rip), %rdi      # 0x30fc8
leaq 0x33dd(%rip), %rsi      # 0x24643
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3110
xorl %eax, %eax
jmp 0x212a1
movb $0x73, (%rbx)
leaq -0x1a8(%rbp), %rdi
callq 0x3170
jmp 0x2129f
leaq -0x1a8(%rbp), %rdi
callq 0x3170
movb $0x73, (%rbx)
movb $0x1, %al
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x6e, (%rbx)
movq 0xfd0f(%rip), %rdi      # 0x30fc8
leaq 0x339a(%rip), %rsi      # 0x2465a
callq 0x31f0
movq %rax, %rdi
callq 0x3110
movq %rax, %rdi
callq 0x3110
leaq -0x1a8(%rbp), %rdi
callq 0x3170
jmp 0x2127b
jmp 0x212e7
jmp 0x212e7
movq %rax, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3370