LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 0asa[P]TTree-source/ExtraTTrees.cpp
// Function: ExtraTTrees::computeGroupVimp()
void ExtraTTrees::computeGroupVimp() {
	for (int t = 0 ; t < nbtree ; ++t) {
		term[t]->computeGroupVimp();
		VimpList interm = term[t]->getGroupVimpCompact(false);
		for (int i = 0 ; i < interm.size() ; ++i)
			groupVimp[interm.getNum(i)] += interm.getImp(i);
	}
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x5c(%rsp), %eax
cmpl 0x98(%rcx), %eax
jae 0x1a796
movq 0x20(%rsp), %rax
movq 0xa0(%rax), %rax
movslq 0x5c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x20(%rsp), %rax
movq 0xa0(%rax), %rax
movslq 0x5c(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x40(%rsp), %rdi
xorl %edx, %edx
callq 0x1cee0
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1a8c0
movl %eax, 0x1c(%rsp)
jmp 0x1a6ec
movl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
cmpl %ecx, %eax
jge 0x1a77c
movl 0x3c(%rsp), %esi
leaq 0x40(%rsp), %rdi
callq 0x1a8d0
movsd %xmm0, 0x10(%rsp)
jmp 0x1a712
movq 0x20(%rsp), %rax
addq $0x68, %rax
movq %rax, (%rsp)
movl 0x3c(%rsp), %esi
leaq 0x40(%rsp), %rdi
callq 0x1a900
movl %eax, 0xc(%rsp)
jmp 0x1a733
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0xcda0
movsd 0x10(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x1a6d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2e730
jmp 0x1a79b
leaq 0x40(%rsp), %rdi
callq 0x2e730
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x1a67b
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: 0asa[P]TTree-source/ExtraTrees.cpp
// Function: ExtraTrees::test(int, std::vector<unsigned int, std::allocator<unsigned int>>*)
Result ExtraTrees::test(int t, std::vector<unsigned int> *set) {
	Result r(db);
	std::vector<Result> vr;
	for (int _t = 0 ; _t < t ; ++_t) 
		vr.push_back(term[_t]->test(set));
	r.aggregate(vr);
	return r;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movl %edx, 0xb4(%rsp)
movq %rcx, 0xa8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0xa7(%rsp)
movq 0x8(%rax), %rsi
callq 0x24ac0
leaq 0x88(%rsp), %rdi
callq 0x1a820
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
cmpl 0xb4(%rsp), %eax
jge 0x1bfc4
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x84(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0xa8(%rsp), %rdx
movq (%rsi), %rax
movq 0x20(%rax), %rax
leaq 0x28(%rsp), %rdi
callq *%rax
jmp 0x1bf69
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1a830
jmp 0x1bf7d
leaq 0x28(%rsp), %rdi
callq 0x24b00
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x1bf28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1bff8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x24b00
jmp 0x1bff8
movq (%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x25000
jmp 0x1bfd7
movb $0x1, 0xa7(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1a860
testb $0x1, 0xa7(%rsp)
jne 0x1c019
jmp 0x1c010
leaq 0x88(%rsp), %rdi
callq 0x1a860
movq (%rsp), %rdi
callq 0x24b00
jmp 0x1c026
movq (%rsp), %rdi
callq 0x24b00
movq 0x8(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x33e0
// File: 0asa[P]TTree-source/ExtraTrees.cpp
// Function: ExtraTrees::testnmin(std::vector<unsigned int, std::allocator<unsigned int>>*, int, int)
Result ExtraTrees::testnmin(std::vector<unsigned int> *set,int nmin, int t) {
	Result r(db);
	std::vector<Result> vr;
	for (int _t = 0 ; _t < t ; ++_t) 
		vr.push_back(term[_t]->testnmin(set,nmin));
	r.aggregate(vr);
	return r;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movl %ecx, 0xac(%rsp)
movl %r8d, 0xa8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0xa7(%rsp)
movq 0x8(%rax), %rsi
callq 0x24ac0
leaq 0x88(%rsp), %rdi
callq 0x1a820
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
cmpl 0xa8(%rsp), %eax
jge 0x1c38f
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x84(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0xb0(%rsp), %rdx
movl 0xac(%rsp), %ecx
leaq 0x28(%rsp), %rdi
callq 0x159b0
jmp 0x1c334
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1a830
jmp 0x1c348
leaq 0x28(%rsp), %rdi
callq 0x24b00
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x1c2f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1c3c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x24b00
jmp 0x1c3c3
movq (%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x25000
jmp 0x1c3a2
movb $0x1, 0xa7(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1a860
testb $0x1, 0xa7(%rsp)
jne 0x1c3e4
jmp 0x1c3db
leaq 0x88(%rsp), %rdi
callq 0x1a860
movq (%rsp), %rdi
callq 0x24b00
jmp 0x1c3f1
movq (%rsp), %rdi
callq 0x24b00
movq 0x8(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x33e0
nopl (%rax,%rax)
// File: 0asa[P]TTree-source/ExtraTrees.cpp
// Function: ExtraTrees::computeVimp()
void ExtraTrees::computeVimp() {
	for (int t = 0 ; t < nbtree ; ++t) {
		term[t]->computeVimp();
		std::vector<float> interm = term[t]->getVimp(false);
		for (int i = 0 ; i < interm.size() ; ++i)
			vimp[i] += interm[i];		
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpl 0x58(%rcx), %eax
jae 0x1c4ed
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x3c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x3c(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
callq 0x208c0
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x126a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1c4d3
movslq 0x1c(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x12680
movq 0x10(%rsp), %rdi
movss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
addq $0x38, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x12680
movss 0x4(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1c46b
leaq 0x20(%rsp), %rdi
callq 0x7510
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x1c41b
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 0asa[P]TTree-source/GStump.cpp
// Function: GStump::learn()
double GStump::learn() {
	clock_t clock_start = clock();
	if (ls->size() > 0) 
		nmin = (int) ls->size();
	else 
		fprintf(stderr,"######### WARNING : NO LS SPECIFIED !!! #########\n");
	for (int t = 0 ; t < nbtree ; ++t) {
		term[t] = new ClassicTree(db,nmin);
		term[t]->setLearnFonction(); 
		term[t]->setLS(ls); // CONSUMMING...
		std::vector<unsigned int> a; a.push_back((*cand)[t]);
		term[t]->setAttCand(&a);
		term[t]->learn();
		//term[t]->setLS(emptyls);
		//fprintf(stderr, "Tree %03d - Att %03d - Complexity : %03d\n",t+1,a[0],term[t]->getComplexity());
	}
	return (clock() - clock_start);	
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3180
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq 0x20(%rax), %rdi
callq 0x8bf0
cmpq $0x0, %rax
jbe 0x1c7df
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x8bf0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl %ecx, 0x5c(%rax)
jmp 0x1c7f7
movq 0x247f2(%rip), %rax     # 0x40fd8
movq (%rax), %rdi
leaq 0x1414c(%rip), %rsi     # 0x3093c
movb $0x0, %al
callq 0x3360
movl $0x0, 0x44(%rsp)
movq 0x10(%rsp), %rcx
movl 0x44(%rsp), %eax
cmpl 0x58(%rcx), %eax
jge 0x1c93d
movl $0x170, %edi            # imm = 0x170
callq 0x3270
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rsi
movl 0x5c(%rax), %edx
xorl %ecx, %ecx
callq 0x132d0
jmp 0x1c83b
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rsi
movq 0x60(%rax), %rcx
movslq 0x44(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x60(%rax), %rax
movslq 0x44(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x167d0
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x60(%rax), %rax
movslq 0x44(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x204d0
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x67b0
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movslq 0x44(%rsp), %rsi
callq 0xcd80
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x12490
jmp 0x1c8b0
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x44(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x18(%rsp), %rsi
callq 0x20510
jmp 0x1c8ce
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x44(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x1c8ea
leaq 0x18(%rsp), %rdi
callq 0x6830
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x1c7ff
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x170, %esi            # imm = 0x170
callq 0x3280
jmp 0x1c951
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x6830
jmp 0x1c951
callq 0x3180
subq 0x48(%rsp), %rax
cvtsi2sd %rax, %xmm0
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x33e0
nopl (%rax,%rax)
// File: 0asa[P]TTree-source/GStump.cpp
// Function: GStump::test(std::vector<unsigned int, std::allocator<unsigned int>>*)
Result GStump::test(std::vector<unsigned int> *set) {
	//fprintf(stderr,"GStump::test(&set)\n");
	Result r(db);
	std::vector<Result> vr;
	for (int t = 0 ; t < nbtree ; ++t) 
		vr.push_back(term[t]->test(set));
	r.aggregate(vr);
	return r;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0xaf(%rsp)
movq 0x8(%rax), %rsi
callq 0x24ac0
leaq 0x90(%rsp), %rdi
callq 0x1a820
movl $0x0, 0x8c(%rsp)
movq 0x18(%rsp), %rcx
movl 0x8c(%rsp), %eax
cmpl 0x58(%rcx), %eax
jge 0x1cb3f
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x8c(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0xb0(%rsp), %rdx
movq (%rsi), %rax
movq 0x20(%rax), %rax
leaq 0x30(%rsp), %rdi
callq *%rax
jmp 0x1cae4
leaq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1a830
jmp 0x1caf8
leaq 0x30(%rsp), %rdi
callq 0x24b00
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x1caa2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1cb74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x24b00
jmp 0x1cb74
movq 0x8(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x25000
jmp 0x1cb53
movb $0x1, 0xaf(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x1a860
testb $0x1, 0xaf(%rsp)
jne 0x1cb97
jmp 0x1cb8d
leaq 0x90(%rsp), %rdi
callq 0x1a860
movq 0x8(%rsp), %rdi
callq 0x24b00
jmp 0x1cba4
movq 0x8(%rsp), %rdi
callq 0x24b00
movq 0x10(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x33e0
nop
// File: 0asa[P]TTree-source/GroupLearner.cpp
// Function: GroupLearner::getGroupVimpCompact(bool) const
VimpList GroupLearner::getGroupVimpCompact(bool norm) const {
	std::vector<double> ret = groupVimp;
	if (norm) {
		double max = *max_element(ret.begin(), ret.end());
		for (int i = 0 ; i < ret.size() ; ++i) 
			ret[i] /= max;
	}
	VimpList v;
	for (int i=0 ;  i < ret.size() ; ++i) {
		if (ret[i] != 0.0) {
			v.push(i, ret[i]);
		}
	}
	return v;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x30(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x38(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
andb $0x1, %al
movb %al, 0x97(%rsp)
movq 0x98(%rsp), %rsi
addq $0x68, %rsi
leaq 0x78(%rsp), %rdi
callq 0x178d0
testb $0x1, 0x97(%rsp)
je 0x1d002
leaq 0x78(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xade0
movq 0x20(%rsp), %rdi
movq %rax, 0x60(%rsp)
callq 0xae10
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x1d680
movq %rax, 0x28(%rsp)
jmp 0x1cf6c
movq 0x28(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xcec0
movsd (%rax), %xmm0
movsd %xmm0, 0x70(%rsp)
movl $0x0, 0x48(%rsp)
movslq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xab40
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x1d000
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movslq 0x48(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0xcda0
movsd 0x10(%rsp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x1cf92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x1d0e0
jmp 0x1d002
movq 0x30(%rsp), %rdi
movb $0x0, 0x47(%rsp)
callq 0x2e720
jmp 0x1d013
movl $0x0, 0x40(%rsp)
movslq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xab40
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1d0b3
movslq 0x40(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0xcda0
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1d05c
jp 0x1d05c
jmp 0x1d0a1
movl 0x40(%rsp), %eax
movl %eax, 0x4(%rsp)
movslq %eax, %rsi
leaq 0x78(%rsp), %rdi
callq 0xcda0
movq 0x30(%rsp), %rdi
movl 0x4(%rsp), %esi
movsd (%rax), %xmm0
callq 0x2e740
jmp 0x1d085
jmp 0x1d0a1
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x2e730
jmp 0x1d0e0
jmp 0x1d0a3
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x1d01b
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x1d0c9
movq 0x30(%rsp), %rdi
callq 0x2e730
leaq 0x78(%rsp), %rdi
callq 0xcaa0
movq 0x38(%rsp), %rax
addq $0xa8, %rsp
retq
leaq 0x78(%rsp), %rdi
callq 0xcaa0
movq 0x50(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: 0asa[P]TTree-source/GroupLearner.cpp
// Function: GroupLearner::getGroupVimp(bool) const
std::vector<double> GroupLearner::getGroupVimp(bool norm) const {
	std::vector<double> ret = groupVimp;
	if (!norm) {
		return ret;
	} else {
		double max = *max_element(ret.begin(), ret.end());
		for (int i = 0 ; i < ret.size() ; ++i) 
			ret[i] /= max;
		return ret;
	}
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
andb $0x1, %al
movb %al, 0x67(%rsp)
movq 0x68(%rsp), %rsi
movb $0x0, 0x66(%rsp)
addq $0x68, %rsi
callq 0x178d0
testb $0x1, 0x67(%rsp)
jne 0x1d14f
movb $0x1, 0x66(%rsp)
movl $0x1, 0x60(%rsp)
jmp 0x1d22b
movq 0x20(%rsp), %rdi
callq 0xade0
movq 0x20(%rsp), %rdi
movq %rax, 0x48(%rsp)
callq 0xae10
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1d680
movq %rax, 0x18(%rsp)
jmp 0x1d183
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xcec0
movsd (%rax), %xmm0
movsd %xmm0, 0x58(%rsp)
movl $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xab40
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x1d21e
movq 0x20(%rsp), %rdi
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movslq 0x30(%rsp), %rsi
callq 0xcda0
movsd 0x8(%rsp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x1d1a9
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xcaa0
jmp 0x1d246
movb $0x1, 0x66(%rsp)
movl $0x1, 0x60(%rsp)
testb $0x1, 0x66(%rsp)
jne 0x1d23c
movq 0x20(%rsp), %rdi
callq 0xcaa0
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x33e0
// File: 0asa[P]TTree-source/GroupLearner.cpp
// Function: GroupLearner::printGroupVimp(_IO_FILE*, bool) const
void GroupLearner::printGroupVimp(FILE* out, bool nozero) const {
	std::vector<double> gv = getGroupVimp();
	for (int i = 0 ; i < gv.size() ; ++i)
		if (nozero && gv[i] != 0.0) {
			fprintf(out,"%d\t%f\n",i,gv[i]);
		} else if (!nozero) {
			fprintf(out,"%d\t%f\n",i,gv[i]);
		}
}

// Assembly:
subq $0x68, %rsp
movb %dl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
andb $0x1, %al
movb %al, 0x57(%rsp)
movq 0x60(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movl $0x1, %edx
callq 0x1d100
movl $0x0, 0x34(%rsp)
movslq 0x34(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xab40
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x1d363
testb $0x1, 0x57(%rsp)
je 0x1d30c
movslq 0x34(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xcda0
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1d2ce
jp 0x1d2ce
jmp 0x1d30c
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x24(%rsp)
movslq 0x34(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xcda0
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %edx
movsd (%rax), %xmm0
leaq 0x13674(%rip), %rsi     # 0x30977
movb $0x1, %al
callq 0x3360
jmp 0x1d351
testb $0x1, 0x57(%rsp)
jne 0x1d34f
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x14(%rsp)
movslq 0x34(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xcda0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %edx
movsd (%rax), %xmm0
leaq 0x1362f(%rip), %rsi     # 0x30977
movb $0x1, %al
callq 0x3360
jmp 0x1d351
jmp 0x1d353
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x1d282
leaq 0x38(%rsp), %rdi
callq 0xcaa0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 0asa[P]TTree-source/JavaDB.cpp
// Function: JavaDB::countLineAtt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
long int JavaDB::countLineAtt(std::string f) {
	std::ifstream fs(f.c_str());
	long int ln = 0;
	long int a = 0;
	std::string line;
	while(getline(fs,line)) {
		if (ln == 5)
			a = countAtt(line);
		ln += 1;
	}
	fs.close();
	//printf("%ld x %ld\n",(ln-5),a);
	return (ln-5)*a;
}

// Assembly:
subq $0x2a8, %rsp            # imm = 0x2A8
movq %rsi, 0x20(%rsp)
movq %rdi, %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x2a0(%rsp)
movq %rdi, 0x298(%rsp)
movq 0x2a0(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x3100
movq %rax, %rsi
leaq 0x90(%rsp), %rdi
movl $0x8, %edx
callq 0x3410
movq $0x0, 0x88(%rsp)
movq $0x0, 0x80(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3350
leaq 0x90(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x3070
movq %rax, 0x18(%rsp)
jmp 0x1e706
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3320
movb %al, 0x17(%rsp)
jmp 0x1e720
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x1e72d
jmp 0x1e7bb
cmpq $0x5, 0x88(%rsp)
jne 0x1e7a2
leaq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x3120
jmp 0x1e749
movq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1e990
movq %rax, 0x8(%rsp)
jmp 0x1e75f
movq 0x8(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3170
jmp 0x1e7a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1e806
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3170
jmp 0x1e806
movq 0x88(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x88(%rsp)
jmp 0x1e6ed
leaq 0x90(%rsp), %rdi
callq 0x3080
jmp 0x1e7ca
movq 0x88(%rsp), %rax
subq $0x5, %rax
imulq 0x80(%rsp), %rax
movq %rax, (%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3170
leaq 0x90(%rsp), %rdi
callq 0x30a0
movq (%rsp), %rax
addq $0x2a8, %rsp            # imm = 0x2A8
retq
leaq 0x60(%rsp), %rdi
callq 0x3170
leaq 0x90(%rsp), %rdi
callq 0x30a0
movq 0x58(%rsp), %rdi
callq 0x33e0
nopw (%rax,%rax)
// File: 0asa[P]TTree-source/JavaDB.cpp
// Function: JavaDB::readline(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void JavaDB::readline(std::string l) {
	char* lcopy = new char[l.size()+1];
	strcpy(lcopy,l.c_str());
	char delim[] = " ";
	char* result = strtok(lcopy,delim);
	// at this point result = name of object which is not used here
	int wc = 0;
	while (result != NULL) {
		result = strtok(NULL, delim);
		if (wc == 0) {// status
			output.push_back(atoi(result));
		} else if (wc > 0 && result != NULL) { // genotype 
			att.push_back(atof(result));
		}
		wc++;
	}
	delete[] lcopy;
	setNbAtt(wc-2);
}

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rax
movq 0x18(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq %rax, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x31a0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x3030
movq 0x28(%rsp), %rdi
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x3100
movq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x3230
movw 0x12095(%rip), %ax      # 0x3092d
movw %ax, 0x4e(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x4e(%rsp), %rsi
callq 0x33b0
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x1e95e
leaq 0x4e(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x33b0
movq %rax, 0x40(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0x1e90d
movq 0x20(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x33a0
movq 0x10(%rsp), %rdi
movw %ax, 0x3a(%rsp)
leaq 0x3a(%rsp), %rsi
callq 0x1eda0
jmp 0x1e94e
cmpl $0x0, 0x3c(%rsp)
jle 0x1e94c
cmpq $0x0, 0x40(%rsp)
je 0x1e94c
movq 0x20(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x3310
movq 0x8(%rsp), %rdi
cvttsd2si %xmm0, %eax
movw %ax, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x1eda0
jmp 0x1e94e
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x1e8b9
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1e976
movq (%rsp), %rdi
callq 0x3330
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %esi
subl $0x2, %esi
callq 0x193f0
addq $0x68, %rsp
retq
nopl (%rax)
// File: 0asa[P]TTree-source/JavaDB.cpp
// Function: JavaDB::countAtt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
long int JavaDB::countAtt(std::string l) {
	char* lcopy = new char[l.size()+1];
	strcpy(lcopy,l.c_str());
	char delim[] = " ";
	char* result = strtok(lcopy,delim);
	// at this point result = name of object which is not used here
	int wc = 0;
	while (result != NULL) {
		result = strtok(NULL, delim);
		wc++;
	}
	delete[] lcopy;
	return wc-2;
}

// Assembly:
subq $0x58, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rax, 0x50(%rsp)
movq %rdi, 0x48(%rsp)
callq 0x31a0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x3030
movq 0x18(%rsp), %rdi
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x3100
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x3230
movw 0x11f3f(%rip), %ax      # 0x3092d
movw %ax, 0x3e(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x3e(%rsp), %rsi
callq 0x33b0
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x1ea37
leaq 0x3e(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x33b0
movq %rax, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1ea0f
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1ea51
movq 0x8(%rsp), %rdi
callq 0x3330
movl 0x2c(%rsp), %eax
subl $0x2, %eax
cltq
addq $0x58, %rsp
retq
nop
// File: 0asa[P]TTree-source/Learner.cpp
// Function: Learner::getVimpCompact(bool) const
VimpList Learner::getVimpCompact(bool norm) const {
	std::vector<float> ret = vimp;
	if (norm) {
		double max = *max_element(ret.begin(), ret.end());
		for (int i = 0 ; i < ret.size() ; ++i) 
			ret[i] /= max;
	}
	VimpList v;
	for (int i=0 ;  i < ret.size() ; ++i) {
		if (ret[i] != 0.0) {
			v.push(i, ret[i]);
		}
	}
	return v;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x30(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x38(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
andb $0x1, %al
movb %al, 0x97(%rsp)
movq 0x98(%rsp), %rsi
addq $0x38, %rsi
leaq 0x78(%rsp), %rdi
callq 0x21070
testb $0x1, 0x97(%rsp)
je 0x207be
leaq 0x78(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1d720
movq 0x20(%rsp), %rdi
movq %rax, 0x60(%rsp)
callq 0x1d750
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x1d6d0
movq %rax, 0x28(%rsp)
jmp 0x2071c
movq 0x28(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1d780
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x70(%rsp)
movl $0x0, 0x48(%rsp)
movslq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x126a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x207bc
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movslq 0x48(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x12680
movsd 0x10(%rsp), %xmm1
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x20746
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x208a4
jmp 0x207be
movq 0x30(%rsp), %rdi
movb $0x0, 0x47(%rsp)
callq 0x2e720
jmp 0x207cf
movl $0x0, 0x40(%rsp)
movslq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x126a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x20877
movslq 0x40(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x12680
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2081c
jp 0x2081c
jmp 0x20865
movl 0x40(%rsp), %eax
movl %eax, 0x4(%rsp)
movslq %eax, %rsi
leaq 0x78(%rsp), %rdi
callq 0x12680
movq 0x30(%rsp), %rdi
movl 0x4(%rsp), %esi
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x2e740
jmp 0x20849
jmp 0x20865
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x2e730
jmp 0x208a4
jmp 0x20867
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x207d7
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x2088d
movq 0x30(%rsp), %rdi
callq 0x2e730
leaq 0x78(%rsp), %rdi
callq 0x7510
movq 0x38(%rsp), %rax
addq $0xa8, %rsp
retq
leaq 0x78(%rsp), %rdi
callq 0x7510
movq 0x50(%rsp), %rdi
callq 0x33e0
nopl (%rax,%rax)
// File: 0asa[P]TTree-source/Learner.cpp
// Function: Learner::getVimp(bool) const
std::vector<float> Learner::getVimp(bool norm) const {
	std::vector<float> ret = vimp;
	if (!norm) {
		return ret;
	} else {
		double max = *max_element(ret.begin(), ret.end());
		for (int i = 0 ; i < ret.size() ; ++i) 
			ret[i] /= max;
		return ret;
	}
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
andb $0x1, %al
movb %al, 0x67(%rsp)
movq 0x68(%rsp), %rsi
movb $0x0, 0x66(%rsp)
addq $0x38, %rsi
callq 0x21070
testb $0x1, 0x67(%rsp)
jne 0x2090f
movb $0x1, 0x66(%rsp)
movl $0x1, 0x60(%rsp)
jmp 0x209f7
movq 0x20(%rsp), %rdi
callq 0x1d720
movq 0x20(%rsp), %rdi
movq %rax, 0x48(%rsp)
callq 0x1d750
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1d6d0
movq %rax, 0x18(%rsp)
jmp 0x20943
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1d780
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x58(%rsp)
movl $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x126a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x209ea
movq 0x20(%rsp), %rdi
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movslq 0x30(%rsp), %rsi
callq 0x12680
movsd 0x8(%rsp), %xmm1
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x2096d
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x7510
jmp 0x20a12
movb $0x1, 0x66(%rsp)
movl $0x1, 0x60(%rsp)
testb $0x1, 0x66(%rsp)
jne 0x20a08
movq 0x20(%rsp), %rdi
callq 0x7510
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x33e0
nopl (%rax)
// File: 0asa[P]TTree-source/Learner.cpp
// Function: Learner::printVimp(_IO_FILE*, bool) const
void Learner::printVimp(FILE* out, bool nozero) const {
	std::vector<float> v = getVimp();
	for (int i = 0 ; i < v.size() ; ++i)
		if (nozero && v[i] != 0.0) {
			fprintf(out,"%d\t%f\n",i,v[i]);
		} else if (!nozero) {
			fprintf(out,"%d\t%f\n",i,v[i]);
		}
}

// Assembly:
subq $0x68, %rsp
movb %dl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
andb $0x1, %al
movb %al, 0x57(%rsp)
movq 0x60(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movl $0x1, %edx
callq 0x208c0
movl $0x0, 0x34(%rsp)
movslq 0x34(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x126a0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x20b3f
testb $0x1, 0x57(%rsp)
je 0x20ae4
movslq 0x34(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x12680
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x20aa2
jp 0x20aa2
jmp 0x20ae4
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x24(%rsp)
movslq 0x34(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x12680
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %edx
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xfe9c(%rip), %rsi      # 0x30977
movb $0x1, %al
callq 0x3360
jmp 0x20b2d
testb $0x1, 0x57(%rsp)
jne 0x20b2b
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x14(%rsp)
movslq 0x34(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x12680
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %edx
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xfe53(%rip), %rsi      # 0x30977
movb $0x1, %al
callq 0x3360
jmp 0x20b2d
jmp 0x20b2f
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x20a52
leaq 0x38(%rsp), %rdi
callq 0x7510
addq $0x68, %rsp
retq
nop
// File: 0asa[P]TTree-source/Learner.cpp
// Function: Learner::print(_IO_FILE*) const
void Learner::print(FILE* out) const {
	fprintf(out,"########## Learning Set :\n");
			for (int i = 0 ; i < ls->size() ; ++i)
			fprintf(out,"%d ",(*ls)[i]);
	fprintf(out,"\n");
	fprintf(out,"########## Test     Set :\n");
	for (int i = 0 ; i < ts->size() ; ++i)
		fprintf(out,"%d ",(*ts)[i]);
	fprintf(out,"\n");
	fprintf(out,"########## Candidate Attributes :\n");
	for (int i = 0 ; i < cand->size() ; ++i)
		fprintf(out,"%d ",(*cand)[i]);
	fprintf(out,"\n");
	fprintf(out,"NMin : %d\n",nmin);
	fprintf(out,"Max Complexity : %d\n",maxcomplexity);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
leaq 0xfbf3(%rip), %rsi      # 0x30a37
movb $0x0, %al
callq 0x3360
movl $0x0, 0x44(%rsp)
movq 0x30(%rsp), %rax
movslq 0x44(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq 0x20(%rax), %rdi
callq 0x8bf0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x20eb7
movq 0x30(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x20(%rax), %rdi
movslq 0x44(%rsp), %rsi
callq 0xcd80
movq 0x20(%rsp), %rdi
movl (%rax), %edx
leaq 0xf81d(%rip), %rsi      # 0x306c0
movb $0x0, %al
callq 0x3360
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x20e53
movq 0x48(%rsp), %rdi
leaq 0xf751(%rip), %rsi      # 0x30614
movb $0x0, %al
callq 0x3360
movq 0x48(%rsp), %rdi
leaq 0xfb7c(%rip), %rsi      # 0x30a52
movb $0x0, %al
callq 0x3360
movl $0x0, 0x40(%rsp)
movq 0x30(%rsp), %rax
movslq 0x40(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0x28(%rax), %rdi
callq 0x8bf0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x20f49
movq 0x30(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x28(%rax), %rdi
movslq 0x40(%rsp), %rsi
callq 0xcd80
movq 0x10(%rsp), %rdi
movl (%rax), %edx
leaq 0xf78b(%rip), %rsi      # 0x306c0
movb $0x0, %al
callq 0x3360
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x20ee5
movq 0x48(%rsp), %rdi
leaq 0xf6bf(%rip), %rsi      # 0x30614
movb $0x0, %al
callq 0x3360
movq 0x48(%rsp), %rdi
leaq 0xfb05(%rip), %rsi      # 0x30a6d
movb $0x0, %al
callq 0x3360
movl $0x0, 0x3c(%rsp)
movq 0x30(%rsp), %rax
movslq 0x3c(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x30(%rax), %rdi
callq 0x8bf0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x20fd9
movq 0x30(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x30(%rax), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xcd80
movq (%rsp), %rdi
movl (%rax), %edx
leaq 0xf6fb(%rip), %rsi      # 0x306c0
movb $0x0, %al
callq 0x3360
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x20f77
movq 0x48(%rsp), %rdi
leaq 0xf62f(%rip), %rsi      # 0x30614
movb $0x0, %al
callq 0x3360
movq 0x30(%rsp), %rax
movq 0x48(%rsp), %rdi
movl 0x10(%rax), %edx
leaq 0xfa90(%rip), %rsi      # 0x30a90
movb $0x0, %al
callq 0x3360
movq 0x30(%rsp), %rax
movq 0x48(%rsp), %rdi
movl 0x18(%rax), %edx
leaq 0xfa80(%rip), %rsi      # 0x30a9b
movb $0x0, %al
callq 0x3360
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: 0asa[P]TTree-source/Node.cpp
// Function: Node::~Node()
Node::~Node() { 
	if (!isLeaf()) {
		delete test;
		delete left;
		delete right;
	} 
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x21aa0
movb %al, 0x2f(%rsp)
jmp 0x219ee
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x21a73
jmp 0x219f8
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x21a17
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x21a44
movq 0x10(%rsp), %rdi
callq 0x219d0
movq 0x10(%rsp), %rdi
movl $0x60, %esi
callq 0x3280
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x21a71
movq 0x8(%rsp), %rdi
callq 0x219d0
movq 0x8(%rsp), %rdi
movl $0x60, %esi
callq 0x3280
jmp 0x21a73
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
callq 0xcaa0
movq 0x20(%rsp), %rdi
callq 0x6830
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x8360
nopl (%rax,%rax)
// File: 0asa[P]TTree-source/Node.cpp
// Function: Node::setTest(Learner*, double, unsigned int, int)
void Node::setTest(Learner *t, double th, unsigned int g, int _treeType) {
	treeType = _treeType;
	test = new TreeNodeTest();
	((TreeNodeTest*)test)->setTreshold(th);
	((TreeNodeTest*)test)->setWeak(t);
	((TreeNodeTest*)test)->setGroup(g);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movl %ecx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x28(%rsp), %ecx
movl %ecx, 0x5c(%rax)
movl $0x20, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x2da10
jmp 0x21bd9
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq 0x30(%rax), %rdi
movsd 0x30(%rsp), %xmm0
callq 0x2dc00
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rsp), %rsi
callq 0x2dbc0
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
movl 0x2c(%rsp), %esi
callq 0x2dbe0
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x20, %esi
callq 0x3280
movq 0x20(%rsp), %rdi
callq 0x33e0
nopw (%rax,%rax)
// File: 0asa[P]TTree-source/Node.cpp
// Function: Node::propagate(double) const
Node* Node::propagate(double v) const {
	if (test->test(v))
		return getLeft();
	else
		return getRight();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rax), %rdi
movsd 0x10(%rsp), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x21d3f
jmp 0x21d50
movq 0x8(%rsp), %rdi
callq 0x21af0
movq %rax, 0x20(%rsp)
jmp 0x21d5f
movq 0x8(%rsp), %rdi
callq 0x21b00
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 0asa[P]TTree-source/Node.cpp
// Function: Node::propagate(unsigned int) const
Node* Node::propagate(unsigned int obj) const {
	if (test->test((double)obj))
		return getLeft();
	else
		return getRight();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rax), %rdi
movl 0x14(%rsp), %eax
cvtsi2sd %rax, %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x21da0
jmp 0x21db1
movq 0x8(%rsp), %rdi
callq 0x21af0
movq %rax, 0x20(%rsp)
jmp 0x21dc0
movq 0x8(%rsp), %rdi
callq 0x21b00
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 0asa[P]TTree-source/Probas.cpp
// Function: Probas::push(Probas&)
void Probas::push(Probas &p) {
	for (int i = 0 ; i < p.getSize() ; ++i) {
		object.push_back(p.getObj(i));
		probas.push_back(p.getProb(i));
		realclass.push_back(p.getRealClass(i));
		++size;
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rdi
callq 0x223c0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jae 0x224b2
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x224c0
movq 0x18(%rsp), %rdi
movl %eax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x7b90
movq 0x18(%rsp), %rax
addq $0x38, %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x224f0
movq (%rsp), %rdi
movsd %xmm0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x17880
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x22520
movq 0x8(%rsp), %rdi
cvttsd2si %xmm0, %eax
movw %ax, 0x26(%rsp)
leaq 0x26(%rsp), %rsi
callq 0x22600
movq 0x18(%rsp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x223f0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 0asa[P]TTree-source/Probas.cpp
// Function: Probas::push(unsigned int, double, double)
void Probas::push(unsigned int o, double p, double rc) {
	object.push_back(o);
	probas.push_back(p);
	realclass.push_back(rc);
	++size;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x2c(%rsp), %rsi
callq 0x12490
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
leaq 0x20(%rsp), %rsi
callq 0x22630
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
cvttsd2si 0x18(%rsp), %eax
movw %ax, 0x16(%rsp)
leaq 0x16(%rsp), %rsi
callq 0x22600
movq 0x8(%rsp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 0asa[P]TTree-source/./Sampler.h
// Function: std::vector<unsigned int, std::allocator<unsigned int>> Sampler::bootstrap<unsigned int>(std::vector<unsigned int, std::allocator<unsigned int>>&)
std::vector<T> Sampler::bootstrap(std::vector<T> &v) {
	std::vector<T> ret(v.size());
	for (int i = 0 ; i < v.size() ; ++i)
		ret[i] = v[rand()%v.size()];
	return ret;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
movq 0x58(%rsp), %rdi
callq 0x8bf0
movq %rax, 0x30(%rsp)
leaq 0x56(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x79a0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x12b90
jmp 0x238a4
leaq 0x56(%rsp), %rdi
callq 0xbb90
movl $0x0, 0x40(%rsp)
movslq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
callq 0x8bf0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x23954
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
callq 0x30b0
cltq
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x8bf0
movq (%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rsi
callq 0xcd80
movq 0x28(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movslq 0x40(%rsp), %rsi
callq 0xcd80
movl 0x14(%rsp), %ecx
movl %ecx, (%rax)
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x238b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x56(%rsp), %rdi
callq 0xbb90
jmp 0x23974
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x2396a
movq 0x28(%rsp), %rdi
callq 0x6830
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x33e0
nop
// File: 0asa[P]TTree-source/RandomTTForest.cpp
// Function: RandomTTForest::RandomTTForest(DB*, int, int, int)
RandomTTForest::RandomTTForest(DB *db, int t, int _k, int n) : GroupLearner(db,n), nbtree(t), k(_k) {
	treeType = TRUEBESTFIRST;
	internalComp = 1;
	setKint(0);
	term = new ClassicNodeTree*[nbtree];
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x38(%rsp), %rsi
movl 0x2c(%rsp), %edx
callq 0x1cd10
movq 0x10(%rsp), %rdi
leaq 0x1d029(%rip), %rax     # 0x40cb8
movq %rax, (%rdi)
movl 0x34(%rsp), %eax
movl %eax, 0x98(%rdi)
movl 0x30(%rsp), %eax
movl %eax, 0xa8(%rdi)
movl $0x2, 0x60(%rdi)
movl $0x1, 0x58(%rdi)
xorl %esi, %esi
callq 0x7390
jmp 0x23cbd
movq 0x10(%rsp), %rax
movl 0x98(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x3030
movq %rax, 0x8(%rsp)
jmp 0x23cda
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0xa0(%rax)
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x1cd70
movq 0x20(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: 0asa[P]TTree-source/RandomTTForest.cpp
// Function: RandomTTForest::testnmin(std::vector<unsigned int, std::allocator<unsigned int>>*, int, int)
Result RandomTTForest::testnmin(std::vector<unsigned int> *set, int nmin, int t) {
	Result r(db);
	std::vector<Result> vr;
	for (int _t = 0 ; _t < t ; ++_t) 
		vr.push_back(term[_t]->testnmin(set,nmin));
	r.aggregate(vr);
	return r;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movl %ecx, 0xac(%rsp)
movl %r8d, 0xa8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0xa7(%rsp)
movq 0x8(%rax), %rsi
callq 0x24ac0
leaq 0x88(%rsp), %rdi
callq 0x1a820
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
cmpl 0xa8(%rsp), %eax
jge 0x246a2
movq 0x10(%rsp), %rax
movq 0xa0(%rax), %rax
movslq 0x84(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0xb0(%rsp), %rdx
movl 0xac(%rsp), %ecx
leaq 0x28(%rsp), %rdi
callq 0x10a40
jmp 0x24647
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1a830
jmp 0x2465b
leaq 0x28(%rsp), %rdi
callq 0x24b00
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x24600
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x246d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x24b00
jmp 0x246d6
movq (%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x25000
jmp 0x246b5
movb $0x1, 0xa7(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1a860
testb $0x1, 0xa7(%rsp)
jne 0x246f7
jmp 0x246ee
leaq 0x88(%rsp), %rdi
callq 0x1a860
movq (%rsp), %rdi
callq 0x24b00
jmp 0x24704
movq (%rsp), %rdi
callq 0x24b00
movq 0x8(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x33e0
nop
// File: 0asa[P]TTree-source/Result.cpp
// Function: Result::getErrorRate(double) const
double Result::getErrorRate(double th) const {
	double err = 0.0;
	double val;
	for (int i = 0 ; i < prob.getSize() ; ++i) {
		if (prob.getProb(i)>th)
			val = 1.0;
		else
			val = 0.0;
		if (val != prob.getRealClass(i))
			err++;
	}
	return err / (double) prob.getSize();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
addq $0x8, %rdi
callq 0x223c0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jae 0x24c78
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movl 0x24(%rsp), %esi
callq 0x224f0
ucomisd 0x38(%rsp), %xmm0
jbe 0x24c18
movsd 0xbb60(%rip), %xmm0     # 0x30770
movsd %xmm0, 0x28(%rsp)
jmp 0x24c21
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x18(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x8, %rdi
movl 0x24(%rsp), %esi
callq 0x22520
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x24c52
jp 0x24c52
jmp 0x24c66
movsd 0xbb16(%rip), %xmm0     # 0x30770
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x24c68
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x24bca
movq 0x18(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rsp)
addq $0x8, %rdi
callq 0x223c0
movsd (%rsp), %xmm0
movl %eax, %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 0asa[P]TTree-source/Result.cpp
// Function: Result::getPossibleProbTh() const
std::vector<double> Result::getPossibleProbTh() const {
	std::vector<double> ret;
	std::vector<double> pcopy(prob.probas);
	sort(pcopy.begin(),pcopy.end());
	double v = pcopy[0];
	for (int i = 1 ; i < pcopy.size() ; ++i) {
		if (pcopy[i] != v) {
			ret.push_back((v+pcopy[i])/2.0);
			v = pcopy[i];
		}
	}
	return ret;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0x87(%rsp)
callq 0xca90
movq 0x28(%rsp), %rsi
addq $0x40, %rsi
leaq 0x68(%rsp), %rdi
callq 0x178d0
jmp 0x24d03
leaq 0x68(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xade0
movq 0x10(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0xae10
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x251e0
jmp 0x24d37
leaq 0x68(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xcda0
movsd (%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movl $0x1, 0x3c(%rsp)
movslq 0x3c(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xab40
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x24e3f
movslq 0x3c(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0xcda0
movsd (%rax), %xmm0
ucomisd 0x40(%rsp), %xmm0
jne 0x24d9e
jp 0x24d9e
jmp 0x24e2d
movsd 0x40(%rsp), %xmm0
movsd %xmm0, (%rsp)
movslq 0x3c(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0xcda0
movsd (%rsp), %xmm0
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm1
addsd %xmm1, %xmm0
movsd 0xb23e(%rip), %xmm1     # 0x30010
mulsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x17880
jmp 0x24de8
movslq 0x3c(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0xcda0
movsd (%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x24e2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x24e72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xcaa0
jmp 0x24e72
jmp 0x24e2f
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x24d57
movb $0x1, 0x87(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xcaa0
testb $0x1, 0x87(%rsp)
jne 0x24e65
movq 0x18(%rsp), %rdi
callq 0xcaa0
movq 0x20(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xcaa0
movq 0x60(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: 0asa[P]TTree-source/Result.cpp
// Function: Result::getContingencyTable(double) const
ContingencyTable Result::getContingencyTable(double th) const {
	ContingencyTable ctable(2,2);
	unsigned int val;
	for (int i = 0 ; i < prob.getSize() ; ++i) {
		if (prob.getProb(i)>th)
			val = 1;
		else
			val = 0;
		ctable.addToTable(prob.getRealClass(i), val, db->getWeight(i));
	}
	return ctable;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movsd %xmm0, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movb $0x0, 0x5f(%rsp)
movl $0x2, %edx
movl %edx, %esi
callq 0x16b40
movl $0x0, 0x54(%rsp)
movq 0x38(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, 0x20(%rsp)
addq $0x8, %rdi
callq 0x223c0
movl %eax, 0x24(%rsp)
jmp 0x24ef0
movl 0x20(%rsp), %eax
movl 0x24(%rsp), %ecx
cmpl %ecx, %eax
jae 0x24fca
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
movl 0x54(%rsp), %esi
callq 0x224f0
movsd %xmm0, 0x18(%rsp)
jmp 0x24f1a
movsd 0x18(%rsp), %xmm0
ucomisd 0x60(%rsp), %xmm0
jbe 0x24f4f
movl $0x1, 0x58(%rsp)
jmp 0x24f57
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x16d70
jmp 0x24fea
movl $0x0, 0x58(%rsp)
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
movl 0x54(%rsp), %esi
callq 0x22520
movsd %xmm0, 0x10(%rsp)
jmp 0x24f71
movq 0x38(%rsp), %rax
movsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, (%rsp)
movl 0x58(%rsp), %ecx
movl %ecx, 0x4(%rsp)
movq (%rax), %rdi
movl 0x54(%rsp), %esi
callq 0xcd50
movsd %xmm0, 0x8(%rsp)
jmp 0x24f9f
movsd 0x8(%rsp), %xmm0
movl 0x4(%rsp), %edx
movl (%rsp), %esi
movq 0x28(%rsp), %rdi
callq 0x16f30
jmp 0x24fb8
jmp 0x24fba
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x24ed4
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x24fe0
movq 0x28(%rsp), %rdi
callq 0x16d70
movq 0x30(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)