LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsimplex.c
// Function: test_one_vs_one_svm
int test_one_vs_one_svm(Svm_simplex_modelptr model, Svm_simplex_parameterptr parameters, Instanceptr inst)
{
 int i, j, k, *votes, maxVote;
 double vote;
 votes = safecalloc(current_dataset->classno, sizeof(int), "test_one_vs_one_svm", 2);
 k = 0;
 for (i = 0; i < current_dataset->classno; i++)
   for (j = i + 1; j < current_dataset->classno; j++)
    {
     vote = test_binary_svm(model->models[k], parameters, inst);
     if (vote < 0)
       votes[i]++;
     else
       votes[j]++;
    }
 maxVote = find_max_in_list(votes, current_dataset->classno);
 safe_free(votes);
 return maxVote;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r12
leaq 0x3f695(%rip), %rbx     # 0xd2870
movq (%rbx), %rax
movslq 0x10(%rax), %rdi
leaq 0x1b9e6(%rip), %rdx     # 0xaebcf
movl $0x4, %esi
movl $0x2, %ecx
callq 0x39210
movq %rax, %r15
movq (%rbx), %rax
movl 0x10(%rax), %esi
testl %esi, %esi
jle 0x93273
movl $0x1, %eax
movq %rax, (%rsp)
xorl %ebp, %ebp
leaq 0x1(%rbp), %rdx
movq (%rbx), %rax
movslq 0x10(%rax), %rax
movq %rdx, 0x8(%rsp)
cmpq %rax, %rdx
jge 0x9325e
movq (%rsp), %r13
movq 0x8(%r12), %rax
movq (%rax), %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
callq 0x92f9e
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
movq %rbp, %rax
ja 0x9324e
movq %r13, %rax
incl (%r15,%rax,4)
incq %r13
movq (%rbx), %rax
cmpl %r13d, 0x10(%rax)
jg 0x93229
movq (%rbx), %rax
movslq 0x10(%rax), %rsi
incq (%rsp)
movq 0x8(%rsp), %rbp
cmpq %rsi, %rbp
jl 0x93210
movq %r15, %rdi
callq 0x37504
movl %eax, %ebx
movq %r15, %rdi
callq 0x39194
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsimplex.c
// Function: solve_one_vs_rest_svm
Svm_simplex_modelptr solve_one_vs_rest_svm(Instanceptr data, Svm_simplex_parameterptr parameters)
{
 int i;
 Svm_simplex_modelptr model;
 model = safemalloc(sizeof(Svm_simplex_model), "solve_one_vs_one_svm", 3);
 model->problemcount = current_dataset->classno;
 model->models = safemalloc(model->problemcount * sizeof(Svm_binary_modelptr), "solve_one_vs_one_svm", 5);
 for (i = 0; i < current_dataset->classno; i++)
   model->models[i] = solve_binary_svm(data, parameters, i);
 return model;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1b90e(%rip), %r12     # 0xaebba
movl $0x10, %edi
movq %r12, %rsi
movl $0x3, %edx
callq 0x390f5
movq %rax, %r15
leaq 0x3f5a8(%rip), %r13     # 0xd2870
movq (%r13), %rax
movslq 0x10(%rax), %rdi
movl %edi, (%r15)
shlq $0x3, %rdi
movq %r12, %rsi
movl $0x5, %edx
callq 0x390f5
movq %rax, 0x8(%r15)
movq (%r13), %rax
cmpl $0x0, 0x10(%rax)
jle 0x9331b
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x92bec
movq 0x8(%r15), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq (%r13), %rax
movslq 0x10(%rax), %rax
cmpq %rax, %r12
jl 0x932f5
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsimplex.c
// Function: free_svm_simplex_model
void free_svm_simplex_model(Svm_simplex_modelptr model)
{
 int i;
 for (i = 0; i < model->problemcount; i++)
   free_svm_binary_model(model->models[i]);
 safe_free(model->models);
 safe_free(model);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x9334f
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x93035
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x93337
movq 0x8(%rbx), %rdi
callq 0x39194
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsimplex.c
// Function: test_one_vs_rest_svm
int test_one_vs_rest_svm(Svm_simplex_modelptr model, Svm_simplex_parameterptr parameters, Instanceptr inst)
{
 int i, maxVote;
 double *votes;
 votes = safecalloc(current_dataset->classno, sizeof(double), "test_one_vs_rest_svm", 3);
 for (i = 0; i < current_dataset->classno; i++)
   votes[i] = test_binary_svm(model->models[i], parameters, inst);
 maxVote = find_min_in_list_double(votes, current_dataset->classno);
 safe_free(votes);
 return maxVote;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x3f4ee(%rip), %r13     # 0xd2870
movq (%r13), %rax
movslq 0x10(%rax), %rdi
leaq 0x1b852(%rip), %rdx     # 0xaebe3
movl $0x8, %esi
movl $0x3, %ecx
callq 0x39210
movq %rax, %r12
movq (%r13), %rax
movl 0x10(%rax), %esi
testl %esi, %esi
jle 0x933d9
xorl %ebp, %ebp
movq 0x8(%r15), %rax
movq (%rax,%rbp,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x92f9e
movsd %xmm0, (%r12,%rbp,8)
incq %rbp
movq (%r13), %rax
movslq 0x10(%rax), %rsi
cmpq %rsi, %rbp
jl 0x933b0
movq %r12, %rdi
callq 0x37740
movl %eax, %ebx
movq %r12, %rdi
callq 0x39194
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsolve.c
// Function: update_alpha_status
void update_alpha_status(Solverptr s, int i)
{
 /*Last Changed 28.04.2005*/
	if (s->alpha[i] >= get_C(s, i))
			s->alpha_status[i] = UPPER_BOUND;
	else 
		 if (s->alpha[i] <= 0)
			  s->alpha_status[i] = LOWER_BOUND;
		 else 
				 s->alpha_status[i] = FREE;
}

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x20(%rdi), %rdx
movslq %esi, %rax
movsd (%rdx,%rax,8), %xmm0
xorl %edx, %edx
cmpb $0x0, (%rcx,%rax)
setle %dl
ucomisd 0x50(%rdi,%rdx,8), %xmm0
jae 0x93447
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
movq 0x18(%rdi), %rcx
jae 0x93450
movb $0x2, (%rcx,%rax)
retq
movq 0x18(%rdi), %rcx
movb $0x1, (%rcx,%rax)
retq
movb $0x0, (%rcx,%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsolve.c
// Function: solver_get_Q
double* solver_get_Q(Solverptr s, int i, int len)
{
 /*Last Changed 28.04.2005*/
	switch (s->qmatrixtype)
	 {
   case QC  :return svcq_get_Q(s->svcq, i, len);
				         break;
			case QR  :return svrq_get_Q(s->svrq, i, len);
				         break;
			case QONE:return oneclassq_get_Q(s->oneclassq, i, len);
				         break;
			default  :return NULL;
				         break;
	 }
}

// Assembly:
movl 0x28(%rdi), %eax
cmpl $0x2, %eax
je 0x934ab
cmpl $0x1, %eax
je 0x934a2
testl %eax, %eax
jne 0x934b4
movq 0x30(%rdi), %rdi
jmp 0x91854
movq 0x38(%rdi), %rdi
jmp 0x91be6
movq 0x40(%rdi), %rdi
jmp 0x919e5
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsolve.c
// Function: solver_swap_index
void solver_swap_index(Solverptr s, int i, int j)
{
 /*Last Changed 28.04.2005*/
	signed char tmp;
	switch (s->qmatrixtype)
	 {
   case QC  :svcq_swap_index(s->svcq, i, j);
				         break;
			case QR  :svrq_swap_index(s->svrq, i, j);
				         break;
			case QONE:oneclassq_swap_index(s->oneclassq, i, j);
				         break;
	 }
	tmp = s->y[i];
	s->y[i] = s->y[j];
	s->y[j] = tmp;
	swap_double(&(s->G[i]), &(s->G[j]));
	swap_char(&(s->alpha_status[i]), &(s->alpha_status[j]));
	swap_double(&(s->alpha[i]), &(s->alpha[j]));
	swap_double(&(s->b[i]), &(s->b[j]));
	swap_int(&(s->active_set[i]), &(s->active_set[j]));
	swap_double(&(s->G_bar[i]), &(s->G_bar[j]));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl 0x28(%rdi), %eax
cmpl $0x2, %eax
je 0x934f7
cmpl $0x1, %eax
je 0x934e7
testl %eax, %eax
jne 0x93505
movq 0x30(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x9191c
jmp 0x93505
movq 0x38(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x91ccc
jmp 0x93505
movq 0x40(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x91a5f
movq 0x8(%rbx), %rax
movslq %r14d, %r14
movb (%rax,%r14), %cl
movslq %ebp, %r15
movb (%rax,%r15), %dl
movb %dl, (%rax,%r14)
movq 0x8(%rbx), %rax
movb %cl, (%rax,%r15)
movq 0x10(%rbx), %rax
leaq (%rax,%r14,8), %rdi
leaq (%rax,%r15,8), %rsi
callq 0x395ac
movq 0x18(%rbx), %rsi
leaq (%rsi,%r14), %rdi
addq %r15, %rsi
callq 0x3959a
movq 0x20(%rbx), %rax
leaq (%rax,%r14,8), %rdi
leaq (%rax,%r15,8), %rsi
callq 0x395ac
movq 0x60(%rbx), %rax
leaq (%rax,%r14,8), %rdi
leaq (%rax,%r15,8), %rsi
callq 0x395ac
movq 0x68(%rbx), %rax
leaq (%rax,%r14,4), %rdi
leaq (%rax,%r15,4), %rsi
callq 0x395a3
movq 0x70(%rbx), %rax
leaq (%rax,%r14,8), %rdi
leaq (%rax,%r15,8), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x395ac
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsolve.c
// Function: reconstruct_gradient
void reconstruct_gradient(Solverptr s)
{
 /*Last Changed 28.04.2005*/
	int i, j;
	double* Q_i, alpha_i;
	if (s->active_size == s->l) 
		 return;
	for (i = s->active_size; i < s->l; i++)
		 s->G[i] = s->G_bar[i] + s->b[i];	
	for (i = 0; i < s->active_size; i++)
		 if (is_free(s, i))
			 {
			  Q_i = solver_get_Q(s, i, s->l);
			  alpha_i = s->alpha[i];
			  for (j = s->active_size; j < s->l; j++)
				   s->G[j] += alpha_i * Q_i[j];
			 }
}

// Assembly:
movslq (%rdi), %rax
movslq 0x78(%rdi), %rcx
cmpl %ecx, %eax
je 0x93636
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl %ecx, %eax
jge 0x935cf
movq 0x70(%rbx), %rdx
movq 0x10(%rbx), %rsi
movq 0x60(%rbx), %rdi
movsd (%rdx,%rax,8), %xmm0
addsd (%rdi,%rax,8), %xmm0
movsd %xmm0, (%rsi,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0x935b8
cmpl $0x0, (%rbx)
jle 0x9362f
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
cmpb $0x2, (%rax,%r14)
jne 0x93624
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x93488
movslq (%rbx), %rcx
movslq 0x78(%rbx), %rdx
cmpl %edx, %ecx
jge 0x93624
movq 0x20(%rbx), %rsi
movsd (%rsi,%r14,8), %xmm0
movq 0x10(%rbx), %rsi
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%rsi,%rcx,8), %xmm1
movsd %xmm1, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rdx
jne 0x93609
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x935d7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsolve.c
// Function: select_working_set
int select_working_set(Solverptr s, int* out_i, int* out_j)
{
 /*Last Changed 28.04.2005*/
	double Gmax1 = -DBL_MAX, Gmax2 = -DBL_MAX;		
	int i, Gmax1_idx = -1, Gmax2_idx = -1;
	for (i = 0; i < s->active_size; i++)
	 {
	 	if (s->y[i] == +1)	
		  {
		  	if (!is_upper_bound(s, i))	
					 {
				   if (-s->G[i] >= Gmax1)
							 {
					    Gmax1 = -s->G[i];
					    Gmax1_idx = i;
							 }
					 }
			  if (!is_lower_bound(s, i))	
					 {
				   if (s->G[i] >= Gmax2)
							 {
					    Gmax2 = s->G[i];
					    Gmax2_idx = i;
							 }
					 }
			 }
		 else		
			 {
			  if (!is_upper_bound(s, i))	
					 {
				   if (-s->G[i] >= Gmax2)
							 {
					    Gmax2 = -s->G[i];
					    Gmax2_idx = i;
							 }
					 }
			  if (!is_lower_bound(s, i))	
					 {
				   if (s->G[i] >= Gmax1)
							 {
					    Gmax1 = s->G[i];
					    Gmax1_idx = i;
							 }
					 }
			 }
	 }
	if (Gmax1 + Gmax2 < s->eps)
 		return 1;
	*out_i = Gmax1_idx;
	*out_j = Gmax2_idx;
	return 0;
}

// Assembly:
movslq (%rdi), %rax
testq %rax, %rax
jle 0x9387a
pushq %rbx
movq 0x8(%rdi), %r9
movsd 0x142ae(%rip), %xmm2    # 0xa7a68
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
movapd 0xfa06(%rip), %xmm1     # 0xa31d0
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movapd %xmm2, %xmm0
cmpb $0x1, (%r9,%r10)
jne 0x93822
movq 0x18(%rdi), %r11
movb (%r11,%r10), %r11b
cmpb $0x1, %r11b
je 0x93804
movq 0x10(%rdi), %rbx
movsd (%rbx,%r10,8), %xmm3
xorpd %xmm1, %xmm3
ucomisd %xmm0, %xmm3
jb 0x93804
movapd %xmm3, %xmm0
movl %r10d, %r8d
testb %r11b, %r11b
je 0x93867
movq 0x10(%rdi), %r11
movsd (%r11,%r10,8), %xmm3
ucomisd %xmm2, %xmm3
jb 0x93867
movapd %xmm3, %xmm2
movl %r10d, %ecx
jmp 0x93867
movq 0x18(%rdi), %r11
movb (%r11,%r10), %r11b
cmpb $0x1, %r11b
je 0x9384b
movq 0x10(%rdi), %rbx
movsd (%rbx,%r10,8), %xmm3
xorpd %xmm1, %xmm3
ucomisd %xmm2, %xmm3
jb 0x9384b
movapd %xmm3, %xmm2
movl %r10d, %ecx
testb %r11b, %r11b
je 0x93867
movq 0x10(%rdi), %r11
movsd (%r11,%r10,8), %xmm3
ucomisd %xmm0, %xmm3
jb 0x93867
movapd %xmm3, %xmm0
movl %r10d, %r8d
incq %r10
cmpq %r10, %rax
jne 0x937d4
addsd %xmm2, %xmm0
popq %rbx
jmp 0x9388d
movsd 0x1b376(%rip), %xmm0    # 0xaebf8
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movsd 0x48(%rdi), %xmm1
movl $0x1, %eax
ucomisd %xmm0, %xmm1
ja 0x938a4
movl %r8d, (%rsi)
movl %ecx, (%rdx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmsolve.c
// Function: calculate_rho
double calculate_rho(Solverptr s)
{
 /*Last Changed 28.04.2005*/
	double r, ub = DBL_MAX, lb = -DBL_MAX, sum_free = 0, yG;
	int i, nr_free = 0;
	for (i = 0; i < s->active_size; i++)
	 {
		 yG = s->y[i] * s->G[i];
		 if (is_lower_bound(s, i))
		  {
		  	if (s->y[i] > 0)
				   ub = fmin(ub, yG);
			  else
				   lb = fmax(lb, yG);
			 }
		 else 
				 if (is_upper_bound(s, i))
					 {
			    if (s->y[i] < 0)
				     ub = fmin(ub, yG);
			    else
				     lb = fmax(lb, yG);
					 }
		   else
					 {
			    ++nr_free;
			    sum_free += yG;
					 }
	 }
	if (nr_free > 0)
		 r = sum_free / nr_free;
	else
		 r = (ub + lb) / 2;
	return r;
}

// Assembly:
movslq (%rdi), %rcx
testq %rcx, %rcx
jle 0x93fa6
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rdi
movsd 0x13b6e(%rip), %xmm0    # 0xa7a70
movsd 0x13b5e(%rip), %xmm2    # 0xa7a68
xorpd %xmm1, %xmm1
xorl %r8d, %r8d
xorl %eax, %eax
movsbl (%rdx,%r8), %r9d
xorps %xmm3, %xmm3
cvtsi2sd %r9d, %xmm3
mulsd (%rsi,%r8,8), %xmm3
movzbl (%rdi,%r8), %r10d
cmpl $0x1, %r10d
je 0x93f5e
testl %r10d, %r10d
jne 0x93f86
testb %r9b, %r9b
jle 0x93f63
movapd %xmm0, %xmm4
cmpunordsd %xmm0, %xmm4
movapd %xmm4, %xmm5
andpd %xmm3, %xmm5
minsd %xmm0, %xmm3
andnpd %xmm3, %xmm4
orpd %xmm5, %xmm4
movapd %xmm4, %xmm0
jmp 0x93f8c
testb %r9b, %r9b
js 0x93f3b
movapd %xmm2, %xmm4
cmpunordsd %xmm2, %xmm4
movapd %xmm4, %xmm5
andpd %xmm3, %xmm5
maxsd %xmm2, %xmm3
andnpd %xmm3, %xmm4
orpd %xmm5, %xmm4
movapd %xmm4, %xmm2
jmp 0x93f8c
incl %eax
addsd %xmm3, %xmm1
incq %r8
cmpq %r8, %rcx
jne 0x93f13
addsd %xmm2, %xmm0
mulsd 0xed74(%rip), %xmm0     # 0xa2d18
jmp 0x93fb0
xorl %eax, %eax
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testl %eax, %eax
jle 0x93fc3
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmtree.c
// Function: optimize_C_for_svmtreenode
int optimize_C_for_svmtreenode(Instanceptr* traindata, int positive, double* split)
{
 /*!Last Changed 22.07.2009*/
 int bestfeature = -1, currentfeature, count;
 int counts[2][MAXCLASSES];
 double C, currenterror, besterror = +INT_MAX, currentsplit;
 Instanceptr validate = NULL, learn = NULL;
 divide_instancelist(traindata, &validate, &learn, 4);
 count = data_size(validate);
 for (C = -2.0; C <= 2.0; C+= 0.2)
  {
   currentfeature = find_best_svmtree_feature(learn, &currentsplit, positive, C);
   find_counts_for_split(validate, currentfeature, currentsplit, counts[0], counts[1], UNIVARIATE_CONDITION);
   currenterror = error_of_split(counts, count);
   if (currenterror < besterror)
    {
     besterror = currenterror;
     bestfeature = currentfeature;
     *split = currentsplit;
    }
  }
 *traindata = learn;
 merge_instancelist(traindata, validate);
 return bestfeature;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdx, 0x20(%rsp)
movl %esi, %ebp
xorl %eax, %eax
leaq 0x10(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rdi, 0x18(%rsp)
movq %rbx, %rsi
movl $0x4, %ecx
callq 0x30746
movq (%rbx), %rdi
callq 0x2fa14
movl %eax, %r12d
movsd 0xf985(%rip), %xmm0     # 0xa4a38
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movsd 0xd457(%rip), %xmm1     # 0xa2518
movsd %xmm1, (%rsp)
leaq 0x38(%rsp), %rbx
leaq 0x40(%rsp), %r14
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movsd %xmm0, 0x30(%rsp)
callq 0x94cba
movl %eax, %r15d
movq 0x10(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
movl %eax, %esi
movsd %xmm0, 0x28(%rsp)
movq %r14, %rdx
leaq 0x108(%rsp), %rcx
xorl %r8d, %r8d
callq 0x9e1bf
movq %r14, %rdi
movl %r12d, %esi
callq 0x1d8fb
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x9513b
movq 0x20(%rsp), %rax
movsd 0x28(%rsp), %xmm1
movsd %xmm1, (%rax)
movl %r15d, %r13d
movsd %xmm0, (%rsp)
movsd 0x30(%rsp), %xmm0
addsd 0xfc3f(%rip), %xmm0     # 0xa4d88
movsd 0xdeef(%rip), %xmm1     # 0xa3040
ucomisd %xmm0, %xmm1
jae 0x950d0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdi
movq %rax, (%rdi)
movq 0x10(%rsp), %rsi
callq 0x2fd59
movl %r13d, %eax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/svmtree.c
// Function: create_svmtreechildren
int create_svmtreechildren(Decisionnodeptr node, Svmtree_parameterptr p, int positive)
{
 /*!Last Changed 03.07.2009*/
 int counts[2][MAXCLASSES], count, i;
 node->conditiontype = UNIVARIATE_CONDITION;
 if (!(can_be_divided(node, &(p->c45param))))
   return 1;
 node->featureno = optimize_C_for_svmtreenode(&(node->instances), positive, &(node->split));
 find_counts_for_split(node->instances, node->featureno, node->split, counts[0], counts[1], node->conditiontype);
 for (i = 0; i < 2; i++)
  {
   count = sum_of_list(counts[i], current_dataset->classno);
   if (count == 0)
    {
     make_leaf_node(node);
     return 1;
    }
  }
 if (!(make_children(node)))
   return 1;
 create_svmtreechildren(node->left, p, positive);
 create_svmtreechildren(node->right, p, positive);
 return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x0, 0x98(%rdi)
callq 0x1c8e2
testl %eax, %eax
je 0x95249
leaq 0x20(%r15), %rdi
leaq 0x28(%r15), %rdx
movl %ebx, %esi
callq 0x95064
movl %eax, 0x30(%r15)
movq 0x20(%r15), %rdi
movsd 0x28(%r15), %xmm0
leaq 0xc8(%rsp), %rcx
movl 0x98(%r15), %r8d
movq %rsp, %rdx
movl %eax, %esi
callq 0x9e1bf
xorl %r12d, %r12d
leaq 0x3d679(%rip), %r13     # 0xd2870
movl $0xc8, %ebp
leaq (%rsp,%r12), %rdi
movq (%r13), %rax
movl 0x10(%rax), %esi
callq 0x379e2
testl %eax, %eax
je 0x95241
addq %rbp, %r12
cmpq %rbp, %r12
je 0x951fc
movq %r15, %rdi
callq 0x9db4a
testl %eax, %eax
je 0x95249
movq (%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x95187
movq 0x8(%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x95187
jmp 0x95249
movq %r15, %rdi
callq 0x1c39c
movl $0x1, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/tests.c
// Function: assign_ranks_to_observations
void assign_ranks_to_observations(Obsptr obs, int size)
{
 /*!Last Changed 13.01.2009*/
 int i, sum, j, l;
 i = 0;
 while (i < size)
  {
   j = i;
   while (i + 1 < size && obs[i].observation == obs[i + 1].observation)
     i++;
   if (i != j)
    {
     sum = 0;
     for (l = j + 1; l <= i + 1; l++)
       sum += l;
     for (l = j; l <= i; l++)
       obs[l].rij = (sum + 0.0) / (i - j + 1);
    }
   else
     obs[i].rij = i + 1;
   i++;
  }
}

// Assembly:
testl %esi, %esi
jle 0x95348
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %eax
leaq 0x28(%rdi), %rcx
leaq 0x10(%rdi), %rdx
xorl %r8d, %r8d
movl %r8d, %r11d
movslq %r8d, %rbx
leal 0x1(%rbx), %r14d
cmpl %r14d, %esi
cmovgl %esi, %r14d
leal -0x1(%r14), %r9d
movq %rbx, %r10
shlq $0x5, %r10
leaq (%rcx,%r10), %r15
incq %rbx
cmpq %rax, %rbx
jge 0x952c1
movsd -0x20(%r15), %xmm0
incl %r8d
incq %rbx
ucomisd (%r15), %xmm0
leaq 0x20(%r15), %r15
jne 0x952bb
jnp 0x9529d
leal -0x1(%r8), %r9d
jmp 0x952c4
movl %r14d, %r8d
movl %r9d, %ebx
subl %r11d, %ebx
jne 0x952e4
xorps %xmm0, %xmm0
cvtsi2sd %r8d, %xmm0
movslq %r9d, %r9
shlq $0x5, %r9
movsd %xmm0, 0x10(%rdi,%r9)
jmp 0x9533a
xorpd %xmm0, %xmm0
jl 0x95315
movl %r11d, %r14d
notl %r14d
addl %r9d, %r14d
movq %rbx, %r15
imulq %r14, %r15
shrq %r15
leal 0x2(%r11), %r14d
imull %ebx, %r14d
addl %r11d, %r14d
leal (%r15,%r14), %ebx
incl %ebx
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
subl %r11d, %r9d
jl 0x9533a
incl %r9d
xorps %xmm1, %xmm1
cvtsi2sd %r9d, %xmm1
divsd %xmm1, %xmm0
addq %rdx, %r10
movsd %xmm0, (%r10)
addq $0x20, %r10
decl %r9d
jne 0x9532c
cmpl %esi, %r8d
jl 0x9527a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/tests.c
// Function: read_multivariate_observations_for_multiple_file
int read_multivariate_observations_for_multiple_file(char** files, matrix observations[], int L)
{
 /*!Last Changed 06.06.2010*/
 int i, j, k, colcount, rowcount;
 FILE* myfile;
 colcount = number_of_floats_in_file(files[0]);
 rowcount = file_length(files[0]);
 for (i = 1; i < L; i++)
  {
   if (number_of_floats_in_file(files[i]) != colcount)
    {
     printf(m1411);
     return -1;
    }
   if (file_length(files[i]) != rowcount)
    {
     printf(m1438);
     return -1;
    }
  }
 for (i = 0; i < L; i++)
  {
   observations[i] = matrix_alloc(rowcount, colcount);
   if ((myfile = fopen(files[i], "r")) == NULL)
    {
     printf(m1274, files[i]);
     return -1;
    }
   for (j = 0; j < observations[i].row; j++)
     for (k = 0; k < colcount; k++)
       fscanf(myfile, "%lf", &(observations[i].values[j][k]));
   fclose(myfile);
  }
 return colcount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r12d
movq %rsi, 0x20(%rsp)
movq %rdi, %r13
movq (%rdi), %rdi
callq 0x37ff4
movl %eax, %ebx
movq (%r13), %rdi
callq 0x37e22
movl %eax, (%rsp)
cmpl $0x2, %r12d
jl 0x95693
movl %r12d, %r14d
movl $0x1, %r15d
movq (%r13,%r15,8), %rdi
callq 0x37ff4
cmpl %ebx, %eax
jne 0x9577b
movq (%r13,%r15,8), %rdi
callq 0x37e22
cmpl (%rsp), %eax
jne 0x95784
incq %r15
cmpq %r15, %r14
jne 0x95666
testl %r12d, %r12d
jle 0x95795
movq %r13, 0x8(%rsp)
movl %r12d, %eax
movq %rax, 0x18(%rsp)
movl %ebx, %ebp
shlq $0x3, %rbp
leaq 0x1155a(%rip), %r13     # 0xa6c10
xorl %r12d, %r12d
movl %ebx, 0x4(%rsp)
movq %r12, %r14
shlq $0x4, %r14
movl (%rsp), %edi
movl %ebx, %esi
callq 0x3c6e5
movq 0x20(%rsp), %r15
movq %rax, (%r15,%r14)
movq %rdx, 0x8(%r15,%r14)
movq 0x8(%rsp), %rax
movq %r12, 0x10(%rsp)
movq (%rax,%r12,8), %rdi
leaq 0x1319e(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x9575d
movq %rax, %r12
addq %r15, %r14
cmpl $0x0, (%r14)
jle 0x95740
xorl %r15d, %r15d
testl %ebx, %ebx
jle 0x95731
xorl %ebx, %ebx
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdx
addq %rbx, %rdx
movq %r12, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %rbx
cmpq %rbx, %rbp
jne 0x95710
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
movl 0x4(%rsp), %ebx
jl 0x9570a
movq %r12, %rdi
callq 0x42a0
movq 0x10(%rsp), %r12
incq %r12
cmpq 0x18(%rsp), %r12
jne 0x956bd
jmp 0x95795
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xda98(%rip), %rdi      # 0xa320a
xorl %eax, %eax
callq 0x4030
jmp 0x95790
leaq 0x19668(%rip), %rdi     # 0xaedea
jmp 0x9578b
leaq 0x1962b(%rip), %rdi     # 0xaedb6
callq 0x4090
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/tests.c
// Function: read_observations_for_multiple_file
Obs* read_observations_for_multiple_file(char** files, int** counts, int* size, int* filecount)
{
 /*!Last Changed 13.01.2009*/
 int treatments = 0, total = 0, k = 0, i;
 Obs *obs = NULL;
 FILE* myfile;
 while (files[treatments])
  {
   treatments++;
   *counts = alloc(*counts, treatments * sizeof(int), treatments);
   *counts[treatments - 1] = file_length(files[treatments - 1]);
   total += *counts[treatments - 1];
   obs = alloc(obs, total * sizeof(Obs), total);
   if ((myfile = fopen(files[treatments - 1], "r")) == NULL)
    {
     printf(m1274, files[treatments - 1]);
     return 0;
    }
   for (i = 0; i < *counts[treatments - 1]; i++)
    {
     fscanf(myfile, "%lf", &obs[k + i].observation);
     obs[k + i].observation_no = treatments - 1;
     obs[k + i].rij = 0;
     obs[k + i].index = k + i;
    }
   k = total;
   fclose(myfile);
  }
 *size = k;
 *filecount = treatments;
 return obs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpq $0x0, (%rdi)
je 0x958ed
movq %rsi, %r13
movq %rdi, %rbx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
xorl %ebp, %ebp
movq $0x0, (%rsp)
xorl %r15d, %r15d
movq %rdi, 0x28(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0x1(%rbp), %r14
movq (%r13), %rdi
leaq 0x4(,%rbp,4), %rsi
movl %r14d, %edx
callq 0x390c8
movq %rax, (%r13)
movq (%rbx,%rbp,8), %rdi
callq 0x37e22
movq (%r13,%rbp,8), %rcx
movl %eax, (%rcx)
addl %r15d, %eax
movl %eax, 0xc(%rsp)
movslq %eax, %rdx
movq %rdx, %rsi
shlq $0x5, %rsi
movq (%rsp), %rdi
callq 0x390c8
movq %rax, (%rsp)
movq (%rbx,%rbp,8), %rdi
leaq 0x13055(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x958ff
movq %rax, %r12
movq %r14, 0x30(%rsp)
movq (%r13,%rbp,8), %rax
cmpl $0x0, (%rax)
leaq 0x113b1(%rip), %r13     # 0xa6c10
jle 0x958b5
movslq %r15d, %rax
movl %eax, %r15d
shlq $0x5, %rax
movq (%rsp), %rcx
leaq (%rcx,%rax), %r14
addq $0x18, %r14
xorl %ebx, %ebx
leaq -0x10(%r14), %rdx
movq %r12, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x4070
movl %ebp, -0x18(%r14)
movq $0x0, -0x8(%r14)
leal (%r15,%rbx), %eax
movl %eax, (%r14)
incq %rbx
movq 0x10(%rsp), %rax
movq (%rax,%rbp,8), %rax
movslq (%rax), %rax
addq $0x20, %r14
cmpq %rax, %rbx
jl 0x95879
movq %r12, %rdi
callq 0x42a0
movq 0x28(%rsp), %rbx
movq 0x30(%rsp), %rax
cmpq $0x0, (%rbx,%rax,8)
movq %rax, %rbp
movl 0xc(%rsp), %esi
movl %esi, %r15d
movq 0x10(%rsp), %r13
jne 0x957e5
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rdx
jmp 0x958f9
xorl %eax, %eax
xorl %esi, %esi
movq $0x0, (%rsp)
movl %esi, (%rdx)
movl %eax, (%rcx)
jmp 0x95919
movq (%rbx,%rbp,8), %rsi
leaq 0xd900(%rip), %rdi      # 0xa320a
movq $0x0, (%rsp)
xorl %eax, %eax
callq 0x4030
movq (%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/tests.c
// Function: read_multivariate_observations_for_two_file
int read_multivariate_observations_for_two_file(char** files, matrix observations[2])
{
 /*!Last Changed 12.01.2009*/
 int i, j, k, colcount, rowcount;
 FILE* myfile;
 colcount = number_of_floats_in_file(files[0]);
 if (number_of_floats_in_file(files[1]) != colcount)
  {
   printf(m1411);
   return -1;
  }
 for (i = 0; i < 2; i++)
  {
   rowcount = file_length(files[i]);
   observations[i] = matrix_alloc(rowcount, colcount);
   if ((myfile = fopen(files[i], "r")) == NULL)
    {
     printf(m1274, files[i]);
     return -1;
    }
   for (j = 0; j < observations[i].row; j++)
     for (k = 0; k < colcount; k++)
       fscanf(myfile, "%lf", &(observations[i].values[j][k]));
   fclose(myfile);
  }
 return colcount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbp
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x37ff4
movl %eax, %ebx
movq %r14, 0x8(%rsp)
movq 0x8(%r14), %rdi
callq 0x37ff4
cmpl %ebx, %eax
jne 0x95a2a
movl %ebx, %r12d
shlq $0x3, %r12
leaq 0x112a2(%rip), %r13     # 0xa6c10
xorl %r15d, %r15d
movl %ebx, 0x14(%rsp)
movq %rbp, 0x20(%rsp)
movq 0x8(%rsp), %rcx
movq (%rcx,%r15,8), %rdi
callq 0x37e22
movq %r15, %r14
shlq $0x4, %r14
movl %eax, %edi
movl %ebx, %esi
callq 0x3c6e5
movq %rax, (%rbp,%r14)
movq %rdx, 0x8(%rbp,%r14)
movq %r15, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq (%rax,%r15,8), %rdi
leaq 0x12ed8(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x95a38
movq %rbp, %rcx
movq %rax, %rbp
addq %rcx, %r14
cmpl $0x0, (%r14)
jle 0x95a09
xorl %r15d, %r15d
testl %ebx, %ebx
jle 0x959fa
xorl %ebx, %ebx
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdx
addq %rbx, %rdx
movq %rbp, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %rbx
cmpq %rbx, %r12
jne 0x959d9
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
movl 0x14(%rsp), %ebx
jl 0x959d3
movq %rbp, %rdi
callq 0x42a0
movq 0x18(%rsp), %rcx
leaq 0x1(%rcx), %r15
testq %rcx, %rcx
movq 0x20(%rsp), %rbp
je 0x9597a
jmp 0x95a59
leaq 0x193b9(%rip), %rdi     # 0xaedea
callq 0x4090
jmp 0x95a54
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xd7bd(%rip), %rdi      # 0xa320a
xorl %eax, %eax
callq 0x4030
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/tests.c
// Function: read_multivariate_observations_for_file
matrix read_multivariate_observations_for_file(char* filename)
{
 int j, k, colcount, rowcount;
 FILE* myfile;
 matrix observations;
 colcount = number_of_floats_in_file(filename);
 if (colcount == -1)
   return matrix_alloc(1, 1);
 rowcount = file_length(filename);
 observations = matrix_alloc(rowcount, colcount);
 if ((myfile = fopen(filename, "r")) == NULL)
  {
   printf(m1274, filename);
   return matrix_alloc(1, 1);
  }
 for (j = 0; j < observations.row; j++)
   for (k = 0; k < colcount; k++)
     fscanf(myfile, "%lf", &(observations.values[j][k]));
 fclose(myfile);
 return observations;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
callq 0x37ff4
cmpl $-0x1, %eax
je 0x95b46
movl %eax, %ebp
movq %r13, %rdi
callq 0x37e22
movl %eax, %edi
movl %ebp, %esi
callq 0x3c6e5
movq %rax, %rbx
movq %rdx, %r15
leaq 0x12de6(%rip), %rsi     # 0xa888f
movq %r13, %rdi
callq 0x40f0
testq %rax, %rax
je 0x95b35
movq %rax, %r12
movq %rbx, 0x8(%rsp)
testl %ebx, %ebx
jle 0x95b16
movq 0x8(%rsp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, 0x10(%rsp)
movl %ebp, %r14d
shlq $0x3, %r14
leaq 0x11131(%rip), %r13     # 0xa6c10
xorl %ebx, %ebx
movl %ebp, 0x4(%rsp)
testl %ebp, %ebp
jle 0x95b08
xorl %ebp, %ebp
movq (%r15,%rbx,8), %rdx
addq %rbp, %rdx
movq %r12, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %rbp
cmpq %rbp, %r14
jne 0x95aeb
incq %rbx
cmpq 0x10(%rsp), %rbx
movl 0x4(%rsp), %ebp
jne 0x95ae5
movq %r12, %rdi
callq 0x42a0
movq 0x8(%rsp), %rax
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd6ce(%rip), %rdi      # 0xa320a
movq %r13, %rsi
xorl %eax, %eax
callq 0x4030
movl $0x1, %edi
movl $0x1, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3c6e5
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/tests.c
// Function: read_observations_for_two_file
double** read_observations_for_two_file(char** files, int* counts)
{
 /*Last Changed 06.02.2004*/
 double** observations;
 int i, j;
 FILE* myfile;
 observations = (double **)safemalloc(2 * sizeof(double*), "find_observations_for_two_file", 4);
 for (i = 0;i < 2;i++)
  {
   counts[i] = file_length(files[i]);
   observations[i] = (double *)safemalloc(counts[i] * sizeof(double), "find_observations_for_two_file", 8);
   if ((myfile = fopen(files[i], "r")) == NULL)
    {
     printf(m1274, files[i]);
     return NULL;
    }
   for (j = 0; j < counts[i]; j++)
     fscanf(myfile, "%lf", &observations[i][j]);
   fclose(myfile);
  }
 return observations;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x19120(%rip), %rsi     # 0xaeca0
movl $0x10, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %rbp
leaq 0x11077(%rip), %rbx     # 0xa6c10
xorl %r13d, %r13d
movq %r15, 0x10(%rsp)
movq 0x8(%rsp), %r14
movq (%r14,%r13,8), %rdi
callq 0x37e22
movl %eax, (%r15,%r13,4)
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x190df(%rip), %rsi     # 0xaeca0
movl $0x8, %edx
callq 0x390f5
movq %rax, (%rbp,%r13,8)
movq (%r14,%r13,8), %rdi
leaq 0x12cb4(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x95c42
movq %rax, %r12
cmpl $0x0, (%r15,%r13,4)
movq %rbp, %r15
jle 0x95c20
xorl %r14d, %r14d
xorl %ebp, %ebp
movq (%r15,%r13,8), %rdx
addq %r14, %rdx
movq %r12, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
incq %rbp
movq 0x10(%rsp), %rax
movslq (%rax,%r13,4), %rax
addq $0x8, %r14
cmpq %rax, %rbp
jl 0x95bf7
movq %r12, %rdi
callq 0x42a0
leaq 0x1(%r13), %rax
testq %r13, %r13
movq %rax, %r13
movq %r15, %rbp
movq 0x10(%rsp), %r15
je 0x95ba1
jmp 0x95c5b
movq 0x8(%rsp), %rax
movq (%rax,%r13,8), %rsi
leaq 0xd5b8(%rip), %rdi      # 0xa320a
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x4030
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/tests.c
// Function: index_in_multiple_sample
int index_in_multiple_sample(int index, int* pos, matrix observations[], int L)
{
 int i, sum = 0;
 for (i = 0; i < L; i++)
   if (index < sum + observations[i].row)
    {
     *pos = index - sum;
     return i;
    }
   else
     sum += observations[i].row;
 return -1;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jle 0x96c92
movl %ecx, %r8d
xorl %ecx, %ecx
xorl %r9d, %r9d
movl (%rdx), %r10d
addl %r9d, %r10d
cmpl %edi, %r10d
jg 0x96c93
incq %rcx
addq $0x10, %rdx
movl %r10d, %r9d
cmpq %rcx, %r8
jne 0x96c78
retq
subl %r9d, %edi
movl %edi, (%rsi)
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/tests.c
// Function: distance_matrix_for_multiple_multivariate_sample
matrix distance_matrix_for_multiple_multivariate_sample(matrix observations[], int L, int N)
{
 int i, j, p, treatmentno, pos;
 double *row1, *row2;
 matrix result;
 p = observations[0].col;
 result = matrix_alloc(N, N);
 for (i = 0; i < N; i++)
   result.values[i][i] = -1;
 for (i = 0; i < N; i++)
  {
   treatmentno = index_in_multiple_sample(i, &pos, observations, L);
   row1 = observations[treatmentno].values[pos];
   for (j = i + 1; j < N; j++)
    {
     treatmentno = index_in_multiple_sample(j, &pos, observations, L);
     row2 = observations[treatmentno].values[pos];
     result.values[i][j] = euclidian_distance(row1, row2, p);
     result.values[j][i] = result.values[i][j];
    }
  }
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r13d
movl %esi, 0x4(%rsp)
movq %rdi, 0x8(%rsp)
movl 0x4(%rdi), %eax
movl %eax, 0x14(%rsp)
movl %edx, %edi
movl %edx, %esi
callq 0x3c6e5
movq %rax, 0x18(%rsp)
movq %rdx, %r12
movl %r13d, %r8d
testl %r13d, %r13d
jle 0x96cf1
xorl %eax, %eax
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq (%r12,%rax,8), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq %rax, %r8
jne 0x96ce1
testl %r13d, %r13d
jle 0x96e04
movl 0x4(%rsp), %ebp
movl $0x1, %r14d
xorl %r15d, %r15d
movq %r8, 0x30(%rsp)
cmpl $0x0, 0x4(%rsp)
jle 0x96d38
xorl %eax, %eax
movq 0x8(%rsp), %rcx
xorl %edx, %edx
movslq (%rcx), %rdi
movslq %edx, %rsi
addq %rdi, %rsi
cmpq %rsi, %r15
jl 0x96d41
incq %rax
addq $0x10, %rcx
movl %esi, %edx
cmpq %rax, %rbp
jne 0x96d1c
movq $-0x1, %rax
jmp 0x96d46
movl %r15d, %ebx
subl %edx, %ebx
leaq 0x1(%r15), %rcx
movq %rcx, 0x20(%rsp)
cmpq %r8, %rcx
movq %r14, 0x28(%rsp)
jae 0x96dee
shlq $0x4, %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx,%rax), %rax
movslq %ebx, %rcx
movq (%rax,%rcx,8), %r13
cmpl $0x0, 0x4(%rsp)
jle 0x96d9e
xorl %eax, %eax
movq 0x8(%rsp), %rcx
xorl %edx, %edx
movslq (%rcx), %rdi
movslq %edx, %rsi
addq %rdi, %rsi
cmpq %rsi, %r14
jl 0x96da7
incq %rax
addq $0x10, %rcx
movl %esi, %edx
cmpq %rax, %rbp
jne 0x96d82
movq $-0x1, %rax
jmp 0x96dac
movl %r14d, %ebx
subl %edx, %ebx
shlq $0x4, %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx,%rax), %rax
movslq %ebx, %rcx
movq (%rax,%rcx,8), %rsi
movq %r13, %rdi
movl 0x14(%rsp), %edx
callq 0x379fb
movq (%r12,%r15,8), %rax
movsd %xmm0, (%rax,%r14,8)
movq (%r12,%r14,8), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r14
movq 0x30(%rsp), %r8
cmpq %r8, %r14
jne 0x96d72
movq 0x28(%rsp), %r14
incq %r14
movq 0x20(%rsp), %r15
cmpq %r8, %r15
jne 0x96d0c
movq 0x18(%rsp), %rax
movq %r12, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/tests.c
// Function: save_mst_to_array_variables
void save_mst_to_array_variables(Graphptr mst, matrix observations[], int L)
{
 int i, j, k, fromindex, toindex, from, to;
 Point p1, p2;
 k = 1;
 for (i = 0; i < mst->nvertices; i++)
   for (j = 0; j < mst->degree[i]; j++)
     if (i < mst->edges[i][j].v)
      {
       fromindex = index_in_multiple_sample(i, &from, observations, L);
       toindex = index_in_multiple_sample(mst->edges[i][j].v, &to, observations, L);
       p1.x = observations[fromindex].values[from][0];
       p1.y = observations[fromindex].values[from][1];
       p2.x = observations[toindex].values[to][0];
       p2.y = observations[toindex].values[to][1];
       write_array_variables("aout", k, 1, "ffff", p1.x, p1.y, p2.x, p2.y); 
       k++;
      }
}

// Assembly:
cmpl $0x0, 0xf46280(%rdi)
jle 0x96f85
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edx, %r12d
movl $0x1, %ebx
xorl %r13d, %r13d
movl %edx, 0x4(%rsp)
cmpl $0x0, 0xf42400(%rdi,%r13,4)
jle 0x96f64
imulq $0x3e80, %r13, %rbp     # imm = 0x3E80
addq %rdi, %rbp
xorl %r15d, %r15d
movq %rbp, 0x10(%rsp)
movq %r15, %rax
shlq $0x4, %rax
movslq (%rax,%rbp), %rcx
cmpq %rcx, %r13
jge 0x96f50
movq %rdi, %rbp
testl %edx, %edx
jle 0x96ea9
xorl %eax, %eax
movq %r14, %r9
xorl %r10d, %r10d
movslq (%r9), %r8
movslq %r10d, %rdi
addq %r8, %rdi
cmpq %rdi, %r13
jl 0x96eb2
incq %rax
addq $0x10, %r9
movl %edi, %r10d
cmpq %rax, %r12
jne 0x96e8c
movq $-0x1, %rax
jmp 0x96ebc
movl %r13d, %edi
subl %r10d, %edi
movl %edi, 0xc(%rsp)
testl %edx, %edx
jle 0x96ee1
xorl %edx, %edx
movq %r14, %r9
xorl %edi, %edi
movl (%r9), %r8d
addl %edi, %r8d
cmpl %ecx, %r8d
jg 0x96eea
incq %rdx
addq $0x10, %r9
movl %r8d, %edi
cmpq %rdx, %r12
jne 0x96ec7
movq $-0x1, %rdx
jmp 0x96ef0
subl %edi, %ecx
movl %ecx, 0x8(%rsp)
shlq $0x4, %rax
movq 0x8(%r14,%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
shlq $0x4, %rdx
movq 0x8(%r14,%rdx), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm3
leaq 0xb883(%rip), %rdi      # 0xa27b0
movl %ebx, %esi
movl $0x1, %edx
leaq 0x17da1(%rip), %rcx     # 0xaecdc
movb $0x4, %al
callq 0x32c64
incl %ebx
movl 0x4(%rsp), %edx
movq %rbp, %rdi
movq 0x10(%rsp), %rbp
incq %r15
movslq 0xf42400(%rdi,%r13,4), %rax
cmpq %rax, %r15
jl 0x96e69
incq %r13
movslq 0xf46280(%rdi), %rax
cmpq %rax, %r13
jl 0x96e48
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/tests.c
// Function: minimum_spanning_tree_from_observations
Graphptr minimum_spanning_tree_from_observations(matrix observations[], matrix distancematrix, int L, int N)
{
 Graphptr g, mst;
 g = graph_from_distancematrix(distancematrix);
 mst = minimum_spanning_tree_prim(g);
 if (get_parameter_o("displayresulton") == ON)
  {
   printf("MST\n");
   print_graph(mst);
  }
 if (mst->nedges != (2 * (N - 1)))
  {
   printf("Minimum spanning tree can not be found\n");
   return NULL;
  }
 free_graph(g); 
 return mst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %r8d, %r14d
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1b535
movq %rax, %r15
movq %rax, %rdi
callq 0x1afa6
movq %rax, %rbx
leaq 0xc391(%rip), %rdi      # 0xa3621
callq 0x536e7
cmpl $0x1, %eax
jne 0x972ae
leaq 0x17b8c(%rip), %rdi     # 0xaee2d
callq 0x4090
movq %rbx, %rdi
callq 0x1ae5a
leal -0x2(,%r14,2), %eax
cmpl %eax, 0xf46284(%rbx)
jne 0x972c8
movq %r15, %rdi
callq 0x1b530
jmp 0x972d6
leaq 0x17b62(%rip), %rdi     # 0xaee31
callq 0x4090
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/tests.c
// Function: height_directed_preorder_traversal
void height_directed_preorder_traversal(Graphptr mst, int* visit_count, int current, matrix distancematrix)
{
 int i, to, minheight, selected;
 double mindistance;
 mst->visitorder[current] = *visit_count;
 while (1)
  {
   selected = -1;
   minheight = +INT_MAX;
   mindistance = +LONG_MAX;
   for (i = 0; i < mst->degree[current]; i++)
    {
     to = mst->edges[current][i].v;
     if (mst->visitorder[to] == 0)
       if (mst->height[to] < minheight || (mst->height[to] == minheight && distancematrix.values[current][to] < mindistance))
        {
         selected = to;
         minheight = mst->height[to];
         mindistance = distancematrix.values[current][to];
        }
    }
   if (selected != -1)
    {
     (*visit_count)++;
     height_directed_preorder_traversal(mst, visit_count, selected, distancematrix);
    }
   else 
     break;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl (%rsi), %eax
movslq %edx, %r13
movl %eax, 0xf433a0(%rdi,%r13,4)
imulq $0x3e80, %r13, %rbp     # imm = 0x3E80
addq %rdi, %rbp
movslq 0xf42400(%r12,%r13,4), %rax
testq %rax, %rax
jle 0x9737b
shlq $0x4, %rax
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movsd 0xbffe(%rip), %xmm0     # 0xa3330
movl (%rbp,%rcx), %edi
movslq %edi, %r8
cmpl $0x0, 0xf433a0(%r12,%r8,4)
jne 0x97370
movl 0xf44340(%r12,%r8,4), %r9d
cmpl %esi, %r9d
jge 0x97362
movq (%rbx,%r13,8), %rdx
movsd (%rdx,%r8,8), %xmm0
movl %r9d, %esi
movl %edi, %edx
jmp 0x97370
jne 0x97370
movq (%rbx,%r13,8), %r10
ucomisd (%r10,%r8,8), %xmm0
ja 0x97351
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x97332
jmp 0x97380
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpl $-0x1, %edx
je 0x9739e
incl (%r15)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
movq %rbx, %r8
callq 0x972df
jmp 0x9730d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/tests.c
// Function: ranks_from_minimum_spanning_tree
void ranks_from_minimum_spanning_tree(Graphptr mst, matrix distancematrix)
{
 double *path_lengths;
 int j, maxecc, ecc, i, visitorder, root, N;
 maxecc = 0;
 N = mst->nvertices;
 for (i = 0; i < N; i++)
  {
   ecc = eccentricity(mst, i);
   if (ecc > maxecc)
    {
     root = i;
     maxecc = ecc;
    }
  }
 path_lengths = shortest_path(mst, root);
 for (i = 0; i < N; i++)
  {
   if (mst->height[i] < path_lengths[i])
     mst->height[i] = path_lengths[i];
   j = mst->parents[i];
   while (j != -1)
    {
     if (mst->height[j] < path_lengths[i])
       mst->height[j] = path_lengths[i];
     j = mst->parents[j];
    }
  }
 safe_free(path_lengths);
 visitorder = 1;
 height_directed_preorder_traversal(mst, &visitorder, root, distancematrix);
 if (get_parameter_o("displayresulton") == ON)
  {
   printf("Visit Order\n");
   for (i = 0; i < N; i++)
     printf("%d: %d\n", i, mst->visitorder[i]);
  } 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
movl 0xf46280(%rdi), %r13d
xorl %r12d, %r12d
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x1b29b
cmpl %r14d, %eax
cmovgl %eax, %r14d
cmovgl %r12d, %ebp
incl %r12d
cmpl %r12d, %r13d
jne 0x973d3
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b153
xorl %ecx, %ecx
xorps %xmm1, %xmm1
cvtsi2sdl 0xf44340(%rbx,%rcx,4), %xmm1
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
jbe 0x9741f
movl %edx, 0xf44340(%rbx,%rcx,4)
movl 0xf452e0(%rbx,%rcx,4), %esi
cmpl $-0x1, %esi
je 0x97450
movslq %esi, %rsi
xorps %xmm1, %xmm1
cvtsi2sdl 0xf44340(%rbx,%rsi,4), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x97447
movl %edx, 0xf44340(%rbx,%rsi,4)
movl 0xf452e0(%rbx,%rsi,4), %esi
jmp 0x97426
incq %rcx
cmpq %r13, %rcx
jne 0x973fd
movq %rax, %rdi
callq 0x39194
leaq 0x14(%rsp), %rsi
movl $0x1, (%rsi)
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
movq 0x8(%rsp), %r8
callq 0x972df
leaq 0xc19d(%rip), %rdi      # 0xa3621
callq 0x536e7
cmpl $0x1, %eax
jne 0x974c1
leaq 0x179c3(%rip), %rdi     # 0xaee58
callq 0x4090
leaq 0x158ba(%rip), %r14     # 0xacd5b
xorl %r15d, %r15d
movl 0xf433a0(%rbx,%r15,4), %edx
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x4030
incq %r15
cmpq %r15, %r13
jne 0x974a4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/tests.c
// Function: kruskalwallis
double kruskalwallis(char **files)
{
 /*!Last Changed 13.01.2009 added find_observations_for_multiple_file, qsort, assign_ranks_to_observations*/
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 30.01.2002*/
 int treatments, df;
 int *counts = NULL, i, k = 0, n;
 Obs *obs;
 double *T, S, sumd, res;
 obs = read_observations_for_multiple_file(files, &counts, &k, &treatments);
 T = (double *)safecalloc(treatments, sizeof(double), "kruskalwallis", 27);
 qsort(obs, k, sizeof(Obs), sort_function_observation_ascending);
 assign_ranks_to_observations(obs, k);
 for (i = 0; i < k; i++)
   T[obs[i].observation_no] += obs[i].rij;
 sumd = 0;
 for (i = 0; i < treatments; i++)
   sumd += T[i] * T[i] / counts[i];
	safe_free(counts);
 safe_free(T);
 n = counts[0];
 S = sumd * ((12 + 0.0) / (treatments * n * (treatments * n + 1))) - 3 * (treatments * n + 1);
 safe_free(obs);
 df = treatments - 1;
 res = chi_square(df, S);
 return 1 - res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x10(%rsp), %r12
movl $0x0, (%r12)
leaq 0x14(%rsp), %rbx
movq %r12, %rdx
movq %rbx, %rcx
callq 0x957a6
movq %rax, %r14
movslq (%rbx), %rbx
leaq 0x16b80(%rip), %rdx     # 0xaed05
movl $0x8, %esi
movq %rbx, %rdi
movl $0x1b, %ecx
callq 0x39210
movq %rax, %r15
movslq (%r12), %r12
leaq -0x5eb80(%rip), %rcx    # 0x39625
movl $0x20, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x4240
movq %r14, %rdi
movl %r12d, %esi
callq 0x95260
testq %r12, %r12
jle 0x981eb
shlq $0x5, %r12
xorl %eax, %eax
movsd 0x10(%r14,%rax), %xmm0
movslq (%r14,%rax), %rcx
addsd (%r15,%rcx,8), %xmm0
movsd %xmm0, (%r15,%rcx,8)
addq $0x20, %rax
cmpq %rax, %r12
jne 0x981cb
xorpd %xmm2, %xmm2
testl %ebx, %ebx
jle 0x9821c
movq 0x8(%rsp), %rax
xorl %ecx, %ecx
movsd (%r15,%rcx,8), %xmm0
mulsd %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl (%rax,%rcx,4), %xmm1
divsd %xmm1, %xmm0
addsd %xmm0, %xmm2
incq %rcx
cmpq %rcx, %rbx
jne 0x981fa
movsd %xmm2, (%rsp)
movq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x39194
movq %r15, %rdi
callq 0x39194
movl (%r12), %eax
imull %ebx, %eax
leal 0x1(%rax), %ecx
imull %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x16a16(%rip), %xmm1    # 0xaec68
divsd %xmm0, %xmm1
mulsd (%rsp), %xmm1
leal (%rcx,%rcx,2), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %r14, %rdi
callq 0x39194
decl %ebx
movl %ebx, %edi
movsd (%rsp), %xmm0
callq 0x1f4cd
movsd 0xa294(%rip), %xmm1     # 0xa2520
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq