LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/svmsimplex.c
// Function: solve_one_vs_one_svm
Svm_simplex_modelptr solve_one_vs_one_svm(Instanceptr* data, Svm_simplex_parameterptr parameters)
{
 int i, j, k;
 Instanceptr list;
 Svm_simplex_modelptr model;
 model = safemalloc(sizeof(Svm_simplex_model), "solve_one_vs_one_svm", 4);
 model->problemcount = current_dataset->classno * (current_dataset->classno - 1) / 2;
 model->models = safemalloc(model->problemcount * sizeof(Svm_binary_modelptr), "solve_one_vs_one_svm", 6);
 k = 0;
 for (i = 0; i < current_dataset->classno; i++)
   for (j = i + 1; j < current_dataset->classno; j++)
    {
     divide_instancelist_one_vs_one(data, &list, i, j);
     model->models[k] = solve_binary_svm(list, parameters, i);
     k++;
     merge_instancelist(data, list);
    }
 return model;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
leaq 0x20b56(%rip), %rsi     # 0xee252
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x30(%rbp)
leaq 0x3812f(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %eax
leaq 0x38122(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
imull %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
leaq 0x20b06(%rip), %rsi     # 0xee252
movl $0x6, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x380c7(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xcd807
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
leaq 0x380a8(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xcd7f7
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq -0x28(%rbp), %rsi
callq 0x45900
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xcd010
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x44f40
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xcd78e
jmp 0xcd7f9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcd76f
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x38005(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x4, %esi
leaq 0x20a19(%rip), %rdx     # 0xee267
movl $0x2, %ecx
callq 0x52f40
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x37fcc(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xcd908
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
leaq 0x37fad(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xcd8f8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xcd510
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x40(%rbp), %xmm0
jbe 0xcd8da
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0xcd8eb
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0xcd8ed
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xcd889
jmp 0xcd8fa
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcd86a
movq -0x30(%rbp), %rdi
leaq 0x37f2d(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x50070
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x52e80
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
leaq 0x208f6(%rip), %rsi     # 0xee252
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
leaq 0x37ecf(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
leaq 0x208c3(%rip), %rsi     # 0xee252
movl $0x5, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x37e8b(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xcd9eb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xcd010
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcd9ab
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xcda3e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xcd5d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xcda13
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x37dc5(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x8, %esi
leaq 0x207ed(%rip), %rdx     # 0xee27b
movl $0x3, %ecx
callq 0x52f40
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x37d93(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xcdaea
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xcd510
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcdaa3
movq -0x28(%rbp), %rdi
leaq 0x37d4b(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x50490
movl %eax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x52e80
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xcdb20
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0xcdbc1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movb $0x1, (%rax,%rcx)
jmp 0xcdbfb
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
xorps %xmm0, %xmm0
ucomisd (%rax,%rcx,8), %xmm0
jb 0xcdbe9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0xcdbf9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movb $0x2, (%rax,%rcx)
jmp 0xcdbfb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0xcdd06
jmp 0xcdcf2
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0xcdd1f
jmp 0xcdcfc
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xcdd38
jmp 0xcdd51
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xcb330
movq %rax, -0x8(%rbp)
jmp 0xcdd59
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xcb8f0
movq %rax, -0x8(%rbp)
jmp 0xcdd59
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xcb5c0
movq %rax, -0x8(%rbp)
jmp 0xcdd59
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0xcdda6
jmp 0xcdd92
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0xcddbb
jmp 0xcdd9c
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0xcddd0
jmp 0xcdde3
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0xcb460
jmp 0xcdde3
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0xcba50
jmp 0xcdde3
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0xcb670
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x11(%rbp), %dl
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x53400
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0xc(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movslq -0x10(%rbp), %rax
addq %rax, %rsi
callq 0x533a0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movslq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x53400
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rsi
movslq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x53400
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rsi
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x533d0
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rsi
movslq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x53400
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jne 0xcdf50
jmp 0xce059
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jge 0xcdfa3
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0xc(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xcdf59
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xce059
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xcdc90
cmpl $0x0, %eax
je 0xce049
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x78(%rax), %edx
callq 0xcdcd0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jge 0xce047
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xce000
jmp 0xce049
jmp 0xce04b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xcdfaa
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/svmtree.c
// Function: support_vector_length
int support_vector_length(Svm_nodeptr sv)
{
 int i = 0;
 while (sv[i].index != -1)
   i++;
 return i + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
je 0xd068e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd066f
movl -0xc(%rbp), %eax
addl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movsd 0x10eeb(%rip), %xmm0    # 0xe2010
movsd %xmm0, -0x1d8(%rbp)
movq $0x0, -0x1e8(%rbp)
movq $0x0, -0x1f0(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
leaq -0x1f0(%rbp), %rdx
movl $0x4, %ecx
callq 0x45f60
movq -0x1e8(%rbp), %rdi
callq 0x449f0
movl %eax, -0x24(%rbp)
movsd 0x13742(%rip), %xmm0    # 0xe48b8
movsd %xmm0, -0x1c8(%rbp)
movsd 0x11b1a(%rip), %xmm0    # 0xe2ca0
ucomisd -0x1c8(%rbp), %xmm0
jb 0xd1256
movq -0x1f0(%rbp), %rdi
movl -0xc(%rbp), %edx
movsd -0x1c8(%rbp), %xmm0
leaq -0x1e0(%rbp), %rsi
callq 0xd0ab0
movl %eax, -0x20(%rbp)
movq -0x1e8(%rbp), %rdi
movl -0x20(%rbp), %esi
movsd -0x1e0(%rbp), %xmm0
leaq -0x1c0(%rbp), %rdx
leaq -0x1c0(%rbp), %rcx
addq $0xc8, %rcx
xorl %r8d, %r8d
callq 0xdd8e0
leaq -0x1c0(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x2adc0
movsd %xmm0, -0x1d0(%rbp)
movsd -0x1d0(%rbp), %xmm1
movsd -0x1d8(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd1237
movsd -0x1d0(%rbp), %xmm0
movsd %xmm0, -0x1d8(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movsd -0x1e0(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0xd1239
movsd 0x135df(%rip), %xmm0    # 0xe4820
addsd -0x1c8(%rbp), %xmm0
movsd %xmm0, -0x1c8(%rbp)
jmp 0xd117e
movq -0x1f0(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x1e8(%rbp), %rsi
callq 0x44f40
movl -0x1c(%rbp), %eax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x98(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x29340
cmpl $0x0, %eax
jne 0xd12c2
movl $0x1, -0x4(%rbp)
jmp 0xd13d6
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
addq $0x28, %rdx
callq 0xd1100
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %esi
movq -0x10(%rbp), %rax
movsd 0x28(%rax), %xmm0
leaq -0x1b0(%rbp), %rdx
leaq -0x1b0(%rbp), %rcx
addq $0xc8, %rcx
movq -0x10(%rbp), %rax
movl 0x98(%rax), %r8d
callq 0xdd8e0
movl $0x0, -0x1b8(%rbp)
cmpl $0x2, -0x1b8(%rbp)
jge 0xd1391
movslq -0x1b8(%rbp), %rax
leaq -0x1b0(%rbp), %rdi
imulq $0xc8, %rax, %rax
addq %rax, %rdi
leaq 0x344ee(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x50940
movl %eax, -0x1b4(%rbp)
cmpl $0x0, -0x1b4(%rbp)
jne 0xd137e
movq -0x10(%rbp), %rdi
callq 0x28a30
movl $0x1, -0x4(%rbp)
jmp 0xd13d6
jmp 0xd1380
movl -0x1b8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1b8(%rbp)
jmp 0xd132a
movq -0x10(%rbp), %rdi
callq 0xdcde0
cmpl $0x0, %eax
jne 0xd13a8
movl $0x1, -0x4(%rbp)
jmp 0xd13d6
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xd1280
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xd1280
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xd1521
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x1d(%rbp)
jge 0xd145c
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
ucomisd 0x8(%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xd1465
jmp 0xd1470
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd1414
movl -0x10(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0xd14f5
movl $0x0, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jg 0xd14a9
movl -0x1c(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd1488
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0xd14f3
cvtsi2sdl -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
movl -0x10(%rbp), %eax
subl -0x18(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd14af
jmp 0xd1513
movl -0x10(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd1402
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x51200
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x51200
cmpl -0x28(%rbp), %eax
je 0xd1d9b
leaq 0x1c588(%rip), %rdi     # 0xee310
movb $0x0, %al
callq 0x4030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd1edd
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0xd1ed7
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x50f90
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x2c(%rbp), %edi
movl -0x28(%rbp), %esi
callq 0x57fc0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x16397(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xd1e44
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x11059(%rip), %rdi     # 0xe2e8a
movb $0x0, %al
callq 0x4030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd1edd
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jge 0xd1ec0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0xd1eb3
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movslq -0x24(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x14927(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd1e68
jmp 0xd1eb5
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd1e4b
movq -0x38(%rbp), %rdi
callq 0x4250
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd1da2
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x51200
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0xd1f27
movl $0x1, %esi
movl %esi, %edi
callq 0x57fc0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0xd2010
movq -0x18(%rbp), %rdi
callq 0x50f90
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x57fc0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x16245(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xd1f98
movq -0x18(%rbp), %rsi
leaq 0x10f0f(%rip), %rdi     # 0xe2e8a
movb $0x0, %al
callq 0x4030
movl $0x1, %esi
movl %esi, %edi
callq 0x57fc0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0xd2010
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x40(%rbp), %eax
jge 0xd1ff7
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xd1fea
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movslq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x147f0(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd1fae
jmp 0xd1fec
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd1f9f
movq -0x30(%rbp), %rdi
callq 0x4250
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x10, %edi
leaq 0x1c34d(%rip), %rsi     # 0xee389
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
jge 0xd2151
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x50f90
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movslq (%rax,%rcx,4), %rdi
shlq $0x3, %rdi
leaq 0x1c2f9(%rip), %rsi     # 0xee389
movl $0x8, %edx
callq 0x52d70
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x160ea(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xd20ef
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x10dac(%rip), %rdi     # 0xe2e8a
movb $0x0, %al
callq 0x4030
movq $0x0, -0x8(%rbp)
jmp 0xd2159
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xd213a
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movslq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x146a0(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xd20f6
movq -0x30(%rbp), %rdi
callq 0x4250
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd2051
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xd39ab
movl -0x8(%rbp), %eax
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rdx
movslq -0x20(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rdx
addl (%rdx), %ecx
cmpl %ecx, %eax
jge 0xd3987
movl -0x8(%rbp), %ecx
subl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd39b2
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xd39a0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd3950
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x57fc0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xd3a36
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd 0xf022(%rip), %xmm0     # 0xe2a48
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd3a06
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xd3b35
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq -0x34(%rbp), %rsi
callq 0xd3930
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xd3b25
movl -0x28(%rbp), %edi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq -0x34(%rbp), %rsi
callq 0xd3930
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x50990
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xd3a87
jmp 0xd3b27
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd3a3d
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xf46280(%rcx), %eax
jge 0xd3cff
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x18(%rbp), %rdx
cmpl 0xf42400(%rcx,%rdx,4), %eax
jge 0xd3cef
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x18(%rbp), %rdx
imulq $0x3e80, %rdx, %rdx     # imm = 0x3E80
addq %rdx, %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jge 0xd3cdf
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x2c(%rbp), %rsi
callq 0xd3930
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0x3e80, %rcx, %rcx     # imm = 0x3E80
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x30(%rbp), %rsi
callq 0xd3930
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x20(%rbp), %esi
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
movsd -0x50(%rbp), %xmm2
movsd -0x48(%rbp), %xmm3
leaq 0xe7f2(%rip), %rdi      # 0xe24b5
movl $0x1, %edx
leaq 0x1a712(%rip), %rcx     # 0xee3e1
movb $0x4, %al
callq 0x490c0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd3ce1
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd3b8b
jmp 0xd3cf1
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd3b71
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x27140
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x26870
movq %rax, -0x38(%rbp)
leaq 0xf0fb(%rip), %rdi      # 0xe326b
callq 0x79440
cmpl $0x1, %eax
jne 0xd4191
leaq 0x1a293(%rip), %rdi     # 0xee414
movb $0x0, %al
callq 0x4030
movq -0x38(%rbp), %rdi
callq 0x26610
movq -0x38(%rbp), %rax
movl 0xf46284(%rax), %eax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
shll %ecx
cmpl %ecx, %eax
je 0xd41bf
leaq 0x1a26b(%rip), %rdi     # 0xee419
movb $0x0, %al
callq 0x4030
movq $0x0, -0x8(%rbp)
jmp 0xd41d0
movq -0x30(%rbp), %rdi
callq 0x27120
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rcx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, 0xf433a0(%rax,%rcx,4)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
movsd 0xed8a(%rip), %xmm0     # 0xe2fb0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
cmpl 0xf42400(%rcx,%rdx,4), %eax
jge 0xd430a
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x3e80, %rcx, %rcx     # imm = 0x3E80
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpl $0x0, 0xf433a0(%rax,%rcx,4)
jne 0xd42fa
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl 0xf44340(%rax,%rcx,4), %eax
cmpl -0x30(%rbp), %eax
jl 0xd42c6
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl 0xf44340(%rax,%rcx,4), %eax
cmpl -0x30(%rbp), %eax
jne 0xd42f8
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x40(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd42f8
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl 0xf44340(%rax,%rcx,4), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0xd42fa
jmp 0xd42fc
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xd4232
cmpl $-0x1, -0x34(%rbp)
je 0xd4335
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x34(%rbp), %edx
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %r8
callq 0xd41e0
jmp 0xd4337
jmp 0xd433c
jmp 0xd4210
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/tests.c
// Function: no_test
int no_test(char **files, int *which, double confidence, double *real_confidence)
{
 /*Last Changed 07.04.2006*/
 int j, counts[2], plus, minus;
 double **observations;
 observations = read_observations_for_two_file(files, counts);
 if (!observations)
  {
   return 0;
  }
 if (counts[0] != counts[1])
   return 0;
 plus = 0;
 minus = 0;
 for (j = 0; j < counts[0]; j++)
  {
   if (observations[0][j] > observations[1][j])
     plus++;
   if (observations[0][j] < observations[1][j])
     minus++;
  }
 free_2d((void**)observations, 2);
 if (plus > minus)
  {
   (*which) = 1;
   if (!get_parameter_o("accuracy")) 
     (*which) = 3 - (*which); 
   (*real_confidence) = 1;
   return 1;
  }
 else
  {
   (*which) = 2; 
   if (!get_parameter_o("accuracy")) 
     (*which) = 3 - (*which); 
   (*real_confidence) = 0;
   return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xd2020
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xd645d
movl $0x0, -0x4(%rbp)
jmp 0xd6590
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
je 0xd6471
movl $0x0, -0x4(%rbp)
jmp 0xd6590
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xd64f7
movq -0x48(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0xd64ba
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd64ea
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xd64ec
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xd6486
movq -0x48(%rbp), %rdi
movl $0x2, %esi
callq 0x52e20
movl -0x38(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jle 0xd6552
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
leaq 0x11e9e(%rip), %rdi     # 0xe83bc
callq 0x79440
cmpl $0x0, %eax
jne 0xd6539
movq -0x18(%rbp), %rax
movl $0x3, %ecx
subl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movsd 0xbad3(%rip), %xmm0     # 0xe2018
movsd %xmm0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xd6590
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
leaq 0x11e59(%rip), %rdi     # 0xe83bc
callq 0x79440
cmpl $0x0, %eax
jne 0xd657e
movq -0x18(%rbp), %rax
movl $0x3, %ecx
subl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)