LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svmregtree.c
// Function: create_svmregtree
int create_svmregtree(Regressionnodeptr node, Regtree_parameterptr param)
{
 /*!Last Changed 01.11.2009*/
 Instanceptr leftinstances = NULL, rightinstances = NULL;
 if (!(can_be_divided_regression(node, param)))
   return 1;
 node->featureno = optimize_C_for_svmregtreenode(node, param->leaftype);
 divide_instancelist_according_to_split(&(node->instances), &leftinstances, &rightinstances, node->featureno, node->split);
 if (leftinstances == NULL || rightinstances == NULL)
  {
   make_leaf_regression_node(node, param->leaftype);
   node->instances = restore_instancelist(node->instances, leftinstances);
   merge_instancelist(&(node->instances), rightinstances);
   return 1;
  }
 node->instances = restore_instancelist(node->instances, leftinstances);
 merge_instancelist(&(node->instances), rightinstances);
 if (!(make_regression_children(node, param->leaftype)))
   return 1;
 create_svmregtree(node->left, param);
 create_svmregtree(node->right, param);
 return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
andq $0x0, 0x10(%rsp)
movq %rdi, %rbx
andq $0x0, 0x8(%rsp)
callq 0x6d588
testl %eax, %eax
je 0x867d2
movl (%r14), %esi
movq %rbx, %rdi
callq 0x86537
movl %eax, 0x68(%rbx)
leaq 0x20(%rbx), %r15
movsd 0x50(%rbx), %xmm0
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %ecx
callq 0x2caf4
movq (%r12), %rsi
testq %rsi, %rsi
je 0x867a8
cmpq $0x0, 0x8(%rsp)
je 0x867a8
movq 0x20(%rbx), %rdi
callq 0x2d2da
movq %rax, 0x20(%rbx)
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2c6e4
movl (%r14), %esi
movq %rbx, %rdi
callq 0x6d17d
testl %eax, %eax
je 0x867d2
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x866fd
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x866fd
jmp 0x867d2
movl (%r14), %esi
movq %rbx, %rdi
callq 0x6c64d
movq 0x20(%rbx), %rdi
movq 0x10(%rsp), %rsi
callq 0x2d2da
movq %rax, 0x20(%rbx)
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2c6e4
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svmsimplex.c
// Function: kernel_value
double kernel_value(Instanceptr inst1, Instanceptr inst2, Kernel_parameter kernel)
{
	switch (kernel.type)
  {
   case    KLINEAR :return dot_product(inst1, inst2);
                    break;
   case    KPOLY   :return pow(kernel.gamma * dot_product(inst1, inst2) + kernel.coef0, kernel.degree);
                    break;
   case    KRBF    :return exp(-kernel.gamma * distance_between_instances(inst1, inst2));
                    break;
   case    KSIGMOID:return tanh(kernel.gamma * dot_product(inst1, inst2) + kernel.coef0);
                    break;
   case KPREDEFINED:return current_dataset->kernel->values[(int) real_feature(inst1, 0)][(int) real_feature(inst2, 0)];
                    break;
   default         :printf(m1232, kernel.type);
                    return 0;
                    break;
  }
 return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x30(%rsp), %esi
cmpq $0x4, %rsi
ja 0x868e7
leaq 0x30(%rsp), %r14
leaq 0x1b320(%rip), %rax     # 0xa1b28
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x2be93
leaq 0x47049(%rip), %rax     # 0xcd870
movq (%rax), %rax
movq 0x1407210(%rax), %rax
movq 0x8(%rax), %r14
xorl %esi, %esi
callq 0x2aea2
cvttsd2si %xmm0, %eax
cltq
movq (%r14,%rax,8), %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2aea2
cvttsd2si %xmm0, %eax
cltq
movsd (%r14,%rax,8), %xmm0
jmp 0x868f8
movsd 0x8(%r14), %xmm0
xorpd 0xf961(%rip), %xmm0     # 0x961d0
movapd %xmm0, (%rsp)
movq %rbx, %rsi
callq 0x2beed
mulsd (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x4060
movsd 0x8(%r14), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rsi
callq 0x2be93
mulsd (%rsp), %xmm0
addsd 0x10(%r14), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x4040
movsd 0x8(%r14), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rsi
callq 0x2be93
mulsd (%rsp), %xmm0
addsd 0x10(%r14), %xmm0
cvtsi2sdl 0x4(%r14), %xmm1
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x42f0
leaq 0x1b1ba(%rip), %rdi     # 0xa1aa8
xorl %eax, %eax
callq 0x4030
xorps %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svmsimplex.c
// Function: prepare_Q_for_epsilon_svm
matrix prepare_Q_for_epsilon_svm(Instanceptr data, Kernel_parameter kernel)
{
 Instanceptr tmp, tmp1;
 matrix Q;
 int i, j, size = data_size(data);
 Q = matrix_alloc(2 * size, 2 * size);
 tmp = data;
 i = 0;
 while (tmp != NULL)
  {
   tmp1 = data;
   j = 0;
   while (tmp1 != NULL)
    {
     Q.values[i][j] = kernel_value(tmp, tmp1, kernel);
     Q.values[i + size][j + size] = Q.values[i][j];
     Q.values[i + size][j] = -Q.values[i][j];
     Q.values[i][j + size] = -Q.values[i][j];
     tmp1 = tmp1->next;
     j++;
    }
   tmp = tmp->next;
   i++;
  }
 return Q;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r15
callq 0x2c3cc
movl %eax, %r12d
leal (%r12,%r12), %edi
movl %edi, %esi
callq 0x380d3
movq %rax, 0x28(%rsp)
movslq %r12d, %r14
movq %rdx, 0x20(%rsp)
leaq (%rdx,%r14,8), %rbx
shlq $0x3, %r14
xorl %ebp, %ebp
movq %r15, 0x30(%rsp)
movq %r15, %r12
testq %r12, %r12
je 0x869d4
xorl %r15d, %r15d
movq 0x30(%rsp), %r13
testq %r13, %r13
je 0x869c7
leaq 0x70(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movups (%rcx), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x867e4
movq 0x20(%rsp), %rax
movq (%rax,%rbp,8), %rax
leaq (%rax,%r15), %rcx
movsd %xmm0, (%rax,%r15)
movq (%rbx,%rbp,8), %rdx
leaq (%rdx,%r15), %rsi
movsd %xmm0, (%r14,%rsi)
movsd (%rax,%r15), %xmm0
movaps 0xf829(%rip), %xmm1     # 0x961d0
xorps %xmm1, %xmm0
movlps %xmm0, (%rdx,%r15)
movsd (%rax,%r15), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, (%r14,%rcx)
movq 0x10(%r13), %r13
addq $0x8, %r15
jmp 0x86954
movq 0x10(%r12), %r12
incq %rbp
jmp 0x86943
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svmsimplex.c
// Function: prepare_Q_for_C_svm
matrix prepare_Q_for_C_svm(Instanceptr data, Kernel_parameter kernel, int negative)
{
 Instanceptr tmp, tmp1;
 matrix Q;
 int i, j, size = data_size(data);
 Q = matrix_alloc(size, size);
 tmp = data;
 i = 0;
 while (tmp != NULL)
  {
   tmp1 = data;
   j = 0;
   while (tmp1 != NULL)
    {
     Q.values[i][j] = svm_classno(tmp, negative) * svm_classno(tmp1, negative) * kernel_value(tmp, tmp1, kernel);
     tmp1 = tmp1->next;
     j++;
    }
   tmp = tmp->next;
   i++;
  }
 return Q;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq %rdi, %r13
callq 0x2c3cc
movl %eax, %edi
movl %eax, %esi
callq 0x380d3
movq %rax, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
xorl %r14d, %r14d
movq %r13, 0x28(%rsp)
testq %r13, %r13
je 0x86aa4
xorl %r12d, %r12d
movq 0x28(%rsp), %rbp
testq %rbp, %rbp
je 0x86a98
movq %r13, %rdi
movl %ebx, %esi
callq 0x2bfe3
movl %eax, %r15d
movq %rbp, %rdi
movl %ebx, %esi
callq 0x2bfe3
imull %r15d, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0x70(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movupd (%rcx), %xmm0
movupd %xmm0, (%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x867e4
mulsd 0x30(%rsp), %xmm0
movq 0x18(%rsp), %rax
movq (%rax,%r14,8), %rax
movsd %xmm0, (%rax,%r12)
movq 0x10(%rbp), %rbp
addq $0x8, %r12
jmp 0x86a2d
movq 0x10(%r13), %r13
incq %r14
jmp 0x86a20
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svmsimplex.c
// Function: prepare_qp_for_C_svm
Quadraticprogramptr prepare_qp_for_C_svm(Instanceptr data, Svm_simplex_parameterptr parameters, int negative)
{
 int i, size = data_size(data);
 double *c, *b;
 matrix A, Q;
 Instanceptr tmp;
 Quadraticprogramptr program;
 Q = prepare_Q_for_C_svm(data, parameters->kernel, negative);
 c = safemalloc(size * sizeof(double), "prepare_qp_for_C_svm", 4);
 for (i = 0; i < size; i++)
   c[i] = -1;
 b = safemalloc((size + 2) * sizeof(double), "prepare_qp_for_C_svm", 7);
 for (i = 0; i < size; i++)
   b[i] = parameters->C;
 b[size] = 0;
 b[size + 1] = 0;
 A = matrix_alloc(size + 2, size);
 for (i = 0, tmp = data; i < size; i++, tmp = tmp->next)
  {
   A.values[size][i] = svm_classno(tmp, negative);
   A.values[size + 1][i] = -svm_classno(tmp, negative);
   A.values[i][i] = 1;
  }
 program = prepare_quadratic_program(Q, A, c, b);
 matrix_free(Q);
 matrix_free(A);
 safe_free(c);
 safe_free(b);
 return program;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
callq 0x2c3cc
movl %eax, %ebp
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movupd (%r12), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
movl %ebx, %esi
callq 0x869ed
movq %rax, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movslq %ebp, %r15
leaq (,%r15,8), %rdi
leaq 0x1ae43(%rip), %rsi     # 0xa1b57
pushq $0x4
popq %rdx
callq 0x34f59
xorl %edx, %edx
testl %r15d, %r15d
movl $0x0, %r13d
movq %r15, 0x18(%rsp)
cmovgl %r15d, %r13d
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
cmpq %rdx, %r13
je 0x86d48
movq %rcx, (%rax,%rdx,8)
incq %rdx
jmp 0x86d3a
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rax
leal 0x2(%rax), %r15d
leaq 0x10(,%rax,8), %rdi
leaq 0x1adf2(%rip), %rsi     # 0xa1b57
pushq $0x7
popq %rdx
callq 0x34f59
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x86d85
movsd 0x20(%r12), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
jmp 0x86d6f
movq 0x18(%rsp), %rsi
andq $0x0, (%rax,%rsi,8)
leaq 0x1(%rsi), %rbp
movq %rax, 0x28(%rsp)
andq $0x0, 0x8(%rax,%rsi,8)
movl %r15d, %edi
callq 0x380d3
movq %rax, 0x20(%rsp)
movq %rdx, %r12
xorl %r15d, %r15d
cmpq %r15, %r13
je 0x86e08
movq %r14, %rdi
movl %ebx, %esi
callq 0x2bfe3
cvtsi2sd %eax, %xmm0
movq 0x18(%rsp), %rax
movq (%r12,%rax,8), %rax
movsd %xmm0, (%rax,%r15,8)
movq %r14, %rdi
movl %ebx, %esi
callq 0x2bfe3
negl %eax
cvtsi2sd %eax, %xmm0
movq (%r12,%rbp,8), %rax
movsd %xmm0, (%rax,%r15,8)
movq (%r12,%r15,8), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax,%r15,8)
incq %r15
movq 0x10(%r14), %r14
jmp 0x86db1
movq 0x40(%rsp), %r14
movq %r14, %rdi
movq 0x38(%rsp), %r15
movq %r15, %rsi
movq 0x20(%rsp), %rbx
movq %rbx, %rdx
movq %r12, %rcx
movq 0x30(%rsp), %r13
movq %r13, %r8
movq 0x28(%rsp), %rbp
movq %rbp, %r9
callq 0xe2c1
movq %rax, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3929f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3929f
movq %r13, %rdi
callq 0x34ff7
movq %rbp, %rdi
callq 0x34ff7
movq 0x18(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svmsimplex.c
// Function: test_svm_regression
double test_svm_regression(Svm_regression_modelptr model, Svm_simplex_parameterptr parameters, Instanceptr inst)
{
 int i;
 double sum = 0;
 for (i = 0; i < model->support_vector_count; i++)
   sum += model->alpha[i] * kernel_value(inst, model->support_vectors[i], parameters->kernel);
 sum += model->b;
 return sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x874af
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movsd (%rcx,%r12,8), %xmm1
movsd %xmm1, 0x20(%rsp)
movq (%rax,%r12,8), %rsi
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movsd %xmm0, 0x18(%rsp)
movupd (%r15), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x867e4
mulsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
incq %r12
jmp 0x8744d
addsd 0x18(%rbx), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/svmsimplex.c
// Function: number_of_support_vectors
int number_of_support_vectors(void* model)
{
 int i, sv;
 if (current_dataset->classno == 2)
   return ((Svm_binary_modelptr) model)->support_vector_count;
 else
   if (current_dataset->classno == 0)
     return ((Svm_regression_modelptr) model)->support_vector_count;
   else
    {
     sv = 0;
     for (i = 0; i < ((Svm_simplex_modelptr)model)->problemcount; i++)
       sv += ((Svm_simplex_modelptr)model)->models[i]->support_vector_count;
     return sv;
    }
}

// Assembly:
leaq 0x462dd(%rip), %rax     # 0xcd870
movq (%rax), %rcx
movl (%rdi), %eax
testl $0xfffffffd, 0x10(%rcx) # imm = 0xFFFFFFFD
jne 0x875a2
retq
xorl %ecx, %ecx
testl %eax, %eax
movl %eax, %edx
cmovlel %ecx, %edx
xorl %eax, %eax
cmpq %rcx, %rdx
je 0x875a1
movq 0x8(%rdi), %rsi
movq (%rsi,%rcx,8), %rsi
addl (%rsi), %eax
incq %rcx
jmp 0x875ad
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1a5b6(%rip), %r12     # 0xa1b92
pushq $0x10
popq %rdi
pushq $0x4
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, %r15
leaq 0x4627c(%rip), %r13     # 0xcd870
movq (%r13), %rax
movl 0x10(%rax), %ecx
leal -0x1(%rcx), %eax
imull %ecx, %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, (%r15)
movslq %eax, %rdi
shlq $0x3, %rdi
pushq $0x6
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, 0x8(%r15)
movq (%r13), %rax
movl 0x10(%rax), %eax
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpl %eax, %r13d
jge 0x87695
leal 0x1(%r13), %ebp
movslq %r12d, %r12
movl %ebp, 0xc(%rsp)
cmpl %eax, %ebp
jge 0x8768c
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
movl %r13d, %edx
movl %ebp, %ecx
callq 0x2cc06
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq 0x8712f
movq 0x8(%r15), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x2c6e4
incl %ebp
leaq 0x461ec(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x10(%rax), %eax
jmp 0x8763d
movl 0xc(%rsp), %ecx
movl %ecx, %r13d
jmp 0x8762d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x461ae(%rip), %r13     # 0xcd870
movq (%r13), %rax
movslq 0x10(%rax), %rdi
leaq 0x1a4d6(%rip), %rdx     # 0xa1ba7
pushq $0x4
popq %rsi
pushq $0x2
popq %rcx
callq 0x35067
movq %rax, %r12
movq (%r13), %rax
movl 0x10(%rax), %esi
pushq $0x1
popq %r13
xorl %ebp, %ebp
movslq %esi, %rax
cmpq %rax, %rbp
jge 0x87741
movq %r13, (%rsp)
cmpl %r13d, %esi
jle 0x87735
movq 0x8(%r15), %rax
movq (%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x874c0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
movq %rbp, %rax
ja 0x8771f
movq %r13, %rax
incl (%r12,%rax,4)
incq %r13
leaq 0x46143(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x10(%rax), %esi
jmp 0x876f8
incq %rbp
movq (%rsp), %r13
incq %r13
jmp 0x876ec
movq %r12, %rdi
callq 0x336b5
movl %eax, %ebx
movq %r12, %rdi
callq 0x34ff7
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_O2/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 0x1a418(%rip), %r12     # 0xa1b92
pushq $0x10
popq %rdi
pushq $0x3
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, %r15
leaq 0x460de(%rip), %r13     # 0xcd870
movq (%r13), %rax
movslq 0x10(%rax), %rdi
movl %edi, (%r15)
shlq $0x3, %rdi
pushq $0x5
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, 0x8(%r15)
xorl %r12d, %r12d
movq (%r13), %rax
movslq 0x10(%rax), %rax
cmpq %rax, %r12
jge 0x877db
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x8712f
movq 0x8(%r15), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
jmp 0x877b3
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
movslq (%rbx), %rax
movq 0x8(%rbx), %rdi
cmpq %rax, %r14
jge 0x8780c
movq (%rdi,%r14,8), %rdi
callq 0x8754e
incq %r14
jmp 0x877f2
callq 0x34ff7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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 0x46035(%rip), %r13     # 0xcd870
movq (%r13), %rax
movslq 0x10(%rax), %rdi
leaq 0x1a371(%rip), %rdx     # 0xa1bbb
pushq $0x8
popq %rsi
pushq $0x3
popq %rcx
callq 0x35067
movq %rax, %r12
xorl %ebp, %ebp
movq (%r13), %rax
movslq 0x10(%rax), %rsi
cmpq %rsi, %rbp
jge 0x87885
movq 0x8(%r15), %rax
movq (%rax,%rbp,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x874c0
movsd %xmm0, (%r12,%rbp,8)
incq %rbp
jmp 0x8785a
movq %r12, %rdi
callq 0x338cc
movl %eax, %ebx
movq %r12, %rdi
callq 0x34ff7
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_O2/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 0x878f3
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
movq 0x18(%rdi), %rcx
jae 0x878fc
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_O2/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 0x87957
cmpl $0x1, %eax
je 0x8794e
testl %eax, %eax
jne 0x87960
movq 0x30(%rdi), %rdi
jmp 0x85e2e
movq 0x38(%rdi), %rdi
jmp 0x861a9
movq 0x40(%rdi), %rdi
jmp 0x85fa6
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x879a3
cmpl $0x1, %eax
je 0x87993
testl %eax, %eax
jne 0x879b1
movq 0x30(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x85ee1
jmp 0x879b1
movq 0x38(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x86288
jmp 0x879b1
movq 0x40(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x86026
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 0x35388
movq 0x18(%rbx), %rsi
leaq (%rsi,%r14), %rdi
addq %r15, %rsi
callq 0x35376
movq 0x20(%rbx), %rax
leaq (%rax,%r14,8), %rdi
leaq (%rax,%r15,8), %rsi
callq 0x35388
movq 0x60(%rbx), %rax
leaq (%rax,%r14,8), %rdi
leaq (%rax,%r15,8), %rsi
callq 0x35388
movq 0x68(%rbx), %rax
leaq (%rax,%r14,4), %rdi
leaq (%rax,%r15,4), %rsi
callq 0x3537f
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 0x35388
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdi), %ecx
movl 0x78(%rdi), %edx
cmpl %edx, %ecx
je 0x87ae3
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %ecx, %rax
movslq %edx, %rsi
cmpq %rsi, %rax
jge 0x87a7e
movq 0x70(%rbx), %rdi
movsd (%rdi,%rax,8), %xmm0
movq 0x10(%rbx), %rdi
movq 0x60(%rbx), %r8
addsd (%r8,%rax,8), %xmm0
movsd %xmm0, (%rdi,%rax,8)
incq %rax
jmp 0x87a58
xorl %r14d, %r14d
movslq %ecx, %rax
cmpq %rax, %r14
jge 0x87adc
movq 0x18(%rbx), %rax
cmpb $0x2, (%rax,%r14)
jne 0x87ad7
movq %rbx, %rdi
movl %r14d, %esi
callq 0x87934
movq 0x20(%rbx), %rcx
movsd (%rcx,%r14,8), %xmm0
movl (%rbx), %ecx
movl 0x78(%rbx), %edx
movslq %ecx, %rsi
movslq %edx, %rdi
cmpq %rdi, %rsi
jge 0x87ad7
movq 0x10(%rbx), %r8
movsd (%rax,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%r8,%rsi,8), %xmm1
movsd %xmm1, (%r8,%rsi,8)
incq %rsi
jmp 0x87ab4
incq %r14
jmp 0x87a81
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
pushq $-0x1
popq %r8
movsd 0x12dd2(%rip), %xmm1    # 0x9aa48
movapd 0xe552(%rip), %xmm0     # 0x961d0
movapd %xmm1, %xmm2
movl %r8d, %r9d
cmpq %rcx, %rax
je 0x87d65
movq 0x8(%rdi), %r10
movq 0x18(%rdi), %r11
cmpb $0x1, (%r10,%rcx)
movb (%r11,%rcx), %r10b
jne 0x87cad
cmpb $0x1, %r10b
jne 0x87cb9
movapd %xmm1, %xmm3
jmp 0x87ced
cmpb $0x1, %r10b
jne 0x87d03
movapd %xmm2, %xmm4
jmp 0x87d37
movq 0x10(%rdi), %r11
movsd (%r11,%rcx,8), %xmm4
xorpd %xmm0, %xmm4
ucomisd %xmm1, %xmm4
movapd %xmm1, %xmm3
cmpnlesd %xmm4, %xmm3
movapd %xmm3, %xmm5
andnpd %xmm4, %xmm5
andpd %xmm1, %xmm3
orpd %xmm5, %xmm3
cmovael %ecx, %r8d
testb %r10b, %r10b
je 0x87cfd
movq 0x10(%rdi), %r10
movsd (%r10,%rcx,8), %xmm4
ucomisd %xmm2, %xmm4
jae 0x87d4d
movapd %xmm2, %xmm4
jmp 0x87d55
movq 0x10(%rdi), %r11
movsd (%r11,%rcx,8), %xmm3
xorpd %xmm0, %xmm3
ucomisd %xmm2, %xmm3
movapd %xmm2, %xmm4
cmpnlesd %xmm3, %xmm4
movapd %xmm4, %xmm5
andnpd %xmm3, %xmm5
andpd %xmm2, %xmm4
orpd %xmm5, %xmm4
cmovael %ecx, %r9d
testb %r10b, %r10b
je 0x87d47
movq 0x10(%rdi), %r10
movsd (%r10,%rcx,8), %xmm3
ucomisd %xmm1, %xmm3
jae 0x87d52
movapd %xmm1, %xmm3
jmp 0x87d55
movl %ecx, %r9d
jmp 0x87d55
movl %ecx, %r8d
incq %rcx
movapd %xmm3, %xmm1
movapd %xmm4, %xmm2
jmp 0x87c85
addsd %xmm2, %xmm1
movsd 0x48(%rdi), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x87d78
pushq $0x1
popq %rax
retq
movl %r8d, (%rsi)
movl %r9d, (%rdx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl (%rdi), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
xorpd %xmm0, %xmm0
movsd 0x126b7(%rip), %xmm3    # 0x9aa48
movsd 0x126b7(%rip), %xmm2    # 0x9aa50
xorl %ebp, %ebp
cmpq %r15, %r14
je 0x8842b
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movsbl (%rax,%r15), %eax
cvtsi2sd %eax, %xmm1
mulsd (%rcx,%r15,8), %xmm1
movq 0x18(%rbx), %rcx
movzbl (%rcx,%r15), %ecx
cmpl $0x1, %ecx
je 0x883f2
testl %ecx, %ecx
jne 0x8841d
movsd %xmm0, 0x10(%rsp)
testb %al, %al
jle 0x883fc
movapd %xmm2, %xmm0
movsd %xmm3, 0x8(%rsp)
callq 0x34c95
movsd 0x8(%rsp), %xmm3
movapd %xmm0, %xmm2
jmp 0x88415
movsd %xmm0, 0x10(%rsp)
testb %al, %al
js 0x883d7
movapd %xmm3, %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x34c90
movsd 0x8(%rsp), %xmm2
movapd %xmm0, %xmm3
movsd 0x10(%rsp), %xmm0
jmp 0x88423
incl %ebp
addsd %xmm1, %xmm0
incq %r15
jmp 0x8839b
testl %ebp, %ebp
jg 0x88441
addsd %xmm3, %xmm2
mulsd 0xd8e5(%rip), %xmm2     # 0x95d20
movapd %xmm2, %xmm0
jmp 0x88449
cvtsi2sd %ebp, %xmm1
divsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x18(%rsp)
movl %esi, %ebp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0x30(%rsp), %rdx
andq $0x0, (%rdx)
pushq $0x4
popq %rcx
movq %rdi, 0x10(%rsp)
movq %rbx, %rsi
callq 0x2cfe5
movq (%rbx), %rdi
callq 0x2c3cc
movl %eax, %r12d
movsd 0xc16a(%rip), %xmm0     # 0x95518
movsd %xmm0, (%rsp)
pushq $-0x1
popq %r13
movsd 0xe6b1(%rip), %xmm0     # 0x97a70
leaq 0x38(%rsp), %rbx
leaq 0x40(%rsp), %r14
movsd 0xcc77(%rip), %xmm1     # 0x96048
ucomisd %xmm0, %xmm1
movq 0x30(%rsp), %rdi
jb 0x89455
movq %rbx, %rsi
movl %ebp, %edx
movsd %xmm0, 0x28(%rsp)
callq 0x8905c
movl %eax, %r15d
movq 0x8(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
movl %eax, %esi
movsd %xmm0, 0x20(%rsp)
movq %r14, %rdx
leaq 0x108(%rsp), %rcx
xorl %r8d, %r8d
callq 0x91c39
movq %r14, %rdi
movl %r12d, %esi
callq 0x1bb11
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x89442
movq 0x18(%rsp), %rax
movsd 0x20(%rsp), %xmm1
movsd %xmm1, (%rax)
movl %r15d, %r13d
movsd %xmm0, (%rsp)
movsd 0x28(%rsp), %xmm0
addsd 0xe940(%rip), %xmm0     # 0x97d90
jmp 0x893c9
movq 0x10(%rsp), %rax
movq %rdi, (%rax)
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2c6e4
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_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
andl $0x0, 0x98(%rdi)
callq 0x1abee
testl %eax, %eax
je 0x89542
leaq 0x20(%r15), %rdi
leaq 0x28(%r15), %rdx
movl %ebx, %esi
callq 0x89361
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 0x91c39
xorl %ecx, %ecx
leaq 0x44386(%rip), %r12     # 0xcd870
leaq 0xc8(%rcx), %r13
cmpq $0x258, %r13            # imm = 0x258
je 0x8951b
leaq (%rsp,%rcx), %rdi
movq (%r12), %rax
movl 0x10(%rax), %esi
callq 0x33b3e
movq %r13, %rcx
testl %eax, %eax
jne 0x894ea
movq %r15, %rdi
callq 0x1a6ac
jmp 0x89542
movq %r15, %rdi
callq 0x91657
testl %eax, %eax
je 0x89542
movq (%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x8947f
movq 0x8(%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x8947f
pushq $0x1
popq %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %esi, %rax
leal -0x1(%rax), %ecx
leaq 0x28(%rdi), %rdx
leaq 0x10(%rdi), %r8
xorl %ebx, %ebx
cmpl %esi, %ebx
jge 0x89621
movslq %ebx, %r10
movq %r10, %r9
shlq $0x5, %r9
leaq (%rdx,%r9), %r15
leaq 0x1(%r10), %r14
movl %ebx, %r11d
cmpq %rax, %r14
jge 0x895b3
movsd -0x20(%r15), %xmm0
incl %r11d
incq %r14
ucomisd (%r15), %xmm0
leaq 0x20(%r15), %r15
jne 0x895ad
jnp 0x8958f
leal -0x1(%r11), %r14d
jmp 0x895b9
movl %ecx, %r14d
movl %esi, %r11d
movl %r14d, %ebp
subl %ebx, %ebp
jne 0x895d1
cvtsi2sd %r11d, %xmm0
movsd %xmm0, 0x10(%rdi,%r9)
movl %r11d, %ebx
jmp 0x89572
leal 0x1(%r14), %r15d
cmpl %r15d, %ebx
cmovgl %ebx, %r15d
movl %r15d, %r12d
subl %ebx, %r12d
leal 0x1(%rbx), %r13d
notl %ebx
addl %r15d, %ebx
imull %r12d, %r13d
imulq %rbx, %r12
shrq %r12
addl %r12d, %r13d
cvtsi2sd %r13d, %xmm0
incl %ebp
cvtsi2sd %ebp, %xmm1
divsd %xmm1, %xmm0
movslq %r14d, %rbx
addq %r8, %r9
cmpq %rbx, %r10
jg 0x895cc
movsd %xmm0, (%r9)
incq %r10
addq $0x20, %r9
jmp 0x8960e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
movq %rsi, 0x20(%rsp)
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x340fb
movl %eax, %r15d
movq (%r12), %rdi
callq 0x33f62
movl %eax, (%rsp)
movq %rbx, %r13
movslq %ebx, %rbx
pushq $0x1
popq %r14
cmpq %rbx, %r14
jge 0x8992d
movq (%r12,%r14,8), %rdi
callq 0x340fb
cmpl %r15d, %eax
jne 0x899fd
movq (%r12,%r14,8), %rdi
callq 0x33f62
incq %r14
cmpl (%rsp), %eax
je 0x898f9
leaq 0x18466(%rip), %rdi     # 0xa1d8e
jmp 0x89a04
movq %r12, 0x8(%rsp)
xorl %eax, %eax
testl %r15d, %r15d
movl %r15d, %r12d
cmovlel %eax, %r12d
testl %r13d, %r13d
cmovlel %eax, %r13d
movq %r13, 0x18(%rsp)
shlq $0x3, %r12
leaq 0x10253(%rip), %r13     # 0x99ba8
xorl %r14d, %r14d
movl %r15d, 0x4(%rsp)
cmpq 0x18(%rsp), %r14
movq 0x20(%rsp), %rbx
je 0x89a2b
movq %r14, %rbp
shlq $0x4, %rbp
movl (%rsp), %edi
movl %r15d, %esi
callq 0x380d3
movq %rax, (%rbx,%rbp)
movq %rdx, 0x8(%rbx,%rbp)
movq 0x8(%rsp), %rax
movq %r14, 0x10(%rsp)
movq (%rax,%r14,8), %rdi
leaq 0x11ee2(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x89a0b
movq %rax, %r14
addq %rbx, %rbp
xorl %r15d, %r15d
movslq (%rbp), %rax
cmpq %rax, %r15
jge 0x899e3
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x899de
movq 0x8(%rbp), %rax
movq (%rax,%r15,8), %rdx
addq %rbx, %rdx
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %rbx
jmp 0x899bb
incq %r15
jmp 0x899b0
movq %r14, %rdi
callq 0x42a0
movq 0x10(%rsp), %r14
incq %r14
movl 0x4(%rsp), %r15d
jmp 0x8995d
leaq 0x183be(%rip), %rdi     # 0xa1dc2
callq 0x4090
jmp 0x89a27
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xc7ea(%rip), %rdi      # 0x9620a
xorl %eax, %eax
callq 0x4030
pushq $-0x1
popq %r15
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r13
movq %rdi, %r15
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %ebx, %ebx
movq %rdi, 0x20(%rsp)
cmpq $0x0, (%r15,%r14,8)
je 0x89b51
leaq 0x1(%r14), %rbp
movq (%r13), %rdi
leaq 0x4(,%r14,4), %rsi
movl %ebp, %edx
callq 0x34f30
movq %rax, (%r13)
movq (%r15,%r14,8), %rdi
callq 0x33f62
movq (%r13,%r14,8), %rcx
movl %eax, (%rcx)
addl %r12d, %eax
movl %eax, 0xc(%rsp)
movslq %eax, %rdx
movq %rdx, %rsi
shlq $0x5, %rsi
movq %rbx, %rdi
callq 0x34f30
movq %rax, %rbx
movq (%r15,%r14,8), %rdi
leaq 0x11dba(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x89b63
movl %r12d, %ecx
movq %rax, %r12
movq %rbp, 0x28(%rsp)
movslq %ecx, %rax
movl %eax, %r15d
shlq $0x5, %rax
movq %rbx, 0x30(%rsp)
addq %rax, %rbx
addq $0x18, %rbx
xorl %ebp, %ebp
movq (%r13,%r14,8), %rax
movslq (%rax), %rax
cmpq %rax, %rbp
jge 0x89b30
leaq -0x10(%rbx), %rdx
movq %r12, %rdi
leaq 0x10097(%rip), %rsi     # 0x99ba8
xorl %eax, %eax
callq 0x4070
movl %r14d, -0x18(%rbx)
andq $0x0, -0x8(%rbx)
leal (%r15,%rbp), %eax
movl %eax, (%rbx)
incq %rbp
addq $0x20, %rbx
jmp 0x89af6
movq %r12, %rdi
callq 0x42a0
movq 0x28(%rsp), %r14
movl 0xc(%rsp), %r12d
movq 0x30(%rsp), %rbx
movq 0x20(%rsp), %r15
jmp 0x89a68
movq 0x10(%rsp), %rax
movl %r12d, (%rax)
movq 0x18(%rsp), %rax
movl %r14d, (%rax)
jmp 0x89b77
movq (%r15,%r14,8), %rsi
leaq 0xc69c(%rip), %rdi      # 0x9620a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4030
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq (%rdi), %rdi
callq 0x340fb
movl %eax, %r15d
movq %rbx, 0x8(%rsp)
movq 0x8(%rbx), %rdi
callq 0x340fb
cmpl %r15d, %eax
jne 0x89c93
xorl %eax, %eax
testl %r15d, %r15d
movl %r15d, %r12d
cmovlel %eax, %r12d
shlq $0x3, %r12
leaq 0xffd2(%rip), %r13      # 0x99ba8
xorl %r14d, %r14d
movl %r15d, 0x14(%rsp)
movq %rbp, 0x20(%rsp)
cmpq $0x2, %r14
je 0x89cc1
movq 0x8(%rsp), %rax
movq (%rax,%r14,8), %rdi
callq 0x33f62
movq %r14, %rbx
shlq $0x4, %rbx
movl %eax, %edi
movl %r15d, %esi
callq 0x380d3
movq %rax, (%rbp,%rbx)
movq %rdx, 0x8(%rbp,%rbx)
movq %r14, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq (%rax,%r14,8), %rdi
leaq 0x11c54(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x89ca1
movq %rbp, %rcx
movq %rax, %rbp
addq %rcx, %rbx
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x89c74
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x89c6f
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdx
addq %r14, %rdx
movq %rbp, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %r14
jmp 0x89c4c
incq %r15
jmp 0x89c41
movq %rbp, %rdi
callq 0x42a0
movq 0x18(%rsp), %r14
incq %r14
movl 0x14(%rsp), %r15d
movq 0x20(%rsp), %rbp
jmp 0x89be3
leaq 0x18128(%rip), %rdi     # 0xa1dc2
callq 0x4090
jmp 0x89cbd
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xc554(%rip), %rdi      # 0x9620a
xorl %eax, %eax
callq 0x4030
pushq $-0x1
popq %r15
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x340fb
cmpl $-0x1, %eax
je 0x89daa
movl %eax, %ebx
movq %r13, %rdi
callq 0x33f62
movl %eax, %edi
movl %ebx, %esi
callq 0x380d3
movq %rax, %r14
movq %rdx, %r15
leaq 0x11b6d(%rip), %rsi     # 0x9b87f
movq %r13, %rdi
callq 0x40f0
testq %rax, %rax
je 0x89d99
movq %rax, %r12
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
testl %r14d, %r14d
movl $0x0, %eax
movq %r14, 0x8(%rsp)
cmovgl %r14d, %eax
movq %rax, 0x10(%rsp)
shlq $0x3, %rbx
leaq 0xfe5e(%rip), %r13      # 0x99ba8
xorl %r14d, %r14d
cmpq 0x10(%rsp), %r14
je 0x89d7a
xorl %ebp, %ebp
cmpq %rbp, %rbx
je 0x89d75
movq (%r15,%r14,8), %rdx
addq %rbp, %rdx
movq %r12, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %rbp
jmp 0x89d56
incq %r14
jmp 0x89d4d
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 0xc46a(%rip), %rdi      # 0x9620a
movq %r13, %rsi
xorl %eax, %eax
callq 0x4030
pushq $0x1
popq %rdi
movl %edi, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x380d3
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rsi, %r15
movq %rdi, (%rsp)
leaq 0x17e9d(%rip), %rsi     # 0xa1c78
pushq $0x10
popq %rdi
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %rbx
xorl %r13d, %r13d
cmpq $0x2, %r13
je 0x89e91
movq (%rsp), %r14
movq (%r14,%r13,8), %rdi
callq 0x33f62
movl %eax, (%r15,%r13,4)
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x17e63(%rip), %rsi     # 0xa1c78
pushq $0x8
popq %rdx
callq 0x34f59
movq %rax, (%rbx,%r13,8)
movq (%r14,%r13,8), %rdi
leaq 0x11a53(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x89e79
movq %rax, %rbp
xorl %r14d, %r14d
xorl %r12d, %r12d
movslq (%r15,%r13,4), %rax
cmpq %rax, %r12
jge 0x89e69
movq (%rbx,%r13,8), %rdx
addq %r14, %rdx
movq %rbp, %rdi
leaq 0xfd4f(%rip), %rsi      # 0x99ba8
xorl %eax, %eax
callq 0x4070
incq %r12
addq $0x8, %r14
jmp 0x89e3f
movq %rbp, %rdi
callq 0x42a0
incq %r13
jmp 0x89dec
movq (%rsp), %rax
movq (%rax,%r13,8), %rsi
leaq 0xc382(%rip), %rdi      # 0x9620a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %r8d, %r8d
testl %ecx, %ecx
cmovlel %r8d, %ecx
pushq $-0x1
popq %rax
xorl %r9d, %r9d
cmpq %r8, %rcx
je 0x8ae47
movl (%rdx), %r10d
addl %r9d, %r10d
cmpl %edi, %r10d
jg 0x8ae3f
incq %r8
addq $0x10, %rdx
movl %r10d, %r9d
jmp 0x8ae23
subl %r9d, %edi
movl %edi, (%rsi)
movl %r8d, %eax
retq