LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %r15 # imm = 0x2E8BA2E8BA2E8BA3
imulq %r15, %rax
cmpq $0x2, %rax
jb 0x12bfc
movl $0x1, %r12d
movq (%r14), %rdi
addq $0x8, %rdi
callq 0x1146a
testl %eax, %eax
je 0x12be5
imulq $0x58, %r12, %r13
xorl %ebp, %ebp
movq (%r14), %rax
movq 0x40(%rax,%r13), %rcx
movsd (%rcx,%rbp,8), %xmm0
movq 0x40(%rax), %rax
addsd (%rax,%rbp,8), %xmm0
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
movq (%r14), %rdi
addq $0x8, %rdi
callq 0x1146a
movl %eax, %eax
cmpq %rax, %rbp
jb 0x12bb4
movq 0x8(%r14), %rax
subq (%r14), %rax
incq %r12
sarq $0x3, %rax
imulq %r15, %rax
cmpq %r12, %rax
ja 0x12b9e
movq (%r14), %rdi
addq $0x8, %rdi
callq 0x1146a
testl %eax, %eax
je 0x12c6c
xorl %r12d, %r12d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
imulq %r15, %rcx
movq %rcx, %xmm0
punpckldq 0x3ab2(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x3aba(%rip), %xmm0     # 0x166f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movq 0x40(%rax), %rax
movsd (%rax,%r12,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%r12,8)
incq %r12
movq (%r14), %rdi
addq $0x8, %rdi
callq 0x1146a
movl %eax, %eax
cmpq %rax, %r12
jb 0x12c0f
movq (%r14), %r14
leaq 0x8(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0x7392
leaq 0x20(%rbx), %rdi
leaq 0x20(%r14), %rsi
callq 0x7472
movl 0x38(%r14), %eax
movl %eax, 0x38(%rbx)
addq $0x40, %rbx
addq $0x40, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7550
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc8e8
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0xc8fa
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xc90c
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rax, %rcx
je 0x130fa
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 0x130e3
movq %rbx, %rdi
callq 0xc8dc
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xc8e2
movapd %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x13256
movsd %xmm0, 0x68(%rsp)
movq %rbx, %rdi
callq 0xc91e
leaq 0x8(%rsp), %rsi
callq 0x132ee
movsd %xmm0, 0x60(%rsp)
movq %rbx, %rdi
callq 0xc8dc
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xc8e2
movapd %xmm0, %xmm1
movsd (%rsp), %xmm0
movsd %xmm1, 0x50(%rsp)
callq 0x13256
movsd %xmm0, 0x58(%rsp)
movsd (%rsp), %xmm0
addsd 0x50(%rsp), %xmm0
leaq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x133e0
movsd %xmm0, (%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x131a0
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x131b7
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x131ce
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 0x2e23(%rip), %xmm1     # 0x16010
divsd %xmm1, %xmm0
addq $0x70, %rsp
popq %rbx
retq
jmp 0x13205
movq %rax, %rbx
jmp 0x1321f
movq %rax, %rbx
jmp 0x13236
jmp 0x13205
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1321f
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x13236
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1324d
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13584
movl %esi, 0x1c(%rdi)
movsd %xmm0, 0x20(%rdi)
movsd %xmm1, 0x28(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1359b
movsd %xmm0, 0x20(%rdi)
movq %rsi, 0x8(%rdi)
movsd %xmm1, 0x28(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x135b1
movsd %xmm0, 0x20(%rdi)
movq %rsi, 0x10(%rdi)
movsd %xmm1, 0x28(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x135c6
movsd %xmm0, 0x20(%rdi)
movq %rsi, (%rdi)
movsd %xmm1, 0x28(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1355c
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x13b46
xorl %r13d, %r13d
movl (%rax,%r13,4), %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x13b54
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x13b1e
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc278
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x13be2
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 0xc570
incq %rbp
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbp, %rcx
ja 0x13b9c
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc6f4
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x13c60
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 0xc58e
movq 0x10(%rsp), %rax
movsd (%rax,%r15,8), %xmm0
movsd %xmm0, 0x28(%rsp)
leaq 0xc(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x13090
movaps %xmm0, %xmm1
movq %r14, %rdi
movl %ebx, %esi
movsd 0x28(%rsp), %xmm0
callq 0x13570
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13c77
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
leaq 0x30(%rsp), %rdi
callq 0xc428
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13cb1
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13cb4
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
jmp 0x13cb4
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc428
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1355c
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x13d14
xorl %r13d, %r13d
movl (%rax,%r13,4), %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x13d22
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x13cec
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc278
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x13db1
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 0xc570
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x13d6b
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc6f4
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
je 0x13e2f
xorl %r12d, %r12d
leaq 0x30(%rsp), %r14
leaq 0xc(%rsp), %r15
movsd (%rdi,%r12,8), %xmm0
movq %r14, %rdi
callq 0xc58e
movq 0x10(%rsp), %rax
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, 0x28(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x13090
movaps %xmm0, %xmm1
movq %rbx, %rdi
movl %ebp, %esi
movsd 0x28(%rsp), %xmm0
callq 0x13570
incq %r12
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x13dd9
testq %rdi, %rdi
je 0x13e41
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
leaq 0x30(%rsp), %rdi
callq 0xc428
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13e5f
movq %rax, %rbx
jmp 0x13e7e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13e7e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
leaq 0x30(%rsp), %rdi
callq 0xc428
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1355c
leaq 0x30(%rsp), %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0xc278
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x13f24
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 0xc570
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x13ede
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc6f4
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
je 0x13fa2
xorl %r12d, %r12d
leaq 0x30(%rsp), %r14
leaq 0xc(%rsp), %r15
movsd (%rdi,%r12,8), %xmm0
movq %r14, %rdi
callq 0xc58e
movq 0x10(%rsp), %rax
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, 0x28(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x13090
movaps %xmm0, %xmm1
movq %rbx, %rdi
movl %ebp, %esi
movsd 0x28(%rsp), %xmm0
callq 0x13570
incq %r12
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x13f4c
testq %rdi, %rdi
je 0x13fb4
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
leaq 0x30(%rsp), %rdi
callq 0xc428
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13fd5
movq %rax, %rbx
jmp 0x13ff4
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13ff4
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x3210
leaq 0x30(%rsp), %rdi
callq 0xc428
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc278
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x1409d
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 0x1407f
movq %rbx, %rdi
callq 0xc624
jmp 0x14087
movq %rbx, %rdi
callq 0xc644
incq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x1403e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xc428
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1355c
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x1411e
xorl %r13d, %r13d
movl (%rax,%r13,4), %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x1412c
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x140f6
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1355c
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x144be
xorl %r13d, %r13d
movl (%rax,%r13,4), %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x144cc
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x14496
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nataly-enne[P]pet-fera/pet_fera_corpo.cpp
// Function: VETERINARIO::VETERINARIO(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
VETERINARIO::VETERINARIO(int i, string n, long int c, int ida, string t, char f, string e, string cr){
	id = i;
	nome = n;
	cpf = c;
	idade = ida;
	tipo_sanguineo = t;
	fator_rh = f;
	especialidade = e;
	crmv = cr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movl %r8d, %r12d
movq %rcx, %r13
movq %rdi, %rbx
addq $0x10, %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movb %al, 0x20(%rbx)
leaq 0x50(%rbx), %rcx
movq %rcx, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movb %al, 0x50(%rbx)
leaq 0x78(%rbx), %rcx
movq %rcx, 0x68(%rbx)
movq %rax, 0x70(%rbx)
movb %al, 0x78(%rbx)
leaq 0x38754(%rip), %rcx     # 0x47ac0
movq %rcx, (%rbx)
leaq 0x88(%rbx), %r14
leaq 0x98(%rbx), %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, 0x88(%rbx)
movq %rax, 0x90(%rbx)
movb %al, 0x98(%rbx)
movl %esi, 0x8(%rbx)
movq %rdx, %rsi
callq 0x30f0
leaq 0x40(%rbx), %rdi
movq %r13, 0x30(%rbx)
movl %r12d, 0x38(%rbx)
movq %r15, %rsi
callq 0x30f0
movq 0x18(%rbp), %rsi
movb 0x10(%rbp), %al
leaq 0x68(%rbx), %rdi
movb %al, 0x60(%rbx)
callq 0x30f0
movq 0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x30f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r14), %rdi
cmpq -0x30(%rbp), %rdi
je 0xf3f3
callq 0x31d0
movq %rbx, %rdi
callq 0x4a34
movq %r15, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/nataly-enne[P]pet-fera/pet_fera_corpo.cpp
// Function: TRATADOR::TRATADOR(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
TRATADOR::TRATADOR(int i, string n, long int c, int ida, string t, char f, string e, int nivel){
	id = i;
	nome = n;
	cpf = c;
	idade = ida;
	tipo_sanguineo = t;
	fator_rh = f;
	especialidade = e;
	nivel_seguranca = nivel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r14
movl %r8d, %r15d
movq %rcx, %r12
movq %rdi, %rbx
addq $0x10, %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movb %al, 0x20(%rbx)
leaq 0x50(%rbx), %rcx
movq %rcx, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movb %al, 0x50(%rbx)
leaq 0x78(%rbx), %rcx
movq %rcx, 0x68(%rbx)
movq %rax, 0x70(%rbx)
movb %al, 0x78(%rbx)
leaq 0x37f87(%rip), %rax     # 0x47ad8
movq %rax, (%rbx)
movl %esi, 0x8(%rbx)
movq %rdx, %rsi
callq 0x30f0
leaq 0x40(%rbx), %rdi
movq %r12, 0x30(%rbx)
movl %r15d, 0x38(%rbx)
movq %r14, %rsi
callq 0x30f0
movq 0x18(%rbp), %rsi
movb 0x10(%rbp), %al
leaq 0x68(%rbx), %rdi
movb %al, 0x60(%rbx)
callq 0x30f0
movl 0x20(%rbp), %eax
movl %eax, 0x88(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4a34
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/nataly-enne[P]pet-fera/pet_fera_pesquisar.cpp
// Function: imprimir_classe(std::map<int, ANFIBIO_NATIVO, std::less<int>, std::allocator<std::pair<int const, ANFIBIO_NATIVO>>>&, std::map<int, ANFIBIO_EXOTICO, std::less<int>, std::allocator<std::pair<int const, ANFIBIO_EXOTICO>>>&)
void imprimir_classe(map <int, ANFIBIO_NATIVO> &anfibios_nat, map <int, ANFIBIO_EXOTICO> &anfibios_ex){
	cout << endl;
	cout << "Anfíbios Nativos:" << endl;
	for(auto it = anfibios_nat.begin(); it != anfibios_nat.end(); it++){
		cout << it -> second;
	}
	cout << endl;
	cout << "Anfíbios Exóticos:" << endl;
	for(auto it = anfibios_ex.begin(); it != anfibios_ex.end(); it++){
		cout << it -> second;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x37afb(%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 0x2a126(%rip), %rsi     # 0x3a629
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 0x10568
movq 0x37a85(%rip), %r13     # 0x47fd0
leaq 0x28(%r12), %rsi
movq %r13, %rdi
callq 0x8385
movq %r12, %rdi
callq 0x3140
movq %rax, %r12
cmpq %r15, %rax
jne 0x1054b
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 0x2a0a6(%rip), %rsi     # 0x3a63c
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 0x105fa
movq 0x379f2(%rip), %r15     # 0x47fd0
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0x8aa6
movq %r14, %rdi
callq 0x3140
movq %rax, %r14
cmpq %rbx, %rax
jne 0x105de
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9eec
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 0xa640
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_O1/nataly-enne[P]pet-fera/pet_fera_pesquisar.cpp
// Function: imprimir_classe(std::map<int, REPTIL_NATIVO, std::less<int>, std::allocator<std::pair<int const, REPTIL_NATIVO>>>&, std::map<int, REPTIL_EXOTICO, std::less<int>, std::allocator<std::pair<int const, REPTIL_EXOTICO>>>&)
void imprimir_classe(map <int, REPTIL_NATIVO> &repteis_nat, map <int, REPTIL_EXOTICO> &repteis_ex){
	cout << endl;
	cout << "Répteis Nativos:" << endl;
	for(auto it = repteis_nat.begin(); it != repteis_nat.end(); it++){
		cout << it -> second;
	}
	cout << endl;
	cout << "Répteis Exóticos:" << endl;
	for(auto it = repteis_ex.begin(); it != repteis_ex.end(); it++){
		cout << it -> second;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x3785d(%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 0x29ed8(%rip), %rsi     # 0x3a679
movl $0x11, %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 0x10806
movq 0x377e7(%rip), %r13     # 0x47fd0
leaq 0x28(%r12), %rsi
movq %r13, %rdi
callq 0xba6f
movq %r12, %rdi
callq 0x3140
movq %rax, %r12
cmpq %r15, %rax
jne 0x107e9
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 0x29e57(%rip), %rsi     # 0x3a68b
movl $0x13, %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 0x10898
movq 0x37754(%rip), %r15     # 0x47fd0
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0xc211
movq %r14, %rdi
callq 0x3140
movq %rax, %r14
cmpq %rbx, %rax
jne 0x1087c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nataly-enne[P]pet-fera/pet_fera_pesquisar.cpp
// Function: imprimir_classe(std::map<int, AVE_NATIVO, std::less<int>, std::allocator<std::pair<int const, AVE_NATIVO>>>&, std::map<int, AVE_EXOTICO, std::less<int>, std::allocator<std::pair<int const, AVE_EXOTICO>>>&)
void imprimir_classe(map <int, AVE_NATIVO> &aves_nat, map <int, AVE_EXOTICO> &aves_ex){
	cout << endl;
	cout << "Aves Nativas:" << endl;
	for(auto it = aves_nat.begin(); it != aves_nat.end(); it++){
		cout << it -> second;
	}
	cout << endl;
	cout << "Aves Exóticas:" << endl;
	for(auto it = aves_ex.begin(); it != aves_ex.end(); it++){
		cout << it -> second;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x3770e(%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 0x29daf(%rip), %rsi     # 0x3a69f
movl $0xd, %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 0x10955
movq 0x37698(%rip), %r13     # 0x47fd0
leaq 0x28(%r12), %rsi
movq %r13, %rdi
callq 0xd6c3
movq %r12, %rdi
callq 0x3140
movq %rax, %r12
cmpq %r15, %rax
jne 0x10938
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 0x29d2a(%rip), %rsi     # 0x3a6ad
movl $0xf, %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 0x109e7
movq 0x37605(%rip), %r15     # 0x47fd0
leaq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0xde35
movq %r14, %rdi
callq 0x3140
movq %rax, %r14
cmpq %rbx, %rax
jne 0x109cb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10aed
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 0x11f8d
cmpb $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_O1/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 0x16038(%rip), %r12     # 0x47fd0
leaq 0x934a(%rip), %r13      # 0x3b2e9
movq 0x1603a(%rip), %rbx     # 0x47fe0
leaq -0x2a(%rbp), %r14
leaq 0x875c(%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 0x32010
cmpb $0x76, %al
jne 0x3204e
movq -0x38(%rbp), %rdi
callq 0x320b8
jmp 0x32057
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 0x3209f
movq -0x40(%rbp), %rdi
callq 0x32957
movl $0x31, %edx
movq %r12, %rdi
leaq 0x92d4(%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 0x31fb1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13098(%rip), %rbx     # 0x47fd0
leaq 0x6575(%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 0x13066(%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 0x34fa9
cmpb $0x76, %al
jne 0x35058
movq %r15, %rdi
callq 0x3506d
jmp 0x35060
leaq 0x6261(%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 0x5606(%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 0x12f93(%rip), %rdi     # 0x47fe0
leaq -0x21(%rbp), %rsi
callq 0x3280
jmp 0x35060
movq %r14, %rdi
callq 0x35486
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
setne %r12b
je 0x36d79
movq %rsi, %rbx
leaq 0x28(%r15), %rdi
callq 0xf24e
cmpq %rbx, %rax
je 0x36d79
movq %r15, %rdi
callq 0x3140
cmpq %r14, %rax
setne %r12b
je 0x36d79
movq %rax, %r15
movq %rax, %rdi
addq $0x28, %rdi
jmp 0x36d52
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x36dce
movq %rsi, %r14
leaq 0x28(%r12), %rdi
callq 0xf24e
xorl %ecx, %ecx
cmpq %r14, %rax
sete %cl
addl %ecx, %ebx
movq %r12, %rdi
callq 0x3140
movq %rax, %r12
cmpq %r15, %rax
jne 0x36da5
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_O1/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
setne %r12b
je 0x36e64
movq %rsi, %rbx
leaq 0x28(%r15), %rsi
leaq -0x48(%rbp), %rdi
callq 0xf220
movq -0x40(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x36e31
testq %rdx, %rdx
je 0x36e36
movq (%rbx), %rsi
movq -0x48(%rbp), %rdi
callq 0x3230
testl %eax, %eax
sete %r13b
jmp 0x36e39
xorl %r13d, %r13d
jmp 0x36e39
movb $0x1, %r13b
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x36e4b
callq 0x31d0
testb %r13b, %r13b
jne 0x36e64
movq %r15, %rdi
callq 0x3140
movq %rax, %r15
cmpq %r14, %rax
setne %r12b
jne 0x36e01
andb $0x1, %r12b
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %r14
movb $0x6e, (%rsi)
cmpl $0x0, 0x8(%rdi)
jle 0x38220
movq %r15, -0x30(%rbp)
xorl %ebx, %ebx
leaq 0x2084(%rip), %r15      # 0x3a248
leaq 0x1f4e(%rip), %r12      # 0x3a119
leaq 0x2816(%rip), %r13      # 0x3a9e8
movq (%r14), %rax
movsbl (%rax,%rbx), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x38237
movq %r14, %rdi
movq %r15, %rsi
callq 0x30c0
testl %eax, %eax
je 0x3820e
movq %r14, %rdi
movq %r12, %rsi
callq 0x30c0
testl %eax, %eax
je 0x3820e
movq %r14, %rdi
movq %r13, %rsi
callq 0x30c0
testl %eax, %eax
jne 0x38237
incq %rbx
movslq 0x8(%r14), %rax
cmpq %rax, %rbx
jl 0x381d2
movq -0x30(%rbp), %r15
jmp 0x38222
xorl %ebx, %ebx
cmpl 0x8(%r14), %ebx
jne 0x382ac
movb $0x73, (%r15)
movb $0x1, %al
jmp 0x3831e
movq -0x30(%rbp), %rax
movb $0x6e, (%rax)
movq 0xfd8b(%rip), %rbx      # 0x47fd0
leaq 0x3437(%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 0x3831c
movq 0xfd1d(%rip), %r14      # 0x47fd0
leaq 0x3410(%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_O1/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
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r13
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x3836d
movq (%r13), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x33d0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x38357
movq 0x8(%r13), %rbx
testl %ebx, %ebx
jle 0x383b8
movq %r12, -0x30(%rbp)
movq %r13, -0x38(%rbp)
movq (%r13), %r13
movl %ebx, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movsbl (%r13,%r14), %r15d
movl %r15d, %edi
callq 0x3320
cmpl $0x20, %r15d
je 0x383a6
testl %eax, %eax
je 0x383c9
incq %r14
cmpq %r14, %r12
jne 0x3838e
movq -0x30(%rbp), %r12
movq -0x38(%rbp), %r13
jmp 0x383ba
xorl %ebx, %ebx
cmpl 0x8(%r13), %ebx
jne 0x3843c
movb $0x73, (%r12)
movb $0x1, %al
jmp 0x3843e
movq -0x30(%rbp), %rax
movb $0x6e, (%rax)
movq 0xfbf9(%rip), %rbx      # 0x47fd0
leaq 0x32a5(%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_O1/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
movq %rdi, %r13
movb $0x6e, (%rsi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x3848d
movq (%r13), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x33d0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x38477
movq 0x8(%r13), %rbx
testl %ebx, %ebx
jle 0x384e0
movq %r12, -0x30(%rbp)
movq %r13, -0x38(%rbp)
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 0x384ce
movzbl %r15b, %eax
cmpl $0x20, %eax
je 0x384ce
cmpl $0x2d, %eax
jne 0x3851a
incq %r14
cmpq %r14, %r12
jne 0x384ae
movq -0x30(%rbp), %r12
movq -0x38(%rbp), %r13
jmp 0x384e2
xorl %ebx, %ebx
movq 0x8(%r13), %r14
cmpl %r14d, %ebx
jne 0x3858d
testq %r14, %r14
je 0x38511
movq (%r13), %rbx
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0x32c0
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x384fb
movb $0x73, (%r12)
movb $0x1, %al
jmp 0x3858f
movq -0x30(%rbp), %rax
movb $0x6e, (%rax)
movq 0xfaa8(%rip), %rbx      # 0x47fd0
leaq 0x3154(%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