LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 0asa[P]TTree-source/Result.cpp
// Function: Result::aggregate(std::vector<Result, std::allocator<Result>>&)
void Result::aggregate(std::vector<Result> &vr) {
	for (int i = 1 ; i < vr.size() ; ++i)
		for (int p = 0 ; p < vr[0].prob.getSize() ; ++p)
			vr[0].prob.probas[p] += vr[i].prob.probas[p];
	
	for (int p = 0 ; p < vr[0].prob.getSize() ; ++p)
		vr[0].prob.probas[p] /= vr.size();
	
	prob = vr[0].prob;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x1, 0x44(%rsp)
movslq 0x44(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1b740
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x250fa
movl $0x0, 0x40(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25220
movq %rax, %rdi
addq $0x8, %rdi
callq 0x223c0
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jae 0x250e8
movq 0x48(%rsp), %rdi
movslq 0x44(%rsp), %rsi
callq 0x25220
movq %rax, %rdi
addq $0x8, %rdi
addq $0x38, %rdi
movslq 0x40(%rsp), %rsi
callq 0xcda0
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25220
movq %rax, %rdi
addq $0x8, %rdi
addq $0x38, %rdi
movslq 0x40(%rsp), %rsi
callq 0xcda0
movsd 0x18(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x2504d
jmp 0x250ea
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x25020
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25220
movq %rax, %rdi
addq $0x8, %rdi
callq 0x223c0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jae 0x251aa
movq 0x48(%rsp), %rdi
callq 0x1b740
movq %rax, %xmm0
movaps 0xb60c(%rip), %xmm1     # 0x30750
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xb610(%rip), %xmm1     # 0x30760
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25220
movq %rax, %rdi
addq $0x8, %rdi
addq $0x38, %rdi
movslq 0x3c(%rsp), %rsi
callq 0xcda0
movsd 0x8(%rsp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x25102
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25220
movq 0x30(%rsp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x9090
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0xe8(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
callq 0x17690
movq 0xe8(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
callq 0x176c0
jmp 0x264e0
movq 0xe8(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x176f0
jmp 0x264f7
movl $0x0, 0x8c(%rsp)
movslq 0x8c(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xab40
movq %rax, %rcx
movq 0x60(%rsp), %rax
cmpq %rcx, %rax
jae 0x265d8
movslq 0x8c(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
callq 0xcda0
movsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movslq 0x8c(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
callq 0xcda0
movsd 0x50(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, 0x58(%rsp)
movslq 0x8c(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0xcda0
movsd 0x58(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x26502
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x26762
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x26755
movq 0xe8(%rsp), %rdi
callq 0x17670
movsd %xmm0, 0x48(%rsp)
jmp 0x265ed
movq 0xe8(%rsp), %rdi
callq 0x17680
movsd %xmm0, 0x40(%rsp)
jmp 0x26602
movsd 0x40(%rsp), %xmm1
movsd 0x48(%rsp), %xmm0
movq 0x68(%rsp), %rdi
callq 0x26780
movsd %xmm0, 0x38(%rsp)
jmp 0x26620
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x80(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x17720
movsd %xmm0, 0x30(%rsp)
jmp 0x26644
movsd 0x30(%rsp), %xmm0
movq 0x68(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x26800
movsd %xmm0, 0x28(%rsp)
jmp 0x26664
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x78(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x17670
movsd %xmm0, 0x20(%rsp)
jmp 0x26685
movq 0xe8(%rsp), %rdi
callq 0x17680
movsd %xmm0, 0x18(%rsp)
jmp 0x2669a
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
movq 0x68(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
leaq 0xb8(%rsp), %rdx
callq 0x268b0
movsd %xmm0, 0x10(%rsp)
jmp 0x266c8
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x70(%rsp)
movsd 0x70(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
addsd 0x80(%rsp), %xmm1
movsd 0xa4c7(%rip), %xmm2     # 0x30bb8
divsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xcaa0
leaq 0xb8(%rsp), %rdi
callq 0xcaa0
leaq 0xd0(%rsp), %rdi
callq 0xcaa0
movsd 0x8(%rsp), %xmm0
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xcaa0
leaq 0xb8(%rsp), %rdi
callq 0xcaa0
leaq 0xd0(%rsp), %rdi
callq 0xcaa0
movq 0xb0(%rsp), %rdi
callq 0x33e0
nopl (%rax)
// File: 0asa[P]TTree-source/Score.cpp
// Function: Score::getShannonEntropy(std::vector<double, std::allocator<double>>&, double)
double Score::getShannonEntropy(std::vector<double> &v, double total) {
  double entropy = 0;
  for (int i = 0; i < v.size() ; ++i) {
    double p =  v[i] / total;
    entropy += getShannonTerm(p);
  }
  return entropy;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movslq 0x24(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xab40
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x26898
movq 0x38(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xcda0
movq 0x10(%rsp), %rdi
movsd (%rax), %xmm0
divsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x26b20
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2682f
movsd 0x28(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 0asa[P]TTree-source/Score.cpp
// Function: Score::getCondShannonEntropy(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, double)
double Score::getCondShannonEntropy(std::vector<double> &less,
                                    std::vector<double> &geq,
                                    double total) {
  double  entropy = 0;
  for (int i = 0; i < less.size() ; ++i) {
    entropy += getShannonEntropy(less[i],geq[i]) * 
      ((double) (less[i] + geq[i]) / total);
  }
  return entropy;  
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movslq 0x2c(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0xab40
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x26a2b
movq 0x48(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xcda0
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xcda0
movq 0x20(%rsp), %rdi
movsd (%rsp), %xmm0
movsd (%rax), %xmm1
callq 0x26780
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xcda0
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xcda0
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm0
addsd (%rax), %xmm2
divsd 0x38(%rsp), %xmm2
movsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x26964
movsd 0x30(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movsd %xmm0, -0x18(%rsp)
movsd %xmm1, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movsd 0x28(%rax), %xmm1
movsd -0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x26c32
movq -0x28(%rsp), %rax
movl -0xc(%rsp), %ecx
movl %ecx, 0x1c(%rax)
movsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd -0x20(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
retq
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movsd %xmm0, -0x18(%rsp)
movsd %xmm1, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movsd 0x28(%rax), %xmm1
movsd -0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x26c95
movq -0x28(%rsp), %rax
movsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movsd -0x20(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
retq
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movsd %xmm0, -0x18(%rsp)
movsd %xmm1, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movsd 0x28(%rax), %xmm1
movsd -0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x26cf5
movq -0x28(%rsp), %rax
movsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movsd -0x20(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
retq
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movsd %xmm0, -0x18(%rsp)
movsd %xmm1, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movsd 0x28(%rax), %xmm1
movsd -0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x26d54
movq -0x28(%rsp), %rax
movsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rsp), %rcx
movq %rcx, (%rax)
movsd -0x20(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0x47(%rsp)
callq 0x26ba0
movl $0x0, 0x40(%rsp)
movslq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x8bf0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x2768c
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0xcd80
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rcx
movl (%rax), %edx
callq 0x276c0
jmp 0x27663
jmp 0x27665
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x27611
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x12640
jmp 0x276ac
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x276a2
movq 0x18(%rsp), %rdi
callq 0x12640
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0x47(%rsp)
callq 0x26ba0
movl $0x0, 0x40(%rsp)
movslq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x8bf0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x27abc
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0xcd80
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rcx
movl (%rax), %edx
callq 0x27af0
jmp 0x27a93
jmp 0x27a95
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x27a41
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x12640
jmp 0x27adc
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x27ad2
movq 0x18(%rsp), %rdi
callq 0x12640
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0x60(%rsp)
movq %rdi, %rax
movq %rax, 0x68(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movl %ecx, 0x9c(%rsp)
movsd %xmm0, 0x90(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x70(%rsp)
movb $0x0, 0x8f(%rsp)
movl $0x2, %edx
movl %edx, %esi
callq 0x16b40
movl $0x0, 0x88(%rsp)
movslq 0x88(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x8bf0
movq %rax, %rcx
movq 0x58(%rsp), %rax
cmpq %rcx, %rax
jae 0x283e1
movq 0x70(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0xa0(%rsp), %rdi
movslq 0x88(%rsp), %rsi
callq 0xcd80
movq 0x48(%rsp), %rdi
movl (%rax), %esi
movl 0x9c(%rsp), %edx
callq 0x16a20
movw %ax, 0x56(%rsp)
jmp 0x2826f
movw 0x56(%rsp), %ax
cwtl
cvtsi2sd %eax, %xmm0
ucomisd 0x90(%rsp), %xmm0
jbe 0x2833a
movq 0x70(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0xa0(%rsp), %rdi
movslq 0x88(%rsp), %rsi
callq 0xcd80
movq 0x38(%rsp), %rdi
movl (%rax), %esi
callq 0xcdc0
movw %ax, 0x46(%rsp)
jmp 0x282bd
movq 0x70(%rsp), %rax
movw 0x46(%rsp), %cx
movswl %cx, %ecx
movl %ecx, 0x24(%rsp)
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0xa0(%rsp), %rdi
movslq 0x88(%rsp), %rsi
callq 0xcd80
movq 0x28(%rsp), %rdi
movl (%rax), %esi
callq 0xcd50
movsd %xmm0, 0x30(%rsp)
jmp 0x282ff
movsd 0x30(%rsp), %xmm0
movl 0x24(%rsp), %esi
movq 0x60(%rsp), %rdi
callq 0x17090
jmp 0x28315
jmp 0x283c9
movq 0x60(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
callq 0x16d70
jmp 0x2840a
movq 0x70(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0xa0(%rsp), %rdi
movslq 0x88(%rsp), %rsi
callq 0xcd80
movq 0x18(%rsp), %rdi
movl (%rax), %esi
callq 0xcdc0
movw %ax, 0x22(%rsp)
jmp 0x2836f
movq 0x70(%rsp), %rax
movw 0x22(%rsp), %cx
movswl %cx, %ecx
movl %ecx, 0x4(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0xa0(%rsp), %rdi
movslq 0x88(%rsp), %rsi
callq 0xcd80
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0xcd50
movsd %xmm0, 0x10(%rsp)
jmp 0x283b1
movsd 0x10(%rsp), %xmm0
movl 0x4(%rsp), %esi
movq 0x60(%rsp), %rdi
callq 0x170f0
jmp 0x283c7
jmp 0x283c9
jmp 0x283cb
movl 0x88(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x88(%rsp)
jmp 0x28208
movb $0x1, 0x8f(%rsp)
testb $0x1, 0x8f(%rsp)
jne 0x283fd
movq 0x60(%rsp), %rdi
callq 0x16d70
movq 0x68(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x33e0
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0x47(%rsp)
callq 0x26ba0
movl $0x0, 0x40(%rsp)
movslq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x8bf0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x284fc
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0xcd80
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rcx
movl (%rax), %edx
callq 0x28530
jmp 0x284d3
jmp 0x284d5
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x28481
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x12640
jmp 0x2851c
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x28512
movq 0x18(%rsp), %rdi
callq 0x12640
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0x47(%rsp)
callq 0x26ba0
movl $0x0, 0x40(%rsp)
movslq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x8bf0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x28c6c
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0xcd80
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rcx
movl (%rax), %edx
callq 0x28ca0
jmp 0x28c43
jmp 0x28c45
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x28bf1
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x12640
jmp 0x28c8c
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x28c82
movq 0x18(%rsp), %rdi
callq 0x12640
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: 0asa[P]TTree-source/./Scorer.h
// Function: Scorer::setBestScoreFonction(unsigned int)
void setBestScoreFonction(unsigned int type = NUMERICAL) {
		if (type == NUMERICAL) 
			bestScoreFonction = &Scorer::getBestNumericalScore;
		else if (type == SNP) 
			bestScoreFonction = &Scorer::getBestSNPScore;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpl $0x0, -0xc(%rsp)
jne 0x29344
movq -0x18(%rsp), %rax
leaq -0x786(%rip), %rcx      # 0x28bb0
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
jmp 0x29365
cmpl $0x1, -0xc(%rsp)
jne 0x29363
movq -0x18(%rsp), %rax
leaq -0x1957(%rip), %rcx     # 0x27a00
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
jmp 0x29365
retq
nopw %cs:(%rax,%rax)
// File: 0asa[P]TTree-source/./Scorer.h
// Function: Scorer::setRandScoreFonction(unsigned int)
void setRandScoreFonction(unsigned int type = NUMERICAL) {
		if (type == NUMERICAL) 
			randScoreFonction = &Scorer::getRandNumericalScore;
		else if (type == SNP) 
			randScoreFonction = &Scorer::getRandSNPScore;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpl $0x0, -0xc(%rsp)
jne 0x293b4
movq -0x18(%rsp), %rax
leaq -0xf66(%rip), %rcx      # 0x28440
movq %rcx, 0x18(%rax)
movq $0x0, 0x20(%rax)
jmp 0x293d5
cmpl $0x1, -0xc(%rsp)
jne 0x293d3
movq -0x18(%rsp), %rax
leaq -0x1df7(%rip), %rcx     # 0x275d0
movq %rcx, 0x18(%rax)
movq $0x0, 0x20(%rax)
jmp 0x293d5
retq
nopw %cs:(%rax,%rax)
// File: 0asa[P]TTree-source/SimpleNodeTest.cpp
// Function: SimpleNodeTest::test(double)
bool SimpleNodeTest::test(double v) { 
	if (v>=th) 
		return true; 
	else
		return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movsd %xmm0, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsd -0x18(%rsp), %xmm0
ucomisd 0x10(%rax), %xmm0
jb 0x2d654
movb $0x1, -0x1(%rsp)
jmp 0x2d659
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
// File: 0asa[P]TTree-source/TreeNodeTest.cpp
// Function: TreeNodeTest::test(double)
bool TreeNodeTest::test(double v) {	
	Result r = weak->test((unsigned int) v);
	if (r.prob.getProb(0)>=th)
		return true; 
	else
		return false;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movsd %xmm0, 0x80(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rax), %rsi
cvttsd2si 0x80(%rsp), %rax
movl %eax, %edx
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq 0x28(%rsp), %rdi
callq *%rax
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x224f0
movsd %xmm0, 0x10(%rsp)
jmp 0x2db47
movsd 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rax
ucomisd 0x8(%rax), %xmm0
jb 0x2db85
movb $0x1, 0x97(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x2db95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x24b00
jmp 0x2dbb0
movb $0x0, 0x97(%rsp)
movl $0x1, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x24b00
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x33e0
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x132a3(%rip), %rax     # 0x40fd8
movq (%rax), %rdi
leaq 0x28d5(%rip), %rsi      # 0x30614
movb $0x0, %al
callq 0x3360
movq 0x1328b(%rip), %rax     # 0x40fd8
movq (%rax), %rdi
leaq 0x2ec9(%rip), %rsi      # 0x30c20
movb $0x0, %al
callq 0x3360
movq 0x13273(%rip), %rax     # 0x40fd8
movq (%rax), %rdi
leaq 0x2ee0(%rip), %rsi      # 0x30c4f
movb $0x0, %al
callq 0x3360
movq 0x1325b(%rip), %rax     # 0x40fd8
movq (%rax), %rdi
leaq 0x288d(%rip), %rsi      # 0x30614
movb $0x0, %al
callq 0x3360
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0xcb20
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x2e56e
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xcb00
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21c70
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xcb00
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21c90
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xcb00
movq (%rax), %rdi
callq 0x21af0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x2e521
movq 0x10(%rsp), %rdi
callq 0x219d0
movq 0x10(%rsp), %rdi
movl $0x60, %esi
callq 0x3280
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xcb00
movq (%rax), %rdi
callq 0x21b00
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2e55c
movq 0x8(%rsp), %rdi
callq 0x219d0
movq 0x8(%rsp), %rdi
movl $0x60, %esi
callq 0x3280
jmp 0x2e55e
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2e48b
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %r9, -0x70(%rbp)
movq %rdx, -0x48(%rbp)
movq 0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x13410
movq -0x50(%rbp), %rdi
leaq 0x3e48e(%rip), %rax     # 0x50aa0
movq %rax, (%rdi)
addq $0x88, %rdi
movq %rdi, -0x58(%rbp)
callq 0x3300
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, 0x8(%rdi)
addq $0x10, %rdi
callq 0x3030
jmp 0x1263e
movq -0x70(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, 0x30(%rdi)
movl -0x24(%rbp), %eax
movl %eax, 0x38(%rdi)
addq $0x40, %rdi
callq 0x3030
jmp 0x1265f
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rdi
movb 0x10(%rbp), %al
movb %al, 0x60(%rdi)
addq $0x68, %rdi
callq 0x3030
jmp 0x12678
movq -0x68(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x88, %rdi
callq 0x3030
jmp 0x1268e
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x3180
movq -0x50(%rbp), %rdi
callq 0x57b0
movq -0x38(%rbp), %rdi
callq 0x33d0
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %r9, -0x60(%rbp)
movq %rdx, -0x48(%rbp)
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x13410
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq 0x3dd07(%rip), %rax     # 0x50ab8
movq %rax, (%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x8(%rdi)
addq $0x10, %rdi
callq 0x3030
jmp 0x12dc5
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, 0x30(%rdi)
movl -0x24(%rbp), %eax
movl %eax, 0x38(%rdi)
addq $0x40, %rdi
callq 0x3030
jmp 0x12de6
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
movb 0x10(%rbp), %al
movb %al, 0x60(%rdi)
addq $0x68, %rdi
callq 0x3030
jmp 0x12dff
movq -0x50(%rbp), %rax
movl 0x20(%rbp), %ecx
movl %ecx, 0x88(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x57b0
movq -0x38(%rbp), %rdi
callq 0x33d0
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3d841(%rip), %rdi     # 0x50fb8
movq 0x3d822(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x3d82e(%rip), %rdi     # 0x50fb8
leaq 0x2de58(%rip), %rsi     # 0x415e9
callq 0x3240
movq %rax, %rdi
movq 0x3d800(%rip), %rsi     # 0x50fa0
callq 0x3280
movq -0x8(%rbp), %rdi
callq 0x13cb0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13d10
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x13ce0
testb $0x1, %al
jne 0x137d2
jmp 0x137ff
leaq -0x18(%rbp), %rdi
callq 0x13d40
movq %rax, %rsi
addq $0x8, %rsi
movq 0x3d7cf(%rip), %rdi     # 0x50fb8
callq 0xbab0
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x13d70
movq %rax, -0x28(%rbp)
jmp 0x137b2
movq 0x3d7b2(%rip), %rdi     # 0x50fb8
movq 0x3d793(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x3d79f(%rip), %rdi     # 0x50fb8
leaq 0x2dddc(%rip), %rsi     # 0x415fc
callq 0x3240
movq %rax, %rdi
movq 0x3d771(%rip), %rsi     # 0x50fa0
callq 0x3280
movq -0x10(%rbp), %rdi
callq 0x13db0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13e10
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13de0
testb $0x1, %al
jne 0x13861
jmp 0x1388e
leaq -0x30(%rbp), %rdi
callq 0x13e40
movq %rax, %rsi
addq $0x8, %rsi
movq 0x3d740(%rip), %rdi     # 0x50fb8
callq 0xc180
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x13e70
movq %rax, -0x40(%rbp)
jmp 0x13841
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3d701(%rip), %rdi     # 0x50fb8
movq 0x3d6e2(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x3d6ee(%rip), %rdi     # 0x50fb8
leaq 0x2dd40(%rip), %rsi     # 0x41611
callq 0x3240
movq %rax, %rdi
movq 0x3d6c0(%rip), %rsi     # 0x50fa0
callq 0x3280
movq -0x8(%rbp), %rdi
callq 0x13eb0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13f10
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x13ee0
testb $0x1, %al
jne 0x13912
jmp 0x1393f
leaq -0x18(%rbp), %rdi
callq 0x13f40
movq %rax, %rsi
addq $0x8, %rsi
movq 0x3d68f(%rip), %rdi     # 0x50fb8
callq 0xd480
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x13f70
movq %rax, -0x28(%rbp)
jmp 0x138f2
movq 0x3d672(%rip), %rdi     # 0x50fb8
movq 0x3d653(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x3d65f(%rip), %rdi     # 0x50fb8
leaq 0x2dcc4(%rip), %rsi     # 0x41624
callq 0x3240
movq %rax, %rdi
movq 0x3d631(%rip), %rsi     # 0x50fa0
callq 0x3280
movq -0x10(%rbp), %rdi
callq 0x13fb0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14010
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13fe0
testb $0x1, %al
jne 0x139a1
jmp 0x139ce
leaq -0x30(%rbp), %rdi
callq 0x14040
movq %rax, %rsi
addq $0x8, %rsi
movq 0x3d600(%rip), %rdi     # 0x50fb8
callq 0xdb90
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x14070
movq %rax, -0x40(%rbp)
jmp 0x13981
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3d5c1(%rip), %rdi     # 0x50fb8
movq 0x3d5a2(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x3d5ae(%rip), %rdi     # 0x50fb8
leaq 0x2dc28(%rip), %rsi     # 0x41639
callq 0x3240
movq %rax, %rdi
movq 0x3d580(%rip), %rsi     # 0x50fa0
callq 0x3280
movq -0x8(%rbp), %rdi
callq 0x140b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14110
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x140e0
testb $0x1, %al
jne 0x13a52
jmp 0x13a7f
leaq -0x18(%rbp), %rdi
callq 0x14140
movq %rax, %rsi
addq $0x8, %rsi
movq 0x3d54f(%rip), %rdi     # 0x50fb8
callq 0xee70
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x14170
movq %rax, -0x28(%rbp)
jmp 0x13a32
movq 0x3d532(%rip), %rdi     # 0x50fb8
movq 0x3d513(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x3d51f(%rip), %rdi     # 0x50fb8
leaq 0x2dbab(%rip), %rsi     # 0x4164b
callq 0x3240
movq %rax, %rdi
movq 0x3d4f1(%rip), %rsi     # 0x50fa0
callq 0x3280
movq -0x10(%rbp), %rdi
callq 0x141b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14210
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x141e0
testb $0x1, %al
jne 0x13ae1
jmp 0x13b0e
leaq -0x30(%rbp), %rdi
callq 0x14240
movq %rax, %rsi
addq $0x8, %rsi
movq 0x3d4c0(%rip), %rdi     # 0x50fb8
callq 0xf5c0
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x14270
movq %rax, -0x40(%rbp)
jmp 0x13ac1
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3d481(%rip), %rdi     # 0x50fb8
movq 0x3d462(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x3d46e(%rip), %rdi     # 0x50fb8
leaq 0x2db0e(%rip), %rsi     # 0x4165f
callq 0x3240
movq %rax, %rdi
movq 0x3d440(%rip), %rsi     # 0x50fa0
callq 0x3280
movq -0x8(%rbp), %rdi
callq 0x142b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14310
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x142e0
testb $0x1, %al
jne 0x13b92
jmp 0x13bbf
leaq -0x18(%rbp), %rdi
callq 0x14340
movq %rax, %rsi
addq $0x8, %rsi
movq 0x3d40f(%rip), %rdi     # 0x50fb8
callq 0x10970
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x14370
movq %rax, -0x28(%rbp)
jmp 0x13b72
movq 0x3d3f2(%rip), %rdi     # 0x50fb8
movq 0x3d3d3(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x3d3df(%rip), %rdi     # 0x50fb8
leaq 0x2da8d(%rip), %rsi     # 0x4166d
callq 0x3240
movq %rax, %rdi
movq 0x3d3b1(%rip), %rsi     # 0x50fa0
callq 0x3280
movq -0x10(%rbp), %rdi
callq 0x143b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14410
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x143e0
testb $0x1, %al
jne 0x13c21
jmp 0x13c4e
leaq -0x30(%rbp), %rdi
callq 0x14440
movq %rax, %rsi
addq $0x8, %rsi
movq 0x3d380(%rip), %rdi     # 0x50fb8
callq 0x11080
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x14470
movq %rax, -0x40(%rbp)
jmp 0x13c01
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x6e, -0x12(%rbp)
movq 0x3c6bd(%rip), %rdi     # 0x50fb8
leaq 0x2cd7b(%rip), %rsi     # 0x4167d
callq 0x3240
movq %rax, %rdi
movq 0x3c68f(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x3c6bb(%rip), %rdi     # 0x50fd8
leaq -0x11(%rbp), %rsi
callq 0x32e0
movsbl -0x11(%rbp), %eax
cmpl $0x76, %eax
je 0x14960
movsbl -0x11(%rbp), %eax
cmpl $0x74, %eax
je 0x14960
movq 0x3c679(%rip), %rdi     # 0x50fb8
leaq 0x2cd87(%rip), %rsi     # 0x416cd
callq 0x3240
movq %rax, %rdi
movq 0x3c64b(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x73, -0x12(%rbp)
jmp 0x14981
movsbl -0x11(%rbp), %eax
cmpl $0x76, %eax
jne 0x14974
movq -0x8(%rbp), %rdi
callq 0x149a0
jmp 0x1497d
movq -0x10(%rbp), %rdi
callq 0x15a70
jmp 0x1497f
jmp 0x14981
movsbl -0x12(%rbp), %eax
cmpl $0x73, %eax
je 0x148f4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x6e, -0x12(%rbp)
movq 0x1a81d(%rip), %rdi     # 0x50fb8
leaq 0xbb07(%rip), %rsi      # 0x422a9
callq 0x3240
movq %rax, %rdi
movq 0x1a7ef(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x1a81b(%rip), %rdi     # 0x50fd8
leaq -0x11(%rbp), %rsi
callq 0x32e0
movsbl -0x11(%rbp), %eax
cmpl $0x76, %eax
je 0x36800
movsbl -0x11(%rbp), %eax
cmpl $0x74, %eax
je 0x36800
movq 0x1a7d9(%rip), %rdi     # 0x50fb8
leaq 0xaee7(%rip), %rsi      # 0x416cd
callq 0x3240
movq %rax, %rdi
movq 0x1a7ab(%rip), %rsi     # 0x50fa0
callq 0x3280
movb $0x73, -0x12(%rbp)
jmp 0x36851
movsbl -0x11(%rbp), %eax
cmpl $0x76, %eax
jne 0x36814
movq -0x8(%rbp), %rdi
callq 0x36870
jmp 0x3681d
movq -0x10(%rbp), %rdi
callq 0x36f30
jmp 0x3681f
movq 0x1a792(%rip), %rdi     # 0x50fb8
leaq 0xbacd(%rip), %rsi      # 0x422fa
callq 0x3240
movq %rax, %rdi
movq 0x1a764(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x1a790(%rip), %rdi     # 0x50fd8
leaq -0x12(%rbp), %rsi
callq 0x32e0
movsbl -0x12(%rbp), %eax
cmpl $0x73, %eax
je 0x36794
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x6e, -0x13(%rbp)
movq 0x1657d(%rip), %rdi     # 0x50fb8
leaq 0x7a32(%rip), %rsi      # 0x42474
callq 0x3240
movq %rax, %rdi
movq 0x1654f(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x1657b(%rip), %rdi     # 0x50fd8
leaq -0x11(%rbp), %rsi
callq 0x32e0
movsbl -0x11(%rbp), %eax
cmpl $0x76, %eax
je 0x3aaec
movsbl -0x11(%rbp), %eax
cmpl $0x74, %eax
je 0x3aaec
movq 0x16539(%rip), %rdi     # 0x50fb8
leaq 0x774b(%rip), %rsi      # 0x421d1
callq 0x3240
movq %rax, %rdi
movq 0x1650b(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x16517(%rip), %rdi     # 0x50fb8
movq 0x164f8(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x16504(%rip), %rdi     # 0x50fb8
leaq 0x6b1d(%rip), %rsi      # 0x415d8
callq 0x3240
movq %rax, %rdi
movq 0x164d6(%rip), %rsi     # 0x50fa0
callq 0x3280
movq 0x16502(%rip), %rdi     # 0x50fd8
leaq -0x12(%rbp), %rsi
callq 0x32e0
movsbl -0x12(%rbp), %eax
cmpl $0x73, %eax
jne 0x3aaea
jmp 0x3ab1a
jmp 0x3ab0b
movsbl -0x11(%rbp), %eax
cmpl $0x76, %eax
jne 0x3ab00
movq -0x8(%rbp), %rdi
callq 0x3ab20
jmp 0x3ab09
movq -0x10(%rbp), %rdi
callq 0x3af80
jmp 0x3ab0b
jmp 0x3ab0d
movsbl -0x13(%rbp), %eax
cmpl $0x73, %eax
je 0x3aa34
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1f6e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1f740
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1f710
testb $0x1, %al
jne 0x3d6c4
jmp 0x3d6fd
leaq -0x20(%rbp), %rdi
callq 0x3d600
movq %rax, %rdi
addq $0x8, %rdi
callq 0x12470
cmpq -0x10(%rbp), %rax
jne 0x3d6ea
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3d6fd
jmp 0x3d6ec
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x1f790
movq %rax, -0x30(%rbp)
jmp 0x3d6a4
cmpl $0x0, -0x14(%rbp)
setne %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1f8b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1f910
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1f8e0
testb $0x1, %al
jne 0x3d754
jmp 0x3d78b
leaq -0x20(%rbp), %rdi
callq 0x3d5d0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x12470
cmpq -0x10(%rbp), %rax
jne 0x3d778
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3d77a
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x1f960
movq %rax, -0x30(%rbp)
jmp 0x3d734
cmpl $0x0, -0x14(%rbp)
setne %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1f6e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1f740
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1f710
testb $0x1, %al
jne 0x3d7e8
jmp 0x3d841
leaq -0x20(%rbp), %rdi
callq 0x3d600
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x48(%rbp), %rdi
callq 0x12440
movq -0x58(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3d540
movb %al, -0x59(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3180
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x3d823
jmp 0x3d82e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3d841
jmp 0x3d830
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x1f790
movq %rax, -0x50(%rbp)
jmp 0x3d7c8
cmpl $0x0, -0x14(%rbp)
setne %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq