LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/convex.c
// Function: find_variable_to_bring_into_basis_qp_random
int find_variable_to_bring_into_basis_qp_random(Quadraticprogramptr program)
{
 int i, index = -2, pos, complementary, newnonbasic, *candidate, size;
 Linklistptr candidates;
 candidates = link_list();
 for (i = 0; i < program->variablecount + program->constraintcount; i++)
   if (!program->isbasic[i] && program->objectives[i] < 0)
    {
     complementary = complementary_variable(program->m, program->n, i);
     newnonbasic = find_variable_to_remove_from_basis(program->constraints, program->constraintcount, i);
     if ((i >= 2 * program->m + 2 * program->n) || !program->isbasic[complementary] || (newnonbasic >= 0 && program->basic[newnonbasic] == complementary))
      {
       candidate = safemalloc(sizeof(int), "find_variable_to_bring_into_basis_qp", 10);
       *candidate = i;
       link_list_insert(candidates, candidate);
      }
    }
 size = link_list_size(candidates);
 if (size != 0)
  {
   pos = myrand() % size;
   candidate = (int*) link_list_get_i(candidates, pos);
   index = *candidate;
  }
 else
   index = -1;
 free_link_list(candidates, safe_free);
 return index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x19aac
movq %rax, %rbx
movslq 0xc(%r14), %rax
movslq 0x8(%r14), %rdx
addq %rdx, %rax
cmpq %rax, %r15
jge 0xea92
movq 0x40(%r14), %r12
cmpl $0x0, (%r12,%r15,4)
jne 0xea8a
movq 0x38(%r14), %rax
xorpd %xmm0, %xmm0
ucomisd (%rax,%r15,8), %xmm0
jbe 0xea8a
movl (%r14), %eax
addl 0x4(%r14), %eax
movslq %eax, %r13
movl %r13d, %ebp
negl %ebp
cmpq %r13, %r15
cmovll %r13d, %ebp
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
movl %r15d, %ecx
callq 0xeadb
leal (,%r13,2), %ecx
movslq %ecx, %rcx
cmpq %rcx, %r15
jge 0xea6a
addq %r15, %rbp
movslq %ebp, %rcx
cmpl $0x0, (%r12,%rcx,4)
je 0xea6a
testl %eax, %eax
js 0xea8a
movq 0x48(%r14), %rcx
movl %eax, %eax
cmpl (%rcx,%rax,4), %ebp
jne 0xea8a
pushq $0x4
popq %rdi
leaq 0x877dc(%rip), %rsi     # 0x96250
pushq $0xa
popq %rdx
callq 0x34f59
movl %r15d, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19ac7
incq %r15
jmp 0xe9e5
movq %rbx, %rdi
callq 0x19ba8
testl %eax, %eax
je 0xeab8
movl %eax, %ebp
xorl %eax, %eax
callq 0x35c7f
cltd
idivl %ebp
movq %rbx, %rdi
movl %edx, %esi
callq 0x19bbb
movl (%rax), %ebp
jmp 0xeabb
pushq $-0x1
popq %rbp
leaq 0x26535(%rip), %rsi     # 0x34ff7
movq %rbx, %rdi
callq 0x19bd5
movl %ebp, %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/convex.c
// Function: find_variable_to_remove_from_basis
int find_variable_to_remove_from_basis(matrix constraints, int constraintcount, int newbasic)
{
 int i, index = -1;
 double bi, ais, minratio = +INT_MAX;
 for (i = 0; i < constraintcount; i++)
  {
   bi = constraints.values[i][constraints.col - 1];
   ais = constraints.values[i][newbasic];
   if (ais > 0 && bi / ais < minratio)
    {
     index = i;
     minratio = bi / ais;
    }
  }
 return index;
}

// Assembly:
movabsq $-0x100000000, %r8      # imm = 0xFFFFFFFF00000000
addq %rdi, %r8
sarq $0x20, %r8
xorl %edi, %edi
testl %edx, %edx
cmovlel %edi, %edx
movslq %ecx, %rcx
movsd 0x86a1a(%rip), %xmm1    # 0x95518
pushq $-0x1
popq %rax
xorpd %xmm0, %xmm0
cmpq %rdi, %rdx
je 0xeb35
movq (%rsi,%rdi,8), %r9
movsd (%r9,%rcx,8), %xmm3
ucomisd %xmm0, %xmm3
jbe 0xeb30
movsd (%r9,%r8,8), %xmm2
divsd %xmm3, %xmm2
ucomisd %xmm2, %xmm1
jbe 0xeb30
movl %edi, %eax
movapd %xmm2, %xmm1
incq %rdi
jmp 0xeb05
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/convex.c
// Function: find_variable_to_bring_into_basis_qp
int find_variable_to_bring_into_basis_qp(Quadraticprogramptr program)
{
 int i, index = -2, complementary, newnonbasic;
 double mincoefficient = +INT_MAX;
 for (i = 0; i < program->variablecount + program->constraintcount; i++)
   if (!program->isbasic[i] && program->objectives[i] < mincoefficient)
    {
     complementary = complementary_variable(program->m, program->n, i);
     newnonbasic = find_variable_to_remove_from_basis(program->constraints, program->constraintcount, i);
     if ((i >= 2 * program->m + 2 * program->n) || !program->isbasic[complementary] || (newnonbasic >= 0 && program->basic[newnonbasic] == complementary))
      {
       index = i;
       mincoefficient = program->objectives[i];
      }
    }
 if (mincoefficient == 0.0)
   return -1;
 else
   if (mincoefficient > 0.0)
     return -2;
   else
     return index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %r15d
movl %eax, 0x4(%rsp)
addl %eax, %r15d
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
movsd 0x869b1(%rip), %xmm1    # 0x95518
pushq $-0x2
popq %rax
movl %eax, (%rsp)
cmpq %r14, %r15
je 0xec14
movq 0x40(%rbx), %r13
cmpl $0x0, (%r13,%r14,4)
jne 0xec0c
movq 0x38(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
ucomisd %xmm0, %xmm1
jbe 0xec0c
movl (%rbx), %eax
addl 0x4(%rbx), %eax
movslq %eax, %rbp
movl %ebp, %r12d
negl %r12d
cmpq %rbp, %r14
cmovll %ebp, %r12d
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rsi
movl 0x4(%rsp), %edx
movl %r14d, %ecx
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
callq 0xeadb
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
leal (,%rbp,2), %ecx
movslq %ecx, %rcx
cmpq %rcx, %r14
jge 0xec04
addq %r14, %r12
movslq %r12d, %rcx
cmpl $0x0, (%r13,%rcx,4)
je 0xec04
testl %eax, %eax
js 0xec0c
movq 0x48(%rbx), %rcx
movl %eax, %eax
cmpl (%rcx,%rax,4), %r12d
jne 0xec0c
movl %r14d, (%rsp)
movapd %xmm0, %xmm1
incq %r14
jmp 0xeb6d
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
pushq $-0x2
popq %rax
movl (%rsp), %ecx
cmoval %eax, %ecx
pushq $-0x1
popq %rax
cmovnel %ecx, %eax
cmovpl %ecx, %eax
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/convex.c
// Function: pivot_on_the_new_variables
void pivot_on_the_new_variables(matrix constraints, double* objectives, int newnonbasic, int newbasic)
{
 int i, j;
 double ars = constraints.values[newnonbasic][newbasic], factor;
 for (j = 0; j < constraints.col; j++)
   constraints.values[newnonbasic][j] /= ars;
 for (i = 0; i < constraints.row; i++)
   if (i != newnonbasic)
    {
     factor = -constraints.values[i][newbasic];
     if (factor != 0)
       for (j = 0; j < constraints.col; j++)
         constraints.values[i][j] += factor * constraints.values[newnonbasic][j];
    }
 factor = -objectives[newbasic];
 for (j = 0; j < constraints.col; j++)
   objectives[j] += factor * constraints.values[newnonbasic][j];
}

// Assembly:
pushq %rbx
movq %rdi, %rax
shrq $0x20, %rax
movslq %ecx, %r9
movq (%rsi,%r9,8), %r9
movslq %r8d, %r8
movsd (%r9,%r8,8), %xmm0
xorl %r10d, %r10d
testl %eax, %eax
cmovlel %r10d, %eax
cmpq %r10, %rax
je 0xec78
movsd (%r9,%r10,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r9,%r10,8)
incq %r10
jmp 0xec5e
movl %ecx, %ecx
xorl %r10d, %r10d
testl %edi, %edi
cmovlel %r10d, %edi
movapd 0x87545(%rip), %xmm0    # 0x961d0
cmpq %rdi, %r10
je 0xecd6
cmpq %rcx, %r10
je 0xecd1
movq (%rsi,%r10,8), %r11
movsd (%r11,%r8,8), %xmm2
movapd %xmm2, %xmm1
xorpd %xmm0, %xmm1
ucomisd %xmm1, %xmm2
jne 0xecaf
jnp 0xecd1
xorl %ebx, %ebx
cmpq %rbx, %rax
je 0xecd1
movsd (%r9,%rbx,8), %xmm2
mulsd %xmm1, %xmm2
addsd (%r11,%rbx,8), %xmm2
movsd %xmm2, (%r11,%rbx,8)
incq %rbx
jmp 0xecb1
incq %r10
jmp 0xec8b
movsd (%rdx,%r8,8), %xmm0
xorpd 0x874ec(%rip), %xmm0    # 0x961d0
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0xed04
movsd (%r9,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%rdx,%rcx,8), %xmm1
movsd %xmm1, (%rdx,%rcx,8)
incq %rcx
jmp 0xece6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/convex.c
// Function: print_simplex_tableau
void print_simplex_tableau(matrix constraints, int* basic, double* objectives)
{
 int i, j;
 printf("------------------------------------------------\n");
 for (i = 0; i < constraints.row; i++)
  {
   printf("%3d ", basic[i]);
   for (j = 0; j < constraints.col; j++)
     printf("%7.3f ", constraints.values[i][j]);
   printf("\n");
  }
 printf("  F ");
 for (j = 0; j < constraints.col; j++)
   printf("%7.3f ", objectives[j]);
 printf("\n");
 printf("------------------------------------------------\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r13
movq %rdi, %r12
shrq $0x20, %r12
leaq 0x875c8(%rip), %rdi     # 0x962fa
callq 0x4090
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
testl %r13d, %r13d
movl $0x0, %ebp
cmovgl %r13d, %ebp
leaq 0x87527(%rip), %r13     # 0x9627a
xorl %ebx, %ebx
cmpq %rbp, %rbx
je 0xed9e
movq 0x10(%rsp), %rax
movl (%rax,%rbx,4), %esi
leaq 0x8750c(%rip), %rdi     # 0x96275
xorl %eax, %eax
callq 0x4030
xorl %r14d, %r14d
cmpq %r14, %r12
je 0xed91
movq (%r15,%rbx,8), %rax
movsd (%rax,%r14,8), %xmm0
movq %r13, %rdi
movb $0x1, %al
callq 0x4030
incq %r14
jmp 0xed73
pushq $0xa
popq %rdi
callq 0x40d0
incq %rbx
jmp 0xed55
leaq 0x874dc(%rip), %rdi     # 0x96281
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4030
leaq 0x874c5(%rip), %r14     # 0x9627a
movq 0x8(%rsp), %r15
cmpq %rbx, %r12
je 0xedd4
movsd (%r15,%rbx,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x4030
incq %rbx
jmp 0xedba
pushq $0xa
popq %rdi
callq 0x40d0
leaq 0x87517(%rip), %rdi     # 0x962fa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/convex.c
// Function: drop_artificial_variables
void drop_artificial_variables(Linearprogramptr program)
{
 int i, totalvariables;
 double tmp;
 program->variablecount -= program->constraintcount;
 totalvariables = program->variablecount + program->constraintcount;
 program->isbasic = alloc(program->isbasic, totalvariables * sizeof(BOOLEAN), totalvariables);
 program->objectives = alloc(program->objectives, (totalvariables + 1) * sizeof(double), totalvariables + 1);
 for (i = 0; i < totalvariables; i++)
   program->objectives[i] = program->constraints.values[program->constraintcount][i];
 program->objectives[totalvariables] = program->constraints.values[program->constraintcount][program->constraints.col - 1];
 for (i = 0; i < program->constraintcount; i++)
  {
   tmp = program->constraints.values[i][program->constraints.col - 1];
   program->constraints.values[i] = alloc(program->constraints.values[i], (totalvariables + 1) * sizeof(double), totalvariables + 1);
   program->constraints.values[i][totalvariables] = tmp;
  }
 safe_free(program->constraints.values[program->constraintcount]);
 (program->constraints.row)--;
 program->constraints.values = alloc(program->constraints.values, program->constraints.row * sizeof(double*), program->constraints.row);
 program->constraints.col -= program->constraintcount;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
movslq %eax, %r14
movl %r14d, %eax
subl 0x4(%rdi), %eax
movl %eax, (%rdi)
movq 0x20(%rdi), %rdi
leaq (,%r14,4), %rsi
movl %r14d, %edx
callq 0x34f30
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rdi
leaq 0x1(%r14), %r15
leaq 0x8(,%r14,8), %r12
movq %r12, %rsi
movl %r15d, %edx
callq 0x34f30
xorl %esi, %esi
testl %r14d, %r14d
movl $0x0, %edi
cmovgl %r14d, %edi
movq %rax, 0x18(%rbx)
movq 0x10(%rbx), %rcx
movslq 0x4(%rbx), %rdx
movq (%rcx,%rdx,8), %r8
cmpq %rsi, %rdi
je 0xf1df
movsd (%r8,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
jmp 0xf1ca
movslq 0xc(%rbx), %rsi
movsd -0x8(%r8,%rsi,8), %xmm0
movsd %xmm0, (%rax,%r14,8)
xorl %r13d, %r13d
movslq %edx, %rax
cmpq %rax, %r13
jge 0xf23e
movq (%rcx,%r13,8), %rdi
movslq 0xc(%rbx), %rax
movsd -0x8(%rdi,%rax,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rsi
movl %r15d, %edx
callq 0x34f30
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x10(%rbx), %rcx
movq (%rcx,%r13,8), %rax
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax,%r14,8)
incq %r13
movl 0x4(%rbx), %edx
jmp 0xf1f3
movq (%rcx,%rax,8), %rdi
callq 0x34ff7
movslq 0x8(%rbx), %rax
leaq -0x1(%rax), %rdx
movl %edx, 0x8(%rbx)
movq 0x10(%rbx), %rdi
leaq -0x8(,%rax,8), %rsi
callq 0x34f30
movq %rax, 0x10(%rbx)
movl 0x4(%rbx), %eax
subl %eax, 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/convex.c
// Function: solve_lp
Convexsolutionptr solve_lp(Linearprogramptr program)
{
 Convexsolutionptr solution;
 Linearprogramptr newprogram;
 if (is_program_in_canonical_form(program))
   return solve_lp_with_basic_feasible_solution_using_simplex(program);
 newprogram = formulate_infeasibility_form(program);
 solution = solve_lp_with_basic_feasible_solution_using_simplex(newprogram);
 if (solution->optimalvalue <= DBL_DELTA)
  {
   drop_artificial_variables(newprogram);
   return solve_lp_with_basic_feasible_solution_using_simplex(newprogram);
  }
 return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xe8b1
testl %eax, %eax
jne 0xf2b6
movq %rbx, %rdi
callq 0xef1b
movq %rax, %rbx
movq %rax, %rdi
callq 0xedf6
movsd 0x86b3d(%rip), %xmm0    # 0x95de0
ucomisd 0x8(%rax), %xmm0
jae 0xf2ae
xorl %eax, %eax
popq %rbx
retq
movq %rbx, %rdi
callq 0xf15c
movq %rbx, %rdi
popq %rbx
jmp 0xedf6
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/convex.c
// Function: solve_qp_wolfe_method
Convexsolutionptr solve_qp_wolfe_method(Quadraticprogramptr program)
{
 int iteration = 0;
 Convexsolutionptr solution, best;
 Quadraticprogramptr copy;
 double optimal;
 copy = copy_of_quadratic_program(program);
 best = solve_qp_using_simplex(copy, BOOLEAN_FALSE);
 optimal = fabs(best->optimalvalue);
 while (optimal > DBL_DELTA && iteration < 10)
  {
   free_quadratic_program(copy);
   copy = copy_of_quadratic_program(program);
   solution = solve_qp_using_simplex(copy, BOOLEAN_TRUE);
   iteration++;
   if (fabs(solution->optimalvalue) < optimal)
    {
     optimal = fabs(solution->optimalvalue);
     free_convex_solution(best);
     best = solution;
    }
   else
     free_convex_solution(solution);
  }
 free_quadratic_program(copy);
 return best;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xe05c
movq %rax, %r15
xorl %r13d, %r13d
movq %rax, %rdi
xorl %esi, %esi
callq 0xf37e
movq %rax, %r14
movsd 0x8(%rax), %xmm0
andpd 0x86eeb(%rip), %xmm0    # 0x961e0
movapd %xmm0, (%rsp)
pushq $0x1
popq %rbp
movq %r15, %rdi
callq 0xe917
movapd (%rsp), %xmm0
ucomisd 0x86ace(%rip), %xmm0    # 0x95de0
jbe 0xf36c
cmpl $0x9, %r13d
ja 0xf36c
movq %rbx, %rdi
callq 0xe05c
movq %rax, %r15
movq %rax, %rdi
movl %ebp, %esi
callq 0xf37e
movq %rax, %r12
movsd 0x8(%rax), %xmm1
andpd 0x86ea1(%rip), %xmm1    # 0x961e0
movapd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
ja 0xf357
movq %r12, %rdi
callq 0xe94d
incl %r13d
jmp 0xf2fd
movq %r14, %rdi
movapd %xmm1, (%rsp)
callq 0xe94d
incl %r13d
movq %r12, %r14
jmp 0xf2fd
movq %r14, %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/data.c
// Function: normalize_regression_values
void normalize_regression_values(Instanceptr myptr, double mean, double variance)
{
 /*!Last Changed 21.12.2005*/
 Instanceptr tmp;
 int classfno;
 NORMALIZATION_TYPE normtype = get_parameter_l("normalization");
 classfno = current_dataset->classdefno;
 tmp = myptr;
 while (tmp)
  {
   switch (normtype)
    {
     case        Z_NORMALIZATION:
     case   VECTOR_NORMALIZATION:tmp->values[classfno].floatvalue = (tmp->values[classfno].floatvalue - mean) / sqrt(variance);
                                 break;
     case STANDARD_NORMALIZATION:tmp->values[classfno].floatvalue = (tmp->values[classfno].floatvalue - current_dataset->features[classfno].min.floatvalue) / (current_dataset->features[classfno].max.floatvalue - current_dataset->features[classfno].min.floatvalue);
                                 break;
    }
   
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm1, (%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rdi, %rbx
leaq 0x86e67(%rip), %rdi     # 0x96360
callq 0x4cf11
movsd (%rsp), %xmm3
movl %eax, %ebp
leaq 0xbe364(%rip), %r14     # 0xcd870
movq (%r14), %rax
movslq 0x1407128(%rax), %r15
sqrtsd %xmm3, %xmm4
xorpd %xmm5, %xmm5
imulq $0x340, %r15, %r12      # imm = 0x340
movsd %xmm4, 0x8(%rsp)
testq %rbx, %rbx
je 0xf5c9
cmpl $0x2, %ebp
je 0xf542
cmpl $0x1, %ebp
je 0xf58e
testl %ebp, %ebp
jne 0xf5c0
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm1
ucomisd %xmm5, %xmm3
movapd %xmm4, %xmm0
jae 0xf579
movapd %xmm3, %xmm0
movsd %xmm1, 0x10(%rsp)
callq 0x4300
movsd 0x10(%rsp), %xmm1
xorpd %xmm5, %xmm5
movsd 0x8(%rsp), %xmm4
movsd (%rsp), %xmm3
subsd 0x18(%rsp), %xmm1
divsd %xmm0, %xmm1
movq (%rbx), %rax
movsd %xmm1, (%rax,%r15,8)
jmp 0xf5c0
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
movq (%r14), %rcx
movsd 0x30f10(%rcx,%r12), %xmm1
movsd 0x30f18(%rcx,%r12), %xmm2
subsd %xmm1, %xmm0
subsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movsd %xmm0, (%rax,%r15,8)
movq 0x10(%rbx), %rbx
jmp 0xf52b
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: unnormalize_instance
void unnormalize_instance(Instanceptr myptr, Instance mean, Instance variance)
{
 int i;
 Instanceptr temp;
 temp = myptr;
 if (mustrealize)
  {
   for (i = 0; i < current_dataset->multifeaturecount; i++)
     if (i != current_dataset->classdefno)
       temp->values[i].floatvalue = (double) (temp->values[i].floatvalue * sqrt(variance.values[i].floatvalue) + mean.values[i].floatvalue);
  }
 else
  {
   for (i = 0; i < current_dataset->featurecount; i++)
     switch (current_dataset->features[i].type)
      {
       case INTEGER:temp->values[i].intvalue = (int) (temp->values[i].floatvalue * sqrt(variance.values[i].floatvalue) + mean.values[i].floatvalue);
                    break;
       case    REAL:temp->values[i].floatvalue = (double) (temp->values[i].floatvalue * sqrt(variance.values[i].floatvalue) + mean.values[i].floatvalue);
                    break;
      }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x39a9b9(%rip), %rax    # 0x3a9fa4
cmpl $0x0, (%rax)
movq 0x70(%rsp), %r14
movq 0x40(%rsp), %r15
je 0xf671
leaq 0xbe26f(%rip), %r12     # 0xcd870
movq (%r12), %rax
xorl %r13d, %r13d
xorpd %xmm1, %xmm1
movslq 0x1c0(%rax), %rcx
cmpq %rcx, %r13
jge 0xf73c
movl 0x1407128(%rax), %ecx
cmpq %rcx, %r13
je 0xf66c
movq (%rbx), %rax
movsd (%rax,%r13,8), %xmm2
movsd (%r14,%r13,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0xf642
sqrtsd %xmm0, %xmm0
jmp 0xf655
movsd %xmm2, (%rsp)
callq 0x4300
movsd (%rsp), %xmm2
xorpd %xmm1, %xmm1
mulsd %xmm0, %xmm2
addsd (%r15,%r13,8), %xmm2
movq (%rbx), %rax
movsd %xmm2, (%rax,%r13,8)
movq (%r12), %rax
incq %r13
jmp 0xf60c
movl $0x61e1, %r12d          # imm = 0x61E1
xorl %r13d, %r13d
leaq 0xbe1ef(%rip), %rbp     # 0xcd870
xorpd %xmm1, %xmm1
movq (%rbp), %rax
movslq 0x1bc(%rax), %rcx
cmpq %rcx, %r13
jge 0xf73c
movl (%rax,%r12,8), %eax
cmpl $0x2, %eax
je 0xf6c5
testl %eax, %eax
jne 0xf730
movq (%rbx), %rax
movsd (%rax,%r13,8), %xmm2
movsd (%r14,%r13,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0xf6e0
sqrtsd %xmm0, %xmm0
jmp 0xf6f3
movq (%rbx), %rax
movsd (%rax,%r13,8), %xmm2
movsd (%r14,%r13,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0xf70a
sqrtsd %xmm0, %xmm0
jmp 0xf71d
movsd %xmm2, (%rsp)
callq 0x4300
movsd (%rsp), %xmm2
xorpd %xmm1, %xmm1
mulsd %xmm0, %xmm2
addsd (%r15,%r13,8), %xmm2
cvttsd2si %xmm2, %eax
movq (%rbx), %rcx
movl %eax, (%rcx,%r13,8)
jmp 0xf730
movsd %xmm2, (%rsp)
callq 0x4300
movsd (%rsp), %xmm2
xorpd %xmm1, %xmm1
mulsd %xmm0, %xmm2
addsd (%r15,%r13,8), %xmm2
movq (%rbx), %rax
movsd %xmm2, (%rax,%r13,8)
incq %r13
addq $0x68, %r12
jmp 0xf685
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/data.c
// Function: normalize
void normalize(Instanceptr myptr, Instance mean, Instance variance)
{
 /*!Last Changed 20.03.2002*/
 Instanceptr temp;
 temp = myptr;
 while (temp)
  {
   normalize_instance(temp, mean, variance);
   temp = temp->next;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0xb0(%rsp), %r14
leaq 0x80(%rsp), %r15
testq %rbx, %rbx
je 0xfb40
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x50(%rsp)
movups %xmm1, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xf74b
movq 0x10(%rbx), %rbx
jmp 0xfaf4
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: realize_instance
void realize_instance(Instanceptr myptr)
{
 Instanceptr tmp = myptr;
 int i, j, k;
 i = current_dataset->featurecount - 1;
 j = current_dataset->multifeaturecount - 1;
 if (i != j)
  tmp->values = (union value *) alloc(tmp->values, current_dataset->multifeaturecount * sizeof(union value), current_dataset->multifeaturecount);
 while (i >= 0)
  {
   switch (current_dataset->features[i].type)
    {
     case INTEGER  :tmp->values[j].floatvalue = (double) tmp->values[i].intvalue;
                    j--;
                    break;
     case REGDEF   :
     case REAL     :tmp->values[j].floatvalue = tmp->values[i].floatvalue;
                    j--;
                    break;
     case CLASSDEF :tmp->values[j].stringindex = tmp->values[i].stringindex;
                    j--;
                    break;
     case STRING   :for (k = 0; k < current_dataset->features[i].valuecount; k++)
                      if (k == tmp->values[i].stringindex)
                        tmp->values[j-k].floatvalue = 1;
                      else
                        tmp->values[j-k].floatvalue = 0;
                    j -= current_dataset->features[i].valuecount;
                    break;
     default       :printf(m1238, current_dataset->features[i].type);
                    break;
    }
   i--;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xbdd11(%rip), %r15     # 0xcd870
movq (%r15), %rax
movl 0x1bc(%rax), %r12d
movslq 0x1c0(%rax), %r14
cmpl %r14d, %r12d
je 0xfb8a
movq (%rbx), %rdi
movq %r14, %rsi
shlq $0x3, %rsi
movl %r14d, %edx
callq 0x34f30
movq %rax, (%rbx)
leal -0x1(%r14), %ebp
imulq $0x340, %r12, %r14      # imm = 0x340
xorl %r13d, %r13d
leal (%r12,%r13), %eax
testl %eax, %eax
jle 0xfc72
movq (%r15), %rdi
movl 0x30bc8(%rdi,%r14), %esi
cmpq $0x4, %rsi
jbe 0xfbcf
leaq 0x867b2(%rip), %rdi     # 0x9636e
xorl %eax, %eax
callq 0x4030
decq %r13
addq $-0x340, %r14           # imm = 0xFCC0
jmp 0xfb98
leaq 0x86762(%rip), %rax     # 0x96338
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
movslq %ebp, %rax
jmpq *%rcx
movq (%rbx), %rcx
leaq (%rcx,%r12,8), %rdx
movsd -0x8(%rdx,%r13,8), %xmm0
movsd %xmm0, (%rcx,%rax,8)
jmp 0xfc1e
movq (%rbx), %rcx
leaq (%rcx,%r12,8), %rdx
movl -0x8(%rdx,%r13,8), %edx
movl %edx, (%rcx,%rax,8)
jmp 0xfc1e
movq (%rbx), %rax
leaq (%rax,%r12,8), %rcx
cvtsi2sdl -0x8(%rcx,%r13,8), %xmm0
movslq %ebp, %rcx
movsd %xmm0, (%rax,%rcx,8)
decl %ebp
addq %r13, %r12
decq %r12
jmp 0xfb8e
leaq -0x8(,%r12,8), %rcx
xorl %edx, %edx
movslq 0x30be0(%rdi,%r14), %rsi
cmpq %rsi, %rdx
jge 0xfc6e
movq (%rbx), %rsi
leaq (%rsi,%rcx), %rdi
movl (%rdi,%r13,8), %edi
movsd 0x858cb(%rip), %xmm0    # 0x95520
cmpq %rdi, %rdx
je 0xfc5e
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsi,%rax,8)
incq %rdx
movq (%r15), %rdi
decq %rax
jmp 0xfc35
subl %esi, %ebp
jmp 0xfc20
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/data.c
// Function: realize
void realize(Instanceptr myptr)
{
 /*!Last Changed 10.03.2004 extended to regression*/
 Instanceptr tmp = myptr;
 while(tmp)
  {
   realize_instance(tmp);
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0xfc98
movq %rbx, %rdi
callq 0xfb4a
movq 0x10(%rbx), %rbx
jmp 0xfc85
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: dimension_reduce_with_pca
void dimension_reduce_with_pca(Instanceptr inst, int howmany, matrix eigenvect)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 Instanceptr tmp = inst;
 int i, j, k;
 double* values, sum;
 values = (double *)safemalloc((current_dataset->multifeaturecount - 1) * sizeof(double), "dimension_reduce_with_pca", 4);
 while (tmp)
  {
   for (i = 0; i < howmany; i++)
    {
     sum = 0;
     for (j = 0; j < current_dataset->multifeaturecount - 1; j++)
       sum += eigenvect.values[j][i] * real_feature(tmp, j);
     values[i] = sum;
    }
   k = 0;
   for (j = 0; j < current_dataset->multifeaturecount - 1 && k < howmany; j++)
     if (in_list(current_dataset->features[j].type, 2, REAL, INTEGER))
      {
       tmp->values[j].floatvalue = (double) values[k];
       k++;
      }
   tmp = tmp->next;
  }
 safe_free(values);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %esi, %r15d
movq %rdi, %r14
leaq 0xbdbb8(%rip), %rbp     # 0xcd870
movq (%rbp), %rax
movslq 0x1c0(%rax), %rax
leaq -0x8(,%rax,8), %rdi
leaq 0x866c7(%rip), %rsi     # 0x96399
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r12
testl %r15d, %r15d
movl $0x0, %eax
movl %r15d, 0xc(%rsp)
cmovgl %r15d, %eax
movq %rax, 0x18(%rsp)
movq %r12, 0x10(%rsp)
testq %r14, %r14
je 0xfdda
xorl %r15d, %r15d
cmpq 0x18(%rsp), %r15
je 0xfd6e
xorpd %xmm0, %xmm0
xorl %r13d, %r13d
movq (%rbp), %rax
movslq 0x1c0(%rax), %rax
decq %rax
cmpq %rax, %r13
jge 0xfd63
movq (%rbx,%r13,8), %rax
movsd (%rax,%r15,8), %xmm1
movsd %xmm1, 0x20(%rsp)
movq %r14, %rdi
movl %r13d, %esi
movsd %xmm0, (%rsp)
callq 0x2aea2
mulsd 0x20(%rsp), %xmm0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r13
jmp 0xfd12
movsd %xmm0, (%r12,%r15,8)
incq %r15
jmp 0xfd04
xorl %r13d, %r13d
movl $0x61e1, %r12d          # imm = 0x61E1
xorl %r15d, %r15d
movq (%rbp), %rax
movslq 0x1c0(%rax), %rcx
decq %rcx
cmpq %rcx, %r13
jge 0xfdcc
cmpl 0xc(%rsp), %r15d
jge 0xfdcc
movl (%rax,%r12,8), %edi
pushq $0x2
popq %rdx
movl %edx, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0xfdc3
movslq %r15d, %rax
movq 0x10(%rsp), %rcx
movsd (%rcx,%rax,8), %xmm0
movq (%r14), %rax
movsd %xmm0, (%rax,%r13,8)
incl %r15d
incq %r13
addq $0x68, %r12
jmp 0xfd7a
movq 0x10(%r14), %r14
movq 0x10(%rsp), %r12
jmp 0xfcf8
movq %r12, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: distance_matrix
matrix distance_matrix(Instanceptr myptr)
{
 /*!Last Changed 17.01.2008*/
 int i, j, size;
 Instanceptr temp1, temp2;
 matrix result;
 size = data_size(myptr);
 result = matrix_alloc(size, size);
 for (i = 0, temp1 = myptr; i < size; i++, temp1 = temp1->next)
   for (j = 0, temp2 = myptr; j < size; j++, temp2 = temp2->next)
     result.values[i][j] = distance_between_instances(temp1, temp2);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
callq 0x2c3cc
movl %eax, %r12d
movl %eax, %edi
movl %eax, %esi
callq 0x380d3
movq %rax, (%rsp)
movq %rdx, %r15
xorl %r14d, %r14d
testl %r12d, %r12d
movl $0x0, %eax
cmovgl %r12d, %eax
movq %rax, 0x10(%rsp)
movl %r12d, %ebx
movq %r13, 0x8(%rsp)
movq %r13, %r12
cmpq 0x10(%rsp), %r14
je 0xfe72
xorl %ebp, %ebp
movq 0x8(%rsp), %r13
cmpq %rbp, %rbx
je 0xfe68
movq %r12, %rdi
movq %r13, %rsi
callq 0x2beed
movq (%r15,%r14,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
movq 0x10(%r13), %r13
jmp 0xfe46
incq %r14
movq 0x10(%r12), %r12
jmp 0xfe38
movq (%rsp), %rax
movq %r15, %rdx
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/data.c
// Function: distance_matrix_with_threshold
matrix distance_matrix_with_threshold(Instanceptr myptr, double epsilon)
{
 /*!Last Changed 17.01.2008*/
 int i, j, size;
 Instanceptr temp1, temp2;
 matrix result;
 double distance;
 size = data_size(myptr);
 result = matrix_alloc(size, size);
 for (i = 0, temp1 = myptr; i < size; i++, temp1 = temp1->next)
   for (j = 0, temp2 = myptr; j < size; j++, temp2 = temp2->next)    
    {
     distance = distance_between_instances(temp1, temp2);
     if (distance < epsilon)
       result.values[i][j] = distance;
     else
       result.values[i][j] = +LONG_MAX;
    }
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movq %rdi, %r13
callq 0x2c3cc
movl %eax, %r12d
movl %eax, %edi
movl %eax, %esi
callq 0x380d3
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
testl %r12d, %r12d
movl $0x0, %eax
cmovgl %r12d, %eax
movq %rax, 0x18(%rsp)
movq %rdx, %r15
movl %r12d, %ebx
movq %r13, 0x10(%rsp)
movq %r13, %r12
cmpq 0x18(%rsp), %r14
je 0xff30
xorl %ebp, %ebp
movq 0x10(%rsp), %r13
cmpq %rbp, %rbx
je 0xff26
movq %r12, %rdi
movq %r13, %rsi
callq 0x2beed
movq (%r15,%r14,8), %rax
movapd %xmm0, %xmm1
cmpltsd 0x20(%rsp), %xmm1
andpd %xmm1, %xmm0
movsd 0x86420(%rip), %xmm2    # 0x96330
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
movlpd %xmm1, (%rax,%rbp,8)
incq %rbp
movq 0x10(%r13), %r13
jmp 0xfee5
incq %r14
movq 0x10(%r12), %r12
jmp 0xfed7
movq 0x8(%rsp), %rax
movq %r15, %rdx
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/data.c
// Function: distance_matrix_with_k
matrix distance_matrix_with_k(Instanceptr myptr, int k)
{
 /*!Last Changed 31.03.2008*/
 int i, j, size;
 Instanceptr temp1, temp2;
 matrix result;
 double distance, threshold;
 size = data_size(myptr);
 result = matrix_alloc(size, size);
 for (i = 0, temp1 = myptr; i < size; i++, temp1 = temp1->next)
  {
   threshold = find_k_nearest_neighbor_distance(myptr, temp1, k);
   for (j = 0, temp2 = myptr; j < size; j++, temp2 = temp2->next)    
    {
     distance = distance_between_instances(temp1, temp2);
     if (distance < threshold + DBL_DELTA)
       result.values[i][j] = distance;
     else
       result.values[i][j] = +LONG_MAX;
    }
  }
 /*Make distance matrix symmetric*/
 for (i = 0; i < size; i++)
   for (j = i + 1; j < size; j++)
     if (result.values[i][j] < result.values[j][i])
       result.values[j][i] = result.values[i][j];
     else
       result.values[i][j] = result.values[j][i];     
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, 0x4(%rsp)
movq %rdi, %r15
callq 0x2c3cc
movl %eax, %r12d
movl %eax, %edi
movl %eax, %esi
callq 0x380d3
movq %rax, 0x8(%rsp)
movq %rdx, %r14
xorl %ebx, %ebx
testl %r12d, %r12d
movl $0x0, %r8d
cmovgl %r12d, %r8d
movl %r12d, %ebp
movq %r15, 0x10(%rsp)
movq %r15, %r12
movq %r8, 0x18(%rsp)
cmpq %r8, %rbx
je 0x1000f
movq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movl 0x4(%rsp), %edx
callq 0x2d78f
addsd 0x85e2b(%rip), %xmm0    # 0x95de0
movsd %xmm0, 0x20(%rsp)
xorl %r15d, %r15d
cmpq %r15, %rbp
je 0x10000
movq %r12, %rdi
movq %r13, %rsi
callq 0x2beed
movq (%r14,%rbx,8), %rax
movapd %xmm0, %xmm1
cmpltsd 0x20(%rsp), %xmm1
andpd %xmm1, %xmm0
movsd 0x86347(%rip), %xmm2    # 0x96330
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
movlpd %xmm1, (%rax,%r15,8)
incq %r15
movq 0x10(%r13), %r13
jmp 0xffbe
incq %rbx
movq 0x10(%r12), %r12
movq 0x18(%rsp), %r8
jmp 0xff94
pushq $0x1
popq %rax
xorl %ecx, %ecx
cmpq %r8, %rcx
je 0x10051
movq %rax, %rdx
cmpl %edx, %ebp
jle 0x10049
movq (%r14,%rcx,8), %rsi
movsd (%rsi,%rdx,8), %xmm0
movq (%r14,%rdx,8), %rdi
movsd (%rdi,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1003f
movsd %xmm0, (%rdi,%rcx,8)
jmp 0x10044
movsd %xmm1, (%rsi,%rdx,8)
incq %rdx
jmp 0x1001c
incq %rcx
incq %rax
jmp 0x10014
movq 0x8(%rsp), %rax
movq %r14, %rdx
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/data.c
// Function: class_covariance
matrix class_covariance(Instanceptr myptr, int classno, Instanceptr classmean)
{
 /*!Last Changed 26.03.2002*/
 int i,j,size = 0;
 matrix temp;
 Instanceptr current = myptr;
 temp = matrix_alloc(current_dataset->multifeaturecount - 1, current_dataset->multifeaturecount - 1);
 while (current)
  {
   if (give_classno(current) == classno)
    {
     for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
       for (j = 0; j < current_dataset->multifeaturecount - 1; j++)
         temp.values[i][j] += (real_feature(current, i) - real_feature(classmean, i)) * (real_feature(current, j) - real_feature(classmean, j));
     size++;
    }
   current = current->next;
  }
 for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
   for (j = 0; j < current_dataset->multifeaturecount - 1; j++)
     if (size > 1)
       temp.values[i][j] /= (size - 1);
     else
       temp.values[i][j] = 0;
 return temp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, %r12
leaq 0xbd7ea(%rip), %rbp     # 0xcd870
movq (%rbp), %rax
movl 0x1c0(%rax), %edi
decl %edi
movl %edi, %esi
callq 0x380d3
movq %rax, 0x10(%rsp)
movq %rdx, %r14
xorl %ebx, %ebx
movl %r13d, 0xc(%rsp)
testq %r12, %r12
je 0x1017d
movq %r12, %rdi
callq 0x2b47e
cmpl %r13d, %eax
jne 0x10173
movq %rbx, 0x18(%rsp)
movq (%rbp), %rax
movl 0x1c0(%rax), %eax
xorl %r13d, %r13d
leal -0x1(%rax), %ecx
movslq %ecx, %rcx
cmpq %rcx, %r13
jge 0x10167
xorl %ebx, %ebx
leal -0x1(%rax), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rbx
jge 0x1015f
movq %r12, %rdi
movl %r13d, %esi
callq 0x2aea2
movsd %xmm0, (%rsp)
movq %r15, %rdi
movl %r13d, %esi
callq 0x2aea2
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x2aea2
movsd %xmm0, 0x20(%rsp)
movq %r15, %rdi
movl %ebx, %esi
callq 0x2aea2
movsd 0x20(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd (%rsp), %xmm1
movq (%r14,%r13,8), %rax
addsd (%rax,%rbx,8), %xmm1
movsd %xmm1, (%rax,%rbx,8)
incq %rbx
movq (%rbp), %rax
movl 0x1c0(%rax), %eax
jmp 0x100e5
incq %r13
jmp 0x100d4
movq 0x18(%rsp), %rbx
incl %ebx
movl 0xc(%rsp), %r13d
movq 0x10(%r12), %r12
jmp 0x100a8
movq (%rbp), %rax
movl 0x1c0(%rax), %eax
decl %eax
leal -0x1(%rbx), %ecx
cvtsi2sd %ecx, %xmm0
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rdx, %rcx
je 0x101cd
xorl %esi, %esi
cmpq %rsi, %rax
je 0x101c8
movq (%r14,%rcx,8), %rdi
xorpd %xmm1, %xmm1
cmpl $0x2, %ebx
jl 0x101be
movsd (%rdi,%rsi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rsi,8)
incq %rsi
jmp 0x101a3
incq %rcx
jmp 0x1019c
movq 0x10(%rsp), %rax
movq %r14, %rdx
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/data.c
// Function: find_bounds_of_feature
void find_bounds_of_feature(Datasetptr d, Instanceptr myptr, int fno, double* min, double* max)
{
 /*!Last Changed 16.09.2004*/
 Instanceptr tmp = myptr;
 double val;
 if (tmp)
  {
   if (d->features[fno].type == INTEGER)
     val = (double)tmp->values[fno].intvalue;
   else
     val = tmp->values[fno].floatvalue;
  }
 else
   val = 0;
 *min = val;
 *max = val;
 while (tmp)
  { 
   if (d->features[fno].type == INTEGER)
     val = (double)tmp->values[fno].intvalue;
   else
     val = tmp->values[fno].floatvalue;
   if (val > *max)
     *max = val;
   else
     if (val < *min)
       *min = val;
   tmp = tmp->next;
  }
}

// Assembly:
movslq %edx, %rax
testq %rsi, %rsi
je 0x10207
imulq $0x340, %rax, %rdx      # imm = 0x340
cmpl $0x0, 0x30f08(%rdi,%rdx)
movq (%rsi), %rdx
je 0x1020d
movsd (%rdx,%rax,8), %xmm0
jmp 0x10212
xorpd %xmm0, %xmm0
jmp 0x10212
cvtsi2sdl (%rdx,%rax,8), %xmm0
movsd %xmm0, (%rcx)
movsd %xmm0, (%r8)
imulq $0x340, %rax, %rdx      # imm = 0x340
addq %rdi, %rdx
addq $0x30f08, %rdx          # imm = 0x30F08
testq %rsi, %rsi
je 0x10266
cmpl $0x0, (%rdx)
movq (%rsi), %rdi
je 0x10240
movsd (%rdi,%rax,8), %xmm0
jmp 0x10245
cvtsi2sdl (%rdi,%rax,8), %xmm0
ucomisd (%r8), %xmm0
movq %r8, %rdi
ja 0x1025c
movsd (%rcx), %xmm1
ucomisd %xmm0, %xmm1
movq %rcx, %rdi
jbe 0x10260
movsd %xmm0, (%rdi)
movq 0x10(%rsi), %rsi
jmp 0x1022c
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: find_bounds_of_feature_class
void find_bounds_of_feature_class(Instanceptr myptr, int fno, int cno, double* min, double* max)
{
 /*oya -- Last Changed 21.4.2006*/
 Instanceptr tmp = myptr;
 double val;
 int i;
 if (tmp)
   val = tmp->values[fno].floatvalue;
 else
   val = 0;
 *min = val;
 *max = val;
 while (tmp)
  { 
   i = give_classno(tmp);
   if (i == cno)
    {
     val = tmp->values[fno].floatvalue;
     if (val > *max)
       *max = val;
     else
       if (val < *min)
         *min = val;
    }
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %r15
testq %rdi, %rdi
je 0x1028d
movq (%r15), %rax
movslq %esi, %r12
movsd (%rax,%r12,8), %xmm0
jmp 0x10294
movslq %esi, %r12
xorpd %xmm0, %xmm0
movsd %xmm0, (%r14)
movsd %xmm0, (%rbx)
testq %r15, %r15
je 0x102d8
movq %r15, %rdi
callq 0x2b47e
cmpl %ebp, %eax
jne 0x102d2
movq (%r15), %rax
movsd (%rax,%r12,8), %xmm0
ucomisd (%rbx), %xmm0
movq %rbx, %rax
ja 0x102ce
movsd (%r14), %xmm1
ucomisd %xmm0, %xmm1
movq %r14, %rax
jbe 0x102d2
movsd %xmm0, (%rax)
movq 0x10(%r15), %r15
jmp 0x1029d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: find_thresholded_class_count
int find_thresholded_class_count(Instanceptr myptr, int classno, int fno, double fval, int dir)
{
 /*oya -- Last Changed 21.04.2006*/
 /*
 dir:LOWER val must be less than fval
 dir:UPPER val must be greater than fval
 */
 int result = 0;
 Instanceptr temp = myptr;
 double val;
 while (temp)
  {
   if (give_classno(temp) == classno)
    {
     val = temp->values[fno].floatvalue;
     if ((dir == LOWER) && (val < fval))
       result++;
     else 
       if ((dir == UPPER) && (val > fval))
         result++;
     }
   temp = temp->next;
  }
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %r14
movslq %edx, %r12
xorl %r15d, %r15d
testq %r14, %r14
je 0x1034c
movq %r14, %rdi
callq 0x2b47e
cmpl %ebp, %eax
jne 0x10346
movq (%r14), %rax
movsd (%rax,%r12,8), %xmm0
testl %ebx, %ebx
jne 0x1032f
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1032f
incl %r15d
jmp 0x10346
cmpl $0x1, %ebx
sete %al
ucomisd 0x8(%rsp), %xmm0
seta %cl
andb %al, %cl
movzbl %cl, %eax
addl %eax, %r15d
movq 0x10(%r14), %r14
jmp 0x10300
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: covariance
matrix covariance(Instanceptr myptr, Instance currentmean)
{
 int i, j, size = data_size(myptr);
 matrix temp;
 Instanceptr current = myptr;
 temp = matrix_alloc(current_dataset->multifeaturecount - 1, current_dataset->multifeaturecount - 1);
 while (current)
  {
   for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
     for (j = 0; j < current_dataset->multifeaturecount - 1; j++)
       temp.values[i][j] += (real_feature(current, i) - real_feature(&currentmean, i)) * (real_feature(current, j) - real_feature(&currentmean, j));
   current = current->next;
  }
 for (i = 0; i < current_dataset->multifeaturecount -1 ; i++)
   for (j = 0; j < current_dataset->multifeaturecount - 1; j++)
     temp.values[i][j] /= (size - 1);
 return temp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
leaq 0x60(%rsp), %r12
callq 0x2c3cc
movl %eax, 0x14(%rsp)
leaq 0xbd171(%rip), %rbp     # 0xcd870
movq (%rbp), %rax
movl 0x1c0(%rax), %edi
decl %edi
movl %edi, %esi
callq 0x380d3
movq %rax, 0x18(%rsp)
movq %rdx, %r14
movq (%rbp), %rax
movl 0x1c0(%rax), %eax
testq %r15, %r15
je 0x107d0
xorl %r13d, %r13d
leal -0x1(%rax), %ecx
movslq %ecx, %rcx
cmpq %rcx, %r13
jge 0x107c7
xorl %ebx, %ebx
leal -0x1(%rax), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rbx
jge 0x107bf
movq %r15, %rdi
movl %r13d, %esi
callq 0x2aea2
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movl %r13d, %esi
callq 0x2aea2
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
movl %ebx, %esi
callq 0x2aea2
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x2aea2
movsd 0x20(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x8(%rsp), %xmm1
movq (%r14,%r13,8), %rax
addsd (%rax,%rbx,8), %xmm1
movsd %xmm1, (%rax,%rbx,8)
incq %rbx
movq (%rbp), %rax
movl 0x1c0(%rax), %eax
jmp 0x10741
incq %r13
jmp 0x10730
movq 0x10(%r15), %r15
jmp 0x1071a
decl %eax
movl 0x14(%rsp), %ecx
decl %ecx
cvtsi2sd %ecx, %xmm0
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rdx, %rcx
je 0x10810
xorl %esi, %esi
cmpq %rsi, %rax
je 0x1080b
movq (%r14,%rcx,8), %rdi
movsd (%rdi,%rsi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rsi,8)
incq %rsi
jmp 0x107ef
incq %rcx
jmp 0x107e8
movq 0x18(%rsp), %rax
movq %r14, %rdx
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/data.c
// Function: find_class_count
int find_class_count(Instanceptr myptr, int classno)
{
 /*!Last Changed 03.12.2003*/
 int result = 0;
 Instanceptr temp = myptr;
 while (temp)
  {
   if (give_classno(temp) == classno)
     result++;
   temp = temp->next;
  }
 return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
testq %r14, %r14
je 0x1084e
movq %r14, %rdi
callq 0x2b47e
xorl %ecx, %ecx
cmpl %ebx, %eax
sete %cl
addl %ecx, %ebp
movq 0x10(%r14), %r14
jmp 0x10832
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: class_exists_in_list
BOOLEAN class_exists_in_list(Instanceptr myptr, int classno)
{
 /*!Last Changed 09.05.2003*/
 Instanceptr temp = myptr;
 while (temp)
  {
   if (give_classno(temp) == classno)
     return BOOLEAN_TRUE;
   temp = temp->next;
  }
 return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x1
popq %rbx
testq %r14, %r14
je 0x10878
movq %r14, %rdi
callq 0x2b47e
cmpl %ebp, %eax
je 0x1087a
movq 0x10(%r14), %r14
jmp 0x10861
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: find_error_as_leaf
int find_error_as_leaf(Instanceptr myptr)
{
 /*!Last Changed 23.05.2006*/
 int i, *result, maxclass = 0, sum = 0;
 result = find_class_counts(myptr);
 for (i = 0; i < current_dataset->classno; i++)
  {
   sum += result[i];
   if (result[i] > maxclass)
     maxclass = result[i];
  } 
 safe_free(result);
 return sum - maxclass;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x108c8
leaq 0xbcfe0(%rip), %rcx     # 0xcd870
movq (%rcx), %rcx
movl 0x10(%rcx), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
xorl %ebp, %ebp
xorl %ebx, %ebx
cmpq %rdx, %rcx
je 0x108b5
movl (%rax,%rdx,4), %esi
addl %esi, %ebx
cmpl %ebp, %esi
cmovgl %esi, %ebp
incq %rdx
jmp 0x108a1
movq %rax, %rdi
callq 0x34ff7
subl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: find_class_counts
int* find_class_counts(Instanceptr myptr)
{
 /*!Last Changed 02.02.2004 added safealloc*/
 /*!Last Changed 16.03.2002*/
 int i;
 Instanceptr temp = myptr;
 int *result;
 result = (int *) safecalloc(current_dataset->classno, sizeof(int), "find_class_counts", 4);
 while (temp)
  {
   i = give_classno(temp);
   result[i]++;
   temp = temp->next;
  }
 return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xbcf9a(%rip), %rax     # 0xcd870
movq (%rax), %rax
movslq 0x10(%rax), %rdi
leaq 0x85adc(%rip), %rdx     # 0x963c0
pushq $0x4
popq %rsi
pushq $0x4
popq %rcx
callq 0x35067
movq %rax, %r14
testq %rbx, %rbx
je 0x1090b
movq %rbx, %rdi
callq 0x2b47e
cltq
incl (%r14,%rax,4)
movq 0x10(%rbx), %rbx
jmp 0x108f2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: all_in_one_class
int all_in_one_class(Instanceptr myptr, int* maxcount)
{
 /*!Last Changed 01.11.2005*/
 /*!Last Changed 23.03.2002*/
 int i, *result, maxindex = -1, maxclass = 0, alone, sum = 0;
 result = find_class_counts(myptr);
 for (i = 0; i < current_dataset->classno; i++)
  {
   sum += result[i];
   if (result[i] > maxclass)
    {
     maxclass = result[i];
     maxindex = i;
    }
  }
 safe_free(result);
 if (sum != maxclass)
   alone = 1;
 else
   alone = 0;
 *maxcount = maxclass;
 if (maxindex == -1)
   return 0;
 else
   return maxindex * 10 + alone;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x108c8
leaq 0xbcf44(%rip), %rcx     # 0xcd870
movq (%rcx), %rcx
movl 0x10(%rcx), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
pushq $-0x1
popq %rbp
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq %rdx, %rcx
je 0x1095c
movl (%rax,%rdx,4), %esi
addl %esi, %r15d
cmpl %r14d, %esi
cmovgl %edx, %ebp
cmovgl %esi, %r14d
incq %rdx
jmp 0x10942
movq %rax, %rdi
callq 0x34ff7
xorl %eax, %eax
cmpl %r14d, %r15d
setne %al
movl %r14d, (%rbx)
imull $0xa, %ebp, %ecx
orl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ebp
cmovnel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: find_classes
int* find_classes(Instanceptr myptr)
{
 /*!Last Changed 28.10.2005*/
 int i = 0;
 Instanceptr temp = myptr;
 int *result;
 result = (int *) safemalloc(data_size(myptr) * sizeof(int), "find_classes", 4);
 while (temp)
  {
   result[i] = give_classno(temp);
   i++;
   temp = temp->next;
  }
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2c3cc
movslq %eax, %rdi
shlq $0x2, %rdi
leaq 0x85a11(%rip), %rsi     # 0x963b3
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r14
movq %rax, %r15
testq %rbx, %rbx
je 0x109ca
movq %rbx, %rdi
callq 0x2b47e
movl %eax, (%r15)
movq 0x10(%rbx), %rbx
addq $0x4, %r15
jmp 0x109b0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: empty_link_list_of_instances
Instanceptr empty_link_list_of_instances(int fcount, int count)
{
 /*!Last Changed 26.11.2005*/
 /*!Last Changed 24.03.2005*/
 /*!Last Changed 22.03.2005*/
 int i;
 Instanceptr result, tmpbefore, tmp;
 result = empty_instance(fcount);
 tmpbefore = result;
 for (i = 1; i < count; i++)
  {
   tmp = empty_instance(fcount);
   tmpbefore->next = tmp;
   tmpbefore = tmp;
  }
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
callq 0x140fd
movq %rax, %r14
pushq $0x1
popq %r15
movq %rax, %r12
cmpl %ebx, %r15d
jge 0x10a04
movl %ebp, %edi
callq 0x140fd
movq %rax, 0x10(%r12)
incl %r15d
jmp 0x109eb
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq