LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/Score.cpp
// Function: Score::getScore(ContingencyTable&)
double Score::getScore(ContingencyTable& t) {
  std::vector<double> less = t.getLess();
  std::vector<double> geq = t.getGeq();
  std::vector<double> sum = t.getSum();
  for (int i = 0 ; i < sum.size() ; i++) {
    sum[i] = less[i] + geq[i];
  }
  double ht = getShannonEntropy(t.totalLess(),t.totalGeq());
  double hc = getShannonEntropy(sum,t.total());
  double itc = getMutualInfo(less,
                             geq,
                             t.totalLess(),
                             t.totalGeq()); 
  return itc / ((hc + ht)/2);
  }

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
leaq 0x38(%rsp), %rdi
callq 0xc908
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0xc91a
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xc92c
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rax, %rcx
je 0x13076
sarq $0x3, %rcx
movq 0x38(%rsp), %rdx
movq 0x20(%rsp), %rsi
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm0
addsd (%rsi,%rdi,8), %xmm0
movsd %xmm0, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x1305f
movq %rbx, %rdi
callq 0xc8fc
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xc902
movapd %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x131d2
movsd %xmm0, 0x68(%rsp)
movq %rbx, %rdi
callq 0xc93e
leaq 0x8(%rsp), %rsi
callq 0x1326a
movsd %xmm0, 0x60(%rsp)
movq %rbx, %rdi
callq 0xc8fc
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xc902
movapd %xmm0, %xmm1
movsd (%rsp), %xmm0
movsd %xmm1, 0x50(%rsp)
callq 0x131d2
movsd %xmm0, 0x58(%rsp)
movsd (%rsp), %xmm0
addsd 0x50(%rsp), %xmm0
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x13362
movsd %xmm0, (%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1311c
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x13133
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1314a
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
movsd 0x58(%rsp), %xmm0
subsd (%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
addsd 0x60(%rsp), %xmm1
mulsd 0x2ea7(%rip), %xmm1     # 0x16010
divsd %xmm1, %xmm0
addq $0x70, %rsp
popq %rbx
retq
jmp 0x13181
movq %rax, %rbx
jmp 0x1319b
movq %rax, %rbx
jmp 0x131b2
jmp 0x13181
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1319b
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x131b2
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x131c9
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/ScoreInfo.cpp
// Function: ScoreInfo::update(int, double, double)
void ScoreInfo::update(int a,double t,double s) {
	if (score < s) {
		attribute = a;
		threshold = t;
		score = s;
	}
}

// Assembly:
ucomisd 0x28(%rdi), %xmm1
jbe 0x13508
movl %esi, 0x1c(%rdi)
movsd %xmm0, 0x20(%rdi)
movsd %xmm1, 0x28(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/ScoreInfo.cpp
// Function: ScoreInfo::update(ClassicTree*, double, double)
void ScoreInfo::update(ClassicTree *t, double th, double s) {
	if (score < s) {
		threshold = th;
		tree = t;
		score = s;
	} 
}

// Assembly:
ucomisd 0x28(%rdi), %xmm1
jbe 0x1351f
movsd %xmm0, 0x20(%rdi)
movq %rsi, 0x8(%rdi)
movsd %xmm1, 0x28(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/ScoreInfo.cpp
// Function: ScoreInfo::update(GStump*, double, double)
void ScoreInfo::update(GStump *t, double th, double s) { 
	if (score < s) {
		threshold = th;
		stump = t;
		score = s;
	} 
}

// Assembly:
ucomisd 0x28(%rdi), %xmm1
jbe 0x13535
movsd %xmm0, 0x20(%rdi)
movq %rsi, 0x10(%rdi)
movsd %xmm1, 0x28(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/0asa[P]TTree-source/ScoreInfo.cpp
// Function: ScoreInfo::update(Learner*, double, double)
void ScoreInfo::update(Learner* w, double th, double s) {
	if (score < s) {
		threshold = th;
		weak = w;
		score = s;
	}
}

// Assembly:
ucomisd 0x28(%rdi), %xmm1
jbe 0x1354a
movsd %xmm0, 0x20(%rdi)
movq %rsi, (%rdi)
movsd %xmm1, 0x28(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x134e0
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x13ac2
xorl %r13d, %r13d
movl (%rax,%r13,4), %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x13ad0
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x13a9a
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0xc280
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x13b5e
xorl %ebp, %ebp
leaq 0x30(%rsp), %r13
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 0xc578
incq %rbp
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbp, %rcx
ja 0x13b18
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc6fc
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
je 0x13be1
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 0xc596
movq 0x10(%rsp), %rax
movsd (%rax,%r15,8), %xmm0
movsd %xmm0, 0x28(%rsp)
leaq 0xc(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1300c
movaps %xmm0, %xmm1
movq %r14, %rdi
movl %ebx, %esi
movsd 0x28(%rsp), %xmm0
callq 0x134f4
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13bf3
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
leaq 0x30(%rsp), %rdi
callq 0xc430
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13c2d
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13c30
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
jmp 0x13c30
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc430
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/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 0x134e0
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x13c90
xorl %r13d, %r13d
movl (%rax,%r13,4), %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x13c9e
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x13c68
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0xc280
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x13d2d
xorl %r13d, %r13d
leaq 0x30(%rsp), %r12
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 0xc578
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x13ce7
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc6fc
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
je 0x13dab
xorl %r12d, %r12d
leaq 0x30(%rsp), %r14
leaq 0xc(%rsp), %r15
movsd (%rdi,%r12,8), %xmm0
movq %r14, %rdi
callq 0xc596
movq 0x10(%rsp), %rax
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, 0x28(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1300c
movaps %xmm0, %xmm1
movq %rbx, %rdi
movl %ebp, %esi
movsd 0x28(%rsp), %xmm0
callq 0x134f4
incq %r12
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x13d55
testq %rdi, %rdi
je 0x13dbd
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
leaq 0x30(%rsp), %rdi
callq 0xc430
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13ddb
movq %rax, %rbx
jmp 0x13dfa
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13dfa
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
leaq 0x30(%rsp), %rdi
callq 0xc430
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/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 0x134e0
leaq 0x30(%rsp), %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0xc280
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x13ea0
xorl %r13d, %r13d
leaq 0x30(%rsp), %r12
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 0xc578
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x13e5a
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc6fc
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
je 0x13f1e
xorl %r12d, %r12d
leaq 0x30(%rsp), %r14
leaq 0xc(%rsp), %r15
movsd (%rdi,%r12,8), %xmm0
movq %r14, %rdi
callq 0xc596
movq 0x10(%rsp), %rax
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, 0x28(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1300c
movaps %xmm0, %xmm1
movq %rbx, %rdi
movl %ebp, %esi
movsd 0x28(%rsp), %xmm0
callq 0x134f4
incq %r12
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x13ec8
testq %rdi, %rdi
je 0x13f30
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
leaq 0x30(%rsp), %rdi
callq 0xc430
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13f51
movq %rax, %rbx
jmp 0x13f70
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13f70
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
leaq 0x30(%rsp), %rdi
callq 0xc430
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x2, %esi
movl $0x2, %edx
callq 0xc280
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x14019
xorl %r12d, %r12d
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
xorps %xmm0, %xmm0
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 0x13ffb
movq %rbx, %rdi
callq 0xc62c
jmp 0x14003
movq %rbx, %rdi
callq 0xc64c
incq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x13fba
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xc430
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/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 0x134e0
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x1409a
xorl %r13d, %r13d
movl (%rax,%r13,4), %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x140a8
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x14072
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x134e0
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x1442a
xorl %r13d, %r13d
movl (%rax,%r13,4), %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x14438
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x14402
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x379ac(%rip), %r14     # 0x47fd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
leaq 0x29fff(%rip), %rsi     # 0x3a651
movl $0x12, %edx
movq %r14, %rdi
callq 0x3250
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq 0x18(%r15), %r12
addq $0x8, %r15
cmpq %r15, %r12
je 0x106b7
movq 0x37936(%rip), %r13     # 0x47fd0
leaq 0x28(%r12), %rsi
movq %r13, %rdi
callq 0x9ef0
movq %r12, %rdi
callq 0x3140
movq %rax, %r12
cmpq %r15, %rax
jne 0x1069a
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
leaq 0x29f7f(%rip), %rsi     # 0x3a664
movl $0x14, %edx
movq %r14, %rdi
callq 0x3250
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq 0x18(%rbx), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x10749
movq 0x378a3(%rip), %r15     # 0x47fd0
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0xa644
movq %r14, %rdi
callq 0x3140
movq %rax, %r14
cmpq %rbx, %rax
jne 0x1072d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x375b5(%rip), %r15     # 0x47fd0
leaq 0x29c9b(%rip), %r12     # 0x3a6bd
movq 0x375b7(%rip), %r13     # 0x47fe0
leaq -0x29(%rbp), %rbx
movl $0x4f, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3250
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %r13, %rdi
movq %rbx, %rsi
callq 0x3280
movb -0x29(%rbp), %al
movl %eax, %ecx
andb $-0x3, %cl
cmpb $0x74, %cl
jne 0x10a8b
cmpb $0x76, %al
jne 0x10acb
movq -0x38(%rbp), %rdi
callq 0x10af0
jmp 0x10ad4
movl $0x31, %edx
movq %r15, %rdi
leaq 0x29c73(%rip), %rsi     # 0x3a70d
callq 0x3250
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movb $0x73, %r14b
jmp 0x10ad4
movq -0x40(%rbp), %rdi
callq 0x11f9d
cmpb $0x73, %r14b
movb $0x73, %r14b
je 0x10a2d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16040(%rip), %r12     # 0x47fd0
leaq 0x9352(%rip), %r13      # 0x3b2e9
movq 0x16042(%rip), %rbx     # 0x47fe0
leaq -0x2a(%rbp), %r14
leaq 0x8764(%rip), %r15      # 0x3a70d
movl $0x50, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3250
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3280
movb -0x2a(%rbp), %al
movl %eax, %ecx
andb $-0x3, %cl
cmpb $0x74, %cl
jne 0x32008
cmpb $0x76, %al
jne 0x32049
movq -0x38(%rbp), %rdi
callq 0x320b3
jmp 0x32052
movl $0x31, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x3250
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movb $0x73, -0x29(%rbp)
jmp 0x31fa9
movq -0x40(%rbp), %rdi
callq 0x32944
movl $0x31, %edx
movq %r12, %rdi
leaq 0x92d9(%rip), %rsi      # 0x3b33a
callq 0x3250
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rbx, %rdi
leaq -0x29(%rbp), %rsi
callq 0x3280
cmpb $0x73, -0x29(%rbp)
je 0x31fa9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x13180(%rip), %rbx     # 0x47fd0
leaq 0x665d(%rip), %rsi      # 0x3b4b4
movl $0x40, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq 0x1314e(%rip), %rdi     # 0x47fe0
leaq -0x22(%rbp), %r12
movq %r12, %rsi
callq 0x3280
movb (%r12), %al
movl %eax, %ecx
andb $-0x3, %cl
cmpb $0x74, %cl
jne 0x34ec1
cmpb $0x76, %al
jne 0x34f70
movq %r15, %rdi
callq 0x34f85
jmp 0x34f78
leaq 0x6349(%rip), %rsi      # 0x3b211
movl $0x25, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
leaq 0x56ee(%rip), %rsi      # 0x3a618
movl $0x10, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq 0x1307b(%rip), %rdi     # 0x47fe0
leaq -0x21(%rbp), %rsi
callq 0x3280
jmp 0x34f78
movq %r14, %rdi
callq 0x35383
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x36cd2
movq %rsi, %rbx
leaq 0x28(%r15), %rdi
callq 0xf252
cmpq %rbx, %rax
sete %r12b
je 0x36cd5
movq %r15, %rdi
callq 0x3140
movq %rax, %r15
cmpq %r14, %rax
jne 0x36cae
jmp 0x36cd5
xorl %r12d, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %r15
movq 0x18(%rdi), %r12
addq $0x8, %r15
xorl %ebx, %ebx
cmpq %r15, %r12
je 0x36d2a
movq %rsi, %r14
leaq 0x28(%r12), %rdi
callq 0xf252
xorl %ecx, %ecx
cmpq %r14, %rax
sete %cl
addl %ecx, %ebx
movq %r12, %rdi
callq 0x3140
movq %rax, %r12
cmpq %r15, %rax
jne 0x36d01
testl %ebx, %ebx
setne %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x36dc0
movq %rsi, %rbx
leaq 0x28(%r15), %rsi
leaq -0x48(%rbp), %rdi
callq 0xf224
movq -0x40(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x36d8c
movq -0x48(%rbp), %r12
testq %rdx, %rdx
je 0x36d95
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x3230
testl %eax, %eax
sete %r13b
jmp 0x36d98
movq -0x48(%rbp), %r12
xorl %r13d, %r13d
jmp 0x36d98
movb $0x1, %r13b
leaq -0x38(%rbp), %rax
cmpq %rax, %r12
je 0x36da9
movq %r12, %rdi
callq 0x31d0
testb %r13b, %r13b
jne 0x36dc3
movq %r15, %rdi
callq 0x3140
movq %rax, %r15
cmpq %r14, %rax
jne 0x36d59
jmp 0x36dc3
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_seguranca(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_seguranca(string nivel_seg_string, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	for(int i = 0; i < (int)nivel_seg_string.size(); i++){
		c = nivel_seg_string[i];
		verificacao = isdigit(c);
		if(!verificacao || (nivel_seg_string != "0" && nivel_seg_string != "1" && nivel_seg_string != "2")){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;		
	}
	if(cont == (int) nivel_seg_string.size()){
		sucesso = 's';
		return 1;
	}
	else{
		cout << "ERRO: valor inválido 2!" << endl << endl;
		sucesso = 'n';
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movb $0x6e, (%rsi)
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x38111
movq %rdi, %r14
movq %r15, -0x30(%rbp)
xorl %ebx, %ebx
leaq 0x2196(%rip), %r15      # 0x3a248
leaq 0x2060(%rip), %r12      # 0x3a119
leaq 0x2928(%rip), %r13      # 0x3a9e8
movq (%r14), %rax
movsbl (%rax,%rbx), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x38126
movq %r14, %rdi
movq %r15, %rsi
callq 0x30c0
testl %eax, %eax
je 0x380fc
movq %r14, %rdi
movq %r12, %rsi
callq 0x30c0
testl %eax, %eax
je 0x380fc
movq %r14, %rdi
movq %r13, %rsi
callq 0x30c0
testl %eax, %eax
jne 0x38126
incq %rbx
movq 0x8(%r14), %rax
movslq %eax, %rcx
cmpq %rcx, %rbx
jl 0x380c0
movq -0x30(%rbp), %r15
jmp 0x38113
xorl %ebx, %ebx
cmpl %eax, %ebx
jne 0x3819b
movb $0x73, (%r15)
movb $0x1, %al
jmp 0x3820d
movq -0x30(%rbp), %rax
movb $0x6e, (%rax)
movq 0xfe9c(%rip), %rbx      # 0x47fd0
leaq 0x3548(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
jmp 0x3820b
movq 0xfe2e(%rip), %r14      # 0x47fd0
leaq 0x3521(%rip), %rsi      # 0x3b6ca
movl $0x18, %edx
movq %r14, %rdi
callq 0x3250
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movb $0x6e, (%r15)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_nome(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char&)
bool verifica_nome(string &nome, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	transform(nome.begin(), nome.end(), nome.begin(), ::toupper); // Converte a string nome para caracteres maiúsculos.
	for(int i = 0; i < (int)nome.size(); i++){
		c = nome[i];
		verificacao = isalpha(c);
		if(!verificacao && c != ' '){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;	
	}
	if(cont == (int) nome.size()){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb $0x6e, (%rsi)
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x38291
movq %rdi, %r14
movq (%rdi), %r12
xorl %r13d, %r13d
movsbl (%r12,%r13), %edi
callq 0x33d0
movb %al, (%r12,%r13)
incq %r13
cmpq %r13, %r15
jne 0x38242
movq 0x8(%r14), %r15
testl %r15d, %r15d
jle 0x3828f
movq (%r14), %r12
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movsbl (%r12,%r13), %r14d
movl %r14d, %edi
callq 0x3320
cmpl $0x20, %r14d
je 0x38285
testl %eax, %eax
je 0x38298
incq %r13
cmpq %r13, %r15
jne 0x3826e
jmp 0x38291
jne 0x38307
movb $0x73, (%rbx)
movb $0x1, %al
jmp 0x38309
movb $0x6e, (%rbx)
movq 0xfd2e(%rip), %rbx      # 0x47fd0
leaq 0x33da(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_nome_cient(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char&)
bool verifica_nome_cient(string &nome, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	transform(nome.begin(), nome.end(), nome.begin(), ::toupper); // Converte a string nome para caracteres maiúsculos.
	for(int i = 0; i < (int)nome.size(); i++){
		c = nome[i];
		verificacao = isalpha(c);
		if(!verificacao && c != ' ' && c !='-'){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;	
	}
	if(cont == (int) nome.size()){
		transform(nome.begin(), nome.end(), nome.begin(), ::tolower);
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x383d5
movq %rdi, %r13
movq (%rdi), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x33d0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x38345
movq %r12, -0x30(%rbp)
movq 0x8(%r13), %rbx
testl %ebx, %ebx
movq %r13, -0x38(%rbp)
jle 0x383a6
movq (%r13), %r13
movl %ebx, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movsbl (%r13,%r14), %r15d
movl %r15d, %edi
callq 0x3320
testl %eax, %eax
jne 0x3839c
movzbl %r15b, %eax
cmpl $0x20, %eax
je 0x3839c
cmpl $0x2d, %eax
jne 0x383de
incq %r14
cmpq %r14, %r12
jne 0x3837c
jmp 0x383ac
jne 0x38451
testq %rbx, %rbx
movq -0x30(%rbp), %r12
movq -0x38(%rbp), %rax
je 0x383d5
movq (%rax), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x32c0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x383bf
movb $0x73, (%r12)
movb $0x1, %al
jmp 0x38453
movq -0x30(%rbp), %rax
movb $0x6e, (%rax)
movq 0xfbe4(%rip), %rbx      # 0x47fd0
leaq 0x3290(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_CPF(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_CPF(string cpf_string, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	for(int i = 0; i < (int)cpf_string.size(); i++){
		c = cpf_string[i];
		verificacao = isdigit(c);
		if(!verificacao){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;	
	}

	if(cont == (int) cpf_string.size()){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rax
testl %eax, %eax
jle 0x38493
movq (%rdi), %rcx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
movsbl (%rcx,%rdx), %edi
addl $-0x30, %edi
cmpl $0xa, %edi
jae 0x3849c
incq %rdx
cmpq %rdx, %rax
jne 0x3847d
jmp 0x38495
jne 0x38508
movb $0x73, (%rsi)
movb $0x1, %al
jmp 0x3850a
movq 0xfb2d(%rip), %rbx      # 0x47fd0
leaq 0x31d9(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_idade(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_idade(string idade_string, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	for(int i = 0; i < (int)idade_string.size(); i++){
		c = idade_string[i];
		verificacao = isdigit(c);
		if(!verificacao){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;
	}

	if(cont == (int) idade_string.size()){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rax
testl %eax, %eax
jle 0x38542
movq (%rdi), %rcx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
movsbl (%rcx,%rdx), %edi
addl $-0x30, %edi
cmpl $0xa, %edi
jae 0x3854b
incq %rdx
cmpq %rdx, %rax
jne 0x3852c
jmp 0x38544
jne 0x385b7
movb $0x73, (%rsi)
movb $0x1, %al
jmp 0x385b9
movq 0xfa7e(%rip), %rbx      # 0x47fd0
leaq 0x312a(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_inteiro(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_inteiro(string total_mudas_string, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	for(int i = 0; i < (int)total_mudas_string.size(); i++){
		c = total_mudas_string[i];
		verificacao = isdigit(c);
		if(!verificacao){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;	
	}

	if(cont == (int) total_mudas_string.size()){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rax
testl %eax, %eax
jle 0x385f1
movq (%rdi), %rcx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
movsbl (%rcx,%rdx), %edi
addl $-0x30, %edi
cmpl $0xa, %edi
jae 0x385fa
incq %rdx
cmpq %rdx, %rax
jne 0x385db
jmp 0x385f3
jne 0x38666
movb $0x73, (%rsi)
movb $0x1, %al
jmp 0x38668
movq 0xf9cf(%rip), %rbx      # 0x47fd0
leaq 0x307b(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_tipo_sang(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char&)
bool verifica_tipo_sang(string &tipo_sang_string, char &sucesso){
	int cont = 0, cont_sangue = 0, verificacao;
	char c;
	sucesso = 'n';
	transform(tipo_sang_string.begin(), tipo_sang_string.end(), tipo_sang_string.begin(), ::toupper); // Converte a string nome para caracteres maiúsculos.
	for(int i = 0; i < (int)tipo_sang_string.size(); i++){
		c = tipo_sang_string[i];
		verificacao = isalpha(c);
		cont_sangue++;
		if(!verificacao || cont_sangue > 2 || (tipo_sang_string != "O" && tipo_sang_string != "AB" && tipo_sang_string != "B" && tipo_sang_string != "A")){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;
	}

	if(cont == (int)tipo_sang_string.size()){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb $0x6e, (%rsi)
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x38739
movq %rdi, %r14
movq (%rdi), %r12
xorl %r13d, %r13d
movsbl (%r12,%r13), %edi
callq 0x33d0
movb %al, (%r12,%r13)
incq %r13
cmpq %r13, %r15
jne 0x38699
movl 0x8(%r14), %eax
xorl %r13d, %r13d
testl %eax, %eax
jle 0x38734
leaq 0x2ba4(%rip), %r15      # 0x3b265
leaq 0x301b(%rip), %r12      # 0x3b6e3
movq (%r14), %rax
movsbl (%rax,%r13), %edi
callq 0x3320
testl %eax, %eax
je 0x38740
movl %r13d, %eax
andl $-0x2, %eax
jne 0x38740
movq %r14, %rdi
movq %r15, %rsi
callq 0x30c0
testl %eax, %eax
je 0x38725
movq %r14, %rdi
movq %r12, %rsi
callq 0x30c0
testl %eax, %eax
je 0x38725
movq %r14, %rdi
leaq 0x2fdb(%rip), %rsi      # 0x3b6e4
callq 0x30c0
testl %eax, %eax
je 0x38725
movq %r14, %rdi
leaq 0x2a43(%rip), %rsi      # 0x3b15f
callq 0x30c0
testl %eax, %eax
jne 0x38740
incq %r13
movq 0x8(%r14), %rax
movslq %eax, %rcx
cmpq %rcx, %r13
jl 0x386c8
cmpl %eax, %r13d
jne 0x387af
movb $0x73, (%rbx)
movb $0x1, %al
jmp 0x387b1
movb $0x6e, (%rbx)
movq 0xf886(%rip), %rbx      # 0x47fd0
leaq 0x2f32(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_fator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_fator(string fator_rh_string, char &sucesso){
	int cont = 0, cont_carac = 0;
	char c;
	sucesso = 'n';

	for(int i = 0; i < (int) fator_rh_string.size(); i++){
		c = fator_rh_string[i];
		cont_carac++;
		if((c != '-' && c != '+') || cont_carac > 1){
			cont--;
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;	
	}

	if(cont == (int)fator_rh_string.size()){
		sucesso = 's';
		return 1;
	}
	else return 0;
}

// Assembly:
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rax
testl %eax, %eax
jle 0x38868
movq (%rdi), %rcx
movzbl (%rcx), %ecx
cmpl $0x2b, %ecx
je 0x387df
cmpl $0x2d, %ecx
jne 0x387ed
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0x1, %eax
je 0x3886d
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xf7d6(%rip), %rbx      # 0x47fd0
leaq 0x2e82(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
je 0x3886d
xorl %eax, %eax
retq
movb $0x73, (%rsi)
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/nataly-enne[P]pet-fera/pet_fera_checagem.cpp
// Function: verifica_especialidade(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char&)
bool verifica_especialidade(string especialidade, char &sucesso){
	int cont = 0, verificacao;
	char c;
	sucesso = 'n';
	transform(especialidade.begin(), especialidade.end(), especialidade.begin(), ::toupper);
	for(int i = 0; i < (int) especialidade.size(); i++){
		c = especialidade[i];
		verificacao = isalpha(c);
		if(!verificacao && c != ' '){
			sucesso = 'n';
			cout << "ERRO: valor inválido!" << endl << endl;
			return 0;
		}
		else cont++;	
	}

	if(cont == (int)especialidade.size()){
		sucesso = 's';
		return 1;
	}
	else{
		sucesso = 'n';
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb $0x6e, (%rsi)
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x388ed
movq %rdi, %r14
movq (%rdi), %r12
xorl %r13d, %r13d
movsbl (%r12,%r13), %edi
callq 0x33d0
movb %al, (%r12,%r13)
incq %r13
cmpq %r13, %r15
jne 0x38899
movq 0x8(%r14), %r15
testl %r15d, %r15d
jle 0x388e6
movq (%r14), %r12
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movsbl (%r12,%r13), %r14d
movl %r14d, %edi
callq 0x3320
cmpl $0x20, %r14d
je 0x388dc
testl %eax, %eax
je 0x388f4
incq %r13
cmpq %r13, %r15
jne 0x388c5
jmp 0x388ed
je 0x388ed
movb $0x6e, (%rbx)
jmp 0x38963
movb $0x73, (%rbx)
movb $0x1, %al
jmp 0x38965
movb $0x6e, (%rbx)
movq 0xf6d2(%rip), %rbx      # 0x47fd0
leaq 0x2d7e(%rip), %rsi      # 0x3b683
movl $0x16, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq