LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xc202a(%rip), %r15     # 0xd2870
movq (%r15), %rax
movl 0x1bc(%rax), %r12d
movslq 0x1c0(%rax), %r14
cmpl %r14d, %r12d
je 0x10871
movq (%rbx), %rdi
movq %r14, %rsi
shlq $0x3, %rsi
movl %r14d, %edx
callq 0x390c8
movq %rax, (%rbx)
testl %r12d, %r12d
jle 0x10955
leal -0x1(%r14), %ebp
leaq 0x92ab3(%rip), %r13     # 0xa3338
movsd 0x91c93(%rip), %xmm1    # 0xa2520
movq %r12, %r14
decq %r12
movq (%r15), %rax
imulq $0x340, %r14, %rcx      # imm = 0x340
movl 0x30bc8(%rcx,%rax), %esi
cmpq $0x4, %rsi
ja 0x1093d
movslq (%r13,%rsi,4), %rax
addq %r13, %rax
jmpq *%rax
movq (%rbx), %rax
movsd (%rax,%r12,8), %xmm0
jmp 0x108de
movq (%rbx), %rax
movl (%rax,%r12,8), %ecx
movslq %ebp, %rdx
movl %ecx, (%rax,%rdx,8)
jmp 0x108e6
movq (%rbx), %rax
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%r12,8), %xmm0
movslq %ebp, %rcx
movsd %xmm0, (%rax,%rcx,8)
decl %ebp
cmpq $0x1, %r14
jg 0x1088d
jmp 0x10955
movq (%r15), %rcx
imulq $0x340, %r12, %rax      # imm = 0x340
movl 0x30f20(%rcx,%rax), %esi
testl %esi, %esi
jle 0x10939
movslq %ebp, %rcx
xorl %edx, %edx
movq (%rbx), %rsi
movl (%rsi,%r12,8), %edi
movapd %xmm1, %xmm0
cmpq %rdi, %rdx
je 0x1091e
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsi,%rcx,8)
incq %rdx
movq (%r15), %rsi
movslq 0x30f20(%rsi,%rax), %rsi
decq %rcx
cmpq %rsi, %rdx
jl 0x1090a
subl %esi, %ebp
jmp 0x108e8
leaq 0x92a2a(%rip), %rdi     # 0xa336e
xorl %eax, %eax
callq 0x4030
movsd 0x91bcd(%rip), %xmm1    # 0xa2520
jmp 0x108e8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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:
testq %rdi, %rdi
je 0x1097f
pushq %rbx
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x10831
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x1096d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x4(%rsp)
movq %rdi, %r14
leaq 0xc1ed1(%rip), %r13     # 0xd2870
movq (%r13), %rax
movslq 0x1c0(%rax), %rax
leaq -0x8(,%rax,8), %rdi
leaq 0x929e0(%rip), %rsi     # 0xa3399
movl $0x4, %edx
callq 0x390f5
movq %rax, %rbp
testq %r14, %r14
je 0x10aee
movl 0x4(%rsp), %eax
movq %rax, 0x18(%rsp)
movq %rbp, 0x10(%rsp)
cmpl $0x0, 0x4(%rsp)
jle 0x10a5e
xorl %r15d, %r15d
movq (%r13), %rax
xorps %xmm0, %xmm0
cmpl $0x2, 0x1c0(%rax)
jl 0x10a4d
xorl %r12d, %r12d
movsd %xmm0, 0x8(%rsp)
movq (%rbx,%r12,8), %rax
movsd (%rax,%r15,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r14, %rdi
movl %r12d, %esi
callq 0x2e4b6
mulsd 0x20(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r12
movq (%r13), %rax
movslq 0x1c0(%rax), %rax
decq %rax
cmpq %rax, %r12
jl 0x109fa
movsd %xmm0, (%rbp,%r15,8)
incq %r15
cmpq 0x18(%rsp), %r15
jne 0x109e7
cmpl $0x0, 0x4(%rsp)
setle %cl
movq (%r13), %rax
cmpl $0x2, 0x1c0(%rax)
setl %dl
orb %cl, %dl
jne 0x10adc
xorl %r12d, %r12d
movl $0x1, %ebp
movl $0x61e1, %r15d          # imm = 0x61E1
movl (%rax,%r15,8), %edi
movl $0x2, %esi
movl $0x2, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0x10abb
movslq %r12d, %r12
movq 0x10(%rsp), %rax
movsd (%rax,%r12,8), %xmm0
movq (%r14), %rax
movsd %xmm0, -0x8(%rax,%rbp,8)
incl %r12d
movq (%r13), %rax
movslq 0x1c0(%rax), %rcx
decq %rcx
cmpq %rcx, %rbp
jge 0x10adc
incq %rbp
addq $0x68, %r15
cmpl 0x4(%rsp), %r12d
jl 0x10a86
movq 0x10(%r14), %r14
testq %r14, %r14
movq 0x10(%rsp), %rbp
jne 0x109dd
movq %rbp, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/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, 0x8(%rsp)
callq 0x2fa14
movl %eax, %ebp
movl %eax, %edi
movl %eax, %esi
callq 0x3c6e5
movq %rax, 0x10(%rsp)
movq %rdx, %r15
testl %ebp, %ebp
jle 0x10b71
movl %ebp, %ebp
xorl %r14d, %r14d
movq 0x8(%rsp), %r12
xorl %ebx, %ebx
movq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2f4ea
movq (%r15,%r14,8), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
movq 0x10(%r13), %r13
cmpq %rbx, %rbp
jne 0x10b44
incq %r14
movq 0x10(%r12), %r12
cmpq %rbp, %r14
jne 0x10b3d
movq 0x10(%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_O1/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 $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movq %rdi, (%rsp)
callq 0x2fa14
movl %eax, %ebp
movl %eax, %edi
movl %eax, %esi
callq 0x3c6e5
movq %rax, 0x8(%rsp)
movq %rdx, %r15
testl %ebp, %ebp
jle 0x10c17
movl %ebp, %ebp
xorl %r14d, %r14d
movq (%rsp), %r12
xorl %ebx, %ebx
movq (%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2f4ea
movsd 0x92752(%rip), %xmm2    # 0xa3330
movapd %xmm0, %xmm1
cmpltsd 0x10(%rsp), %xmm1
andpd %xmm1, %xmm0
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
movq (%r15,%r14,8), %rax
movlpd %xmm1, (%rax,%rbx,8)
incq %rbx
movq 0x10(%r13), %r13
cmpq %rbx, %rbp
jne 0x10bcb
incq %r14
movq 0x10(%r12), %r12
cmpq %rbp, %r14
jne 0x10bc5
movq 0x8(%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_O1/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, 0xc(%rsp)
movq %rdi, 0x10(%rsp)
callq 0x2fa14
movl %eax, %ebx
movl %eax, %edi
movl %eax, %esi
callq 0x3c6e5
movq %rax, 0x18(%rsp)
movq %rdx, %r14
movl %ebx, %r12d
movl %ebx, 0x8(%rsp)
testl %ebx, %ebx
jle 0x10cde
xorl %ebp, %ebp
movq 0x10(%rsp), %r13
movq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movl 0xc(%rsp), %edx
callq 0x31014
addsd 0x9214d(%rip), %xmm0    # 0xa2dd8
movsd %xmm0, 0x20(%rsp)
xorl %ebx, %ebx
movq %r13, %rdi
movq %r15, %rsi
callq 0x2f4ea
movapd %xmm0, %xmm1
cmpltsd 0x20(%rsp), %xmm1
andpd %xmm1, %xmm0
movsd 0x9267b(%rip), %xmm2    # 0xa3330
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
movq (%r14,%rbp,8), %rax
movlpd %xmm1, (%rax,%rbx,8)
incq %rbx
movq 0x10(%r15), %r15
cmpq %rbx, %r12
jne 0x10c93
incq %rbp
movq 0x10(%r13), %r13
cmpq %r12, %rbp
jne 0x10c6f
cmpl $0x0, 0x8(%rsp)
jle 0x10d43
xorl %eax, %eax
movq %r12, %rcx
movq %r14, %rdx
xorl %esi, %esi
movq %rsi, %rdi
incq %rsi
cmpq %r12, %rsi
jae 0x10d33
movq (%r14,%rdi,8), %r8
addq %rax, %r8
movl $0x1, %r9d
movsd (%r8,%r9,8), %xmm0
movq (%rdx,%r9,8), %r10
movsd (%r10,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x10d25
movsd %xmm0, (%r10,%rdi,8)
jmp 0x10d2b
movsd %xmm1, (%r8,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x10d07
addq $0x8, %rdx
addq $0x8, %rax
decq %rcx
cmpq %r12, %rsi
jne 0x10cef
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_O1/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 0xc1af8(%rip), %rbp     # 0xd2870
movq (%rbp), %rax
movl 0x1c0(%rax), %edi
decl %edi
movl %edi, %esi
callq 0x3c6e5
movq %rax, 0x10(%rsp)
movq %rdx, %r14
xorl %ebx, %ebx
testq %r12, %r12
je 0x10e86
movl %r13d, 0xc(%rsp)
movq %r12, %rdi
callq 0x2eaca
cmpl %r13d, %eax
jne 0x10e78
movq %rbx, 0x18(%rsp)
movq (%rbp), %rax
cmpl $0x2, 0x1c0(%rax)
jl 0x10e6c
xorl %r13d, %r13d
movq (%rbp), %rax
cmpl $0x2, 0x1c0(%rax)
jl 0x10e52
xorl %ebx, %ebx
movq %r12, %rdi
movl %r13d, %esi
callq 0x2e4b6
movsd %xmm0, (%rsp)
movq %r15, %rdi
movl %r13d, %esi
callq 0x2e4b6
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x2e4b6
movsd %xmm0, 0x20(%rsp)
movq %r15, %rdi
movl %ebx, %esi
callq 0x2e4b6
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
movslq 0x1c0(%rax), %rax
decq %rax
cmpq %rax, %rbx
jl 0x10ddc
incq %r13
movq (%rbp), %rax
movslq 0x1c0(%rax), %rax
decq %rax
cmpq %rax, %r13
jl 0x10dcd
movq 0x18(%rsp), %rbx
incl %ebx
movl 0xc(%rsp), %r13d
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x10da3
movq (%rbp), %rax
movl 0x1c0(%rax), %eax
cmpl $0x2, %eax
jl 0x10edc
decl %eax
leal -0x1(%rbx), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
cmpl $0x2, %ebx
jl 0x10ec0
movq (%r14,%rcx,8), %rsi
movsd (%rsi,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rdx,8)
jmp 0x10ecc
movq (%r14,%rcx,8), %rsi
movq $0x0, (%rsi,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x10ea7
incq %rcx
cmpq %rax, %rcx
jne 0x10ea5
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_O1/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 0x10f16
imulq $0x340, %rax, %rdx      # imm = 0x340
cmpl $0x0, 0x30f08(%rdi,%rdx)
movq (%rsi), %rdx
je 0x10f1c
movsd (%rdx,%rax,8), %xmm0
jmp 0x10f21
xorpd %xmm0, %xmm0
jmp 0x10f21
cvtsi2sdl (%rdx,%rax,8), %xmm0
movsd %xmm0, (%rcx)
movsd %xmm0, (%r8)
testq %rsi, %rsi
je 0x10f77
imulq $0x340, %rax, %rdx      # imm = 0x340
movl 0x30f08(%rdi,%rdx), %edx
movq (%rsi), %rdi
testl %edx, %edx
je 0x10f4b
movsd (%rdi,%rax,8), %xmm0
jmp 0x10f53
xorps %xmm0, %xmm0
cvtsi2sdl (%rdi,%rax,8), %xmm0
ucomisd (%r8), %xmm0
movq %r8, %rdi
ja 0x10f6a
movsd (%rcx), %xmm1
ucomisd %xmm0, %xmm1
movq %rcx, %rdi
jbe 0x10f6e
movsd %xmm0, (%rdi)
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
jne 0x10f3d
retq
// File: /workspace/github_c_makefile_star2_O1/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
movslq %esi, %r12
testq %rdi, %rdi
je 0x10f9e
movq (%r15), %rax
movsd (%rax,%r12,8), %xmm0
jmp 0x10fa2
xorpd %xmm0, %xmm0
movsd %xmm0, (%r14)
movsd %xmm0, (%rbx)
testq %r15, %r15
je 0x10fe6
movq %r15, %rdi
callq 0x2eaca
cmpl %ebp, %eax
jne 0x10fe0
movq (%r15), %rax
movsd (%rax,%r12,8), %xmm0
ucomisd (%rbx), %xmm0
movq %rbx, %rax
ja 0x10fdc
movsd (%r14), %xmm1
ucomisd %xmm0, %xmm1
movq %r14, %rax
jbe 0x10fe0
movsd %xmm0, (%rax)
movq 0x10(%r15), %r15
jmp 0x10fab
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movsd %xmm0, 0x8(%rsp)
testq %rdi, %rdi
je 0x1105f
movl %ecx, %ebx
movl %esi, %ebp
movq %rdi, %r15
movslq %edx, %r12
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x2eaca
cmpl %ebp, %eax
jne 0x11054
movq (%r15), %rax
movsd (%rax,%r12,8), %xmm0
testl %ebx, %ebx
jne 0x1103d
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1103d
incl %r14d
jmp 0x11054
cmpl $0x1, %ebx
sete %al
ucomisd 0x8(%rsp), %xmm0
seta %cl
andb %al, %cl
movzbl %cl, %eax
addl %eax, %r14d
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x11013
jmp 0x11062
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
callq 0x2fa14
movl %eax, 0x14(%rsp)
leaq 0xc1486(%rip), %rbp     # 0xd2870
movq (%rbp), %rax
movl 0x1c0(%rax), %edi
decl %edi
movl %edi, %esi
callq 0x3c6e5
movq %rax, 0x18(%rsp)
movq %rdx, %r14
testq %r15, %r15
je 0x114d7
leaq 0x60(%rsp), %r12
movq (%rbp), %rax
cmpl $0x2, 0x1c0(%rax)
jl 0x114ca
xorl %r13d, %r13d
movq (%rbp), %rax
cmpl $0x2, 0x1c0(%rax)
jl 0x114b0
xorl %ebx, %ebx
movq %r15, %rdi
movl %r13d, %esi
callq 0x2e4b6
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movl %r13d, %esi
callq 0x2e4b6
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
movl %ebx, %esi
callq 0x2e4b6
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x2e4b6
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
movslq 0x1c0(%rax), %rax
decq %rax
cmpq %rax, %rbx
jl 0x11436
incq %r13
movq (%rbp), %rax
movslq 0x1c0(%rax), %rax
decq %rax
cmpq %rax, %r13
jl 0x11427
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x11413
movq (%rbp), %rax
movl 0x1c0(%rax), %eax
cmpl $0x2, %eax
jl 0x1151d
decl %eax
movl 0x14(%rsp), %ecx
decl %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movl %eax, %eax
xorl %ecx, %ecx
movq (%r14,%rcx,8), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x114ff
incq %rcx
cmpq %rax, %rcx
jne 0x114f9
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_O1/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
testq %rdi, %rdi
je 0x11560
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2eaca
xorl %ecx, %ecx
cmpl %ebx, %eax
sete %cl
addl %ecx, %ebp
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x11544
jmp 0x11562
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x11595
movl %esi, %ebp
movq %rdi, %r14
movq %r14, %rdi
callq 0x2eaca
cmpl %ebp, %eax
je 0x11590
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x11579
jmp 0x11595
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
callq 0x115e1
leaq 0xc12c7(%rip), %rcx     # 0xd2870
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
testq %rcx, %rcx
jle 0x115cf
xorl %esi, %esi
xorl %ebx, %ebx
xorl %edx, %edx
movl (%rax,%rsi,4), %edi
addl %edi, %ebx
cmpl %edx, %edi
cmovgl %edi, %edx
incq %rsi
cmpq %rsi, %rcx
jne 0x115bb
jmp 0x115d3
xorl %edx, %edx
xorl %ebx, %ebx
subl %edx, %ebx
movq %rax, %rdi
callq 0x39194
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc1281(%rip), %rax     # 0xd2870
movq (%rax), %rax
movslq 0x10(%rax), %rdi
leaq 0x91dc3(%rip), %rdx     # 0xa33c0
movl $0x4, %esi
movl $0x4, %ecx
callq 0x39210
movq %rax, %r14
testq %rbx, %rbx
je 0x11628
movq %rbx, %rdi
callq 0x2eaca
cltq
incl (%r14,%rax,4)
movq 0x10(%rbx), %rbx
jmp 0x1160f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq %rsi, %rbx
callq 0x115e1
leaq 0xc1226(%rip), %rcx     # 0xd2870
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
xorl %ebp, %ebp
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rcx, %rcx
jle 0x11681
xorl %edx, %edx
xorl %r12d, %r12d
xorl %r15d, %r15d
movl (%rax,%rdx,4), %esi
addl %esi, %r12d
cmpl %r15d, %esi
cmovgl %edx, %r14d
cmovgl %esi, %r15d
incq %rdx
cmpq %rdx, %rcx
jne 0x11666
jmp 0x11687
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rax, %rdi
callq 0x39194
xorl %ecx, %ecx
cmpl %r15d, %r12d
setne %cl
movl %r15d, (%rbx)
leal (%r14,%r14), %eax
leal (%rax,%rax,4), %eax
orl %ecx, %eax
cmpl $-0x1, %r14d
cmovel %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2fa14
movslq %eax, %rdi
shlq $0x2, %rdi
leaq 0x91ce5(%rip), %rsi     # 0xa33b3
movl $0x4, %edx
callq 0x390f5
movq %rax, %r14
testq %rbx, %rbx
je 0x116fb
movq %r14, %r15
movq %rbx, %rdi
callq 0x2eaca
movl %eax, (%r15)
movq 0x10(%rbx), %rbx
addq $0x4, %r15
testq %rbx, %rbx
jne 0x116e3
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
callq 0x152fc
movq %rax, %r14
cmpl $0x2, %ebx
jl 0x11733
decl %ebx
movq %r14, %r15
movl %ebp, %edi
callq 0x152fc
movq %rax, 0x10(%r15)
movq %rax, %r15
decl %ebx
jne 0x11721
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/data.c
// Function: allocate_feature_counts
int*** allocate_feature_counts()
{
 /*!Last Changed 11.08.2007*/
 int i, j;
 int*** feature_counts;
 feature_counts = (int ***)safemalloc(current_dataset->classno * sizeof(int **), "allocate_feature_counts", 3);
 for (i = 0;i < current_dataset->classno; i++)
   {
    feature_counts[i] = (int **)safemalloc(current_dataset->featurecount * sizeof(int *), "allocate_feature_counts", 6);
    for (j = 0;j < current_dataset->featurecount; j++)
      if (current_dataset->features[j].type == STRING)
        feature_counts[i][j] = (int *)safecalloc(current_dataset->features[j].valuecount, sizeof(int), "allocate_feature_counts", 9);
   }
 return feature_counts;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xc111d(%rip), %r15     # 0xd2870
movq (%r15), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x91c6d(%rip), %rsi     # 0xa33d2
movl $0x3, %edx
callq 0x390f5
movq %rax, %rbx
movq (%r15), %rax
cmpl $0x0, 0x10(%rax)
jle 0x11804
xorl %r12d, %r12d
leaq 0x91c49(%rip), %r14     # 0xa33d2
movslq 0x1bc(%rax), %rdi
shlq $0x3, %rdi
movq %r14, %rsi
movl $0x6, %edx
callq 0x390f5
movq %rax, (%rbx,%r12,8)
movq (%r15), %rax
cmpl $0x0, 0x1bc(%rax)
jle 0x117f5
movl $0x61e4, %r13d          # imm = 0x61E4
xorl %ebp, %ebp
cmpl $0x1, -0x18(%rax,%r13,8)
jne 0x117df
movslq (%rax,%r13,8), %rdi
movl $0x4, %esi
movq %r14, %rdx
movl $0x9, %ecx
callq 0x39210
movq (%rbx,%r12,8), %rcx
movq %rax, (%rcx,%rbp,8)
incq %rbp
movq (%r15), %rax
movslq 0x1bc(%rax), %rcx
addq $0x68, %r13
cmpq %rcx, %rbp
jl 0x117b9
incq %r12
movq (%r15), %rax
movslq 0x10(%rax), %rcx
cmpq %rcx, %r12
jl 0x11789
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_O1/olcaytaner[P]Isell/data.c
// Function: free_feature_counts
void free_feature_counts(int*** feature_counts)
{
 /*!Last Changed 11.08.2007*/
 int i, j;
 for (i = 0; i < current_dataset->classno; i++)
  {
   for (j = 0; j < current_dataset->featurecount; j++)
     if (current_dataset->features[j].type == STRING)
       safe_free(feature_counts[i][j]);
   safe_free(feature_counts[i]);
  }
 safe_free(feature_counts);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xc1047(%rip), %r14     # 0xd2870
movq (%r14), %rax
cmpl $0x0, 0x10(%rax)
jle 0x1188c
xorl %r15d, %r15d
movq (%r14), %rax
cmpl $0x0, 0x1bc(%rax)
jle 0x11874
movl $0x61e1, %r12d          # imm = 0x61E1
xorl %r13d, %r13d
cmpl $0x1, (%rax,%r12,8)
jne 0x1185e
movq (%rbx,%r15,8), %rax
movq (%rax,%r13,8), %rdi
callq 0x39194
incq %r13
movq (%r14), %rax
movslq 0x1bc(%rax), %rcx
addq $0x68, %r12
cmpq %rcx, %r13
jl 0x1184a
movq (%rbx,%r15,8), %rdi
callq 0x39194
incq %r15
movq (%r14), %rax
movslq 0x10(%rax), %rax
cmpq %rax, %r15
jl 0x11835
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/data.c
// Function: find_feature_counts
int*** find_feature_counts(Instanceptr myptr)
{
 /*!Last Changed 11.08.2007*/
 int i, j;
 Instanceptr tmp;
 int*** feature_counts = allocate_feature_counts();
 tmp = myptr;
 while (tmp)
  {
   i = give_classno(tmp);
   for (j = 0; j < current_dataset->featurecount; j++)
     if (current_dataset->features[j].type == STRING)
       feature_counts[i][j][tmp->values[j].stringindex]++;
   tmp = tmp->next;
  }
 return feature_counts;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x11741
movq %rax, %r14
testq %rbx, %rbx
je 0x1190f
leaq 0xc0fb7(%rip), %r15     # 0xd2870
movq %rbx, %rdi
callq 0x2eaca
movq (%r15), %rcx
cmpl $0x0, 0x1bc(%rcx)
jle 0x11906
leaq 0x30f08(%rcx), %rdx
cltq
xorl %esi, %esi
cmpl $0x1, (%rdx)
jne 0x118f0
movq (%r14,%rax,8), %rdi
movq (%rdi,%rsi,8), %rdi
movq (%rbx), %r8
movslq (%r8,%rsi,8), %r8
incl (%rdi,%r8,4)
incq %rsi
movslq 0x1bc(%rcx), %rdi
addq $0x340, %rdx            # imm = 0x340
cmpq %rdi, %rsi
jl 0x118d8
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x118b9
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/data.c
// Function: find_class_variance
double* find_class_variance(Instanceptr myptr, Instanceptr classmeans, int *counts)
{
 /*!Last Changed 11.07.2006*/
 /*!Last Changed 19.12.2005*/
 int i, j;
 double* result;
 Instanceptr temp, m_i;
 result = safecalloc(current_dataset->classno, sizeof(double), "find_class_variance", 3);
 temp = myptr;
 while (temp)/*Adding values to total*/
  {
   i = give_classno(temp);
   m_i = data_x(classmeans, i);
   for (j = 0; j < current_dataset->multifeaturecount; j++)
     if (j != current_dataset->classdefno)
       result[i] += (temp->values[j].floatvalue - m_i->values[j].floatvalue) * (temp->values[j].floatvalue - m_i->values[j].floatvalue);
   temp = temp->next;
  }
 for (i = 0; i < current_dataset->classno; i++)
   if (counts[i] > 1)
     result[i] /= (counts[i] - 1);
   else
     result[i] = 0.0;
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0xc0c1a(%rip), %r13     # 0xd2870
movq (%r13), %rax
movslq 0x10(%rax), %rdi
leaq 0x91785(%rip), %rdx     # 0xa33ea
movl $0x8, %esi
movl $0x3, %ecx
callq 0x39210
movq %rax, %r14
testq %r12, %r12
je 0x11ce2
movq %r12, %rdi
callq 0x2eaca
movl %eax, %ebp
movq %r15, %rdi
movl %eax, %esi
callq 0x30fe5
movq (%r13), %rdx
movslq 0x1c0(%rdx), %rcx
testq %rcx, %rcx
jle 0x11cdb
movl 0x1407128(%rdx), %edx
movslq %ebp, %rsi
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x11cd3
movq (%r12), %r8
movsd (%r8,%rdi,8), %xmm0
movq (%rax), %r8
subsd (%r8,%rdi,8), %xmm0
mulsd %xmm0, %xmm0
addsd (%r14,%rsi,8), %xmm0
movsd %xmm0, (%r14,%rsi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x11cab
movq 0x10(%r12), %r12
jmp 0x11c77
movq (%r13), %rax
movslq 0x10(%rax), %rax
testq %rax, %rax
jle 0x11d24
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
cmpl $0x2, %edx
jl 0x11d14
decl %edx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd (%r14,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r14,%rcx,8)
jmp 0x11d1c
movq $0x0, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x11cf1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/data.c
// Function: find_mean_2d
matrix find_mean_2d(Instanceptr myptr)
{
 /*!Last Changed 30.01.2005*/
 matrix result;
 Instanceptr tmp;
 int i, j, count, dim, matrixdim, x;
 dim = current_dataset->multifeaturecount - 1;
 matrixdim = multifeaturecount_2d(current_dataset);
 result = matrix_alloc(1, matrixdim);
 tmp = myptr;
 count = 0;
 while (tmp)
  {
   x = 0;
   for (i = 0; i < dim; i++)
     for (j = i; j < dim; j++)
      {
       result.values[0][x] += real_feature(tmp, i) * real_feature(tmp, j);
       x++;
      }
   for (i = 0; i < dim; i++)
    {
     result.values[0][x] += real_feature(tmp, i);
     x++;
    }
   count++;
   tmp = tmp->next;
  }
 for (i = 0; i < matrixdim; i++)
   result.values[0][i] /= count;
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r15
leaq 0xc0657(%rip), %rax     # 0xd2870
movq (%rax), %rdi
movl 0x1c0(%rdi), %r13d
callq 0x13726
movl %eax, %ebp
movl $0x1, %edi
movl %eax, %esi
callq 0x3c6e5
movq %rdx, %rbx
testq %r15, %r15
je 0x12362
movl %ebp, (%rsp)
movq %rax, 0x10(%rsp)
leal -0x1(%r13), %eax
movl %eax, 0x4(%rsp)
movl %eax, %ebp
xorl %eax, %eax
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rbx, 0x8(%rsp)
movq %r13, 0x20(%rsp)
movq %rbp, 0x18(%rsp)
cmpl $0x2, %r13d
movq %rax, 0x28(%rsp)
jl 0x122fe
xorl %r12d, %r12d
xorl %ebx, %ebx
movq %rbx, %r14
shlq $0x20, %r14
movslq %ebx, %rbx
movl %r12d, %r13d
movq 0x8(%rsp), %rbp
addq %rcx, %r14
movq %r15, %rdi
movl %r12d, %esi
callq 0x2e4b6
movsd %xmm0, 0x30(%rsp)
movq %r15, %rdi
movl %r13d, %esi
callq 0x2e4b6
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq (%rbp), %rax
mulsd 0x30(%rsp), %xmm0
addsd (%rax,%rbx,8), %xmm0
movsd %xmm0, (%rax,%rbx,8)
movl 0x4(%rsp), %eax
incq %rbx
incl %r13d
cmpl %eax, %r13d
jl 0x12295
incl %r12d
cmpl %eax, %r12d
jne 0x12283
sarq $0x20, %r14
movq 0x8(%rsp), %rbx
movq 0x20(%rsp), %r13
movq 0x18(%rsp), %rbp
jmp 0x12301
xorl %r14d, %r14d
cmpl $0x2, %r13d
jl 0x12333
shlq $0x3, %r14
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x2e4b6
movq (%rbx), %rax
addq %r14, %rax
addsd (%rax,%r12,8), %xmm0
movsd %xmm0, (%rax,%r12,8)
incq %r12
cmpl %r12d, %ebp
jne 0x1230e
movq 0x28(%rsp), %rax
incl %eax
movq 0x10(%r15), %r15
testq %r15, %r15
movabsq $0x100000000, %rcx      # imm = 0x100000000
jne 0x1226f
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq 0x10(%rsp), %rax
movl (%rsp), %ebp
jmp 0x12366
xorpd %xmm0, %xmm0
testl %ebp, %ebp
jle 0x12387
movq (%rbx), %rsi
movl %ebp, %ecx
xorl %edx, %edx
movsd (%rsi,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x12371
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/data.c
// Function: between_class_matrix
matrix between_class_matrix(Instanceptr myptr)
{
 int i, j, k;
 Instanceptr temp = myptr;
 int *c_counts;
 Instanceptr c_means;
 Instance mean;
 matrix result = matrix_alloc(current_dataset->multifeaturecount - 1, current_dataset->multifeaturecount - 1);
 c_counts = find_class_counts(temp);
 c_means = find_class_means(temp, c_counts);
 mean = find_mean(temp);
 for (i = 0; i < current_dataset->classno; i++)
   for (j = 0; j < current_dataset->multifeaturecount - 1; j++)
     for (k = 0; k < current_dataset->multifeaturecount - 1; k++)
       result.values[j][k] += c_counts[i] * ((real_feature(data_x(c_means, i), j) - real_feature(&mean, j))) * ((real_feature(data_x(c_means, i), k) - real_feature(&mean, k)));
 safe_free(mean.values);
 safe_free(c_counts);
 deallocate(c_means);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0xbfd81(%rip), %r14     # 0xd2870
movq (%r14), %rax
movl 0x1c0(%rax), %edi
decl %edi
movl %edi, %esi
callq 0x3c6e5
movq %rax, 0x28(%rsp)
movq %rdx, 0x18(%rsp)
movq %rbx, %rdi
callq 0x115e1
movq %rax, %rbp
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11918
movq %rax, %r15
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x12519
movq (%r14), %rax
cmpl $0x0, 0x10(%rax)
jle 0x12c67
movq %r14, %rcx
xorl %edx, %edx
movq %rbp, 0x30(%rsp)
movq 0x18(%rsp), %r12
movq %rdx, 0x20(%rsp)
movq (%rcx), %rax
cmpl $0x2, 0x1c0(%rax)
jl 0x12c4f
xorl %r13d, %r13d
movq (%rcx), %rax
cmpl $0x2, 0x1c0(%rax)
movq 0x20(%rsp), %rbx
jl 0x12c36
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtsi2sdl (%rbp,%rbx,4), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movl %ebx, %esi
movq %rcx, %rbp
callq 0x30fe5
movq %rax, %rdi
movl %r13d, %esi
callq 0x2e4b6
movsd %xmm0, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
movl %r13d, %esi
callq 0x2e4b6
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movq %r15, %rdi
movl %ebx, %esi
callq 0x30fe5
movq %rax, %rdi
movl %r14d, %esi
callq 0x2e4b6
movsd %xmm0, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
movl %r14d, %esi
callq 0x2e4b6
movq %rbp, %rcx
movq 0x30(%rsp), %rbp
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x10(%rsp), %xmm1
movq (%r12,%r13,8), %rax
addsd (%rax,%r14,8), %xmm1
movsd %xmm1, (%rax,%r14,8)
incq %r14
movq (%rcx), %rax
movslq 0x1c0(%rax), %rax
decq %rax
cmpq %rax, %r14
jl 0x12b7d
incq %r13
movq (%rcx), %rax
movslq 0x1c0(%rax), %rax
decq %rax
cmpq %rax, %r13
jl 0x12b65
movq 0x20(%rsp), %rdx
incq %rdx
movq (%rcx), %rax
movslq 0x10(%rax), %rax
cmpq %rax, %rdx
jl 0x12b4d
movq 0x38(%rsp), %rdi
callq 0x39194
movq %rbp, %rdi
callq 0x39194
movq %r15, %rdi
callq 0x2f616
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/data.c
// Function: exception_performance
double exception_performance(Instanceptr list)
{
 /*!Last Changed 08.05.2004*/
 int excount = 0, error = 0;
 Instanceptr tmp = list;
 while (tmp)
  {
   if (tmp->isexception)
    {
     excount++;
     if (!(tmp->classified))
       error++;
    }
   tmp = tmp->next;
  }
 if (excount != 0)
   return (100 * (error + 0.0)) / excount;
 return 0;
}

// Assembly:
xorpd %xmm0, %xmm0
testq %rdi, %rdi
je 0x12ce2
xorl %ecx, %ecx
xorl %eax, %eax
cmpl $0x0, 0x20(%rdi)
je 0x12ccb
incl %eax
cmpl $0x1, 0x1c(%rdi)
adcl $0x0, %ecx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0x12cbc
cvtsi2sd %ecx, %xmm1
mulsd 0x900c0(%rip), %xmm1    # 0xa2da0
jmp 0x12ce8
xorl %eax, %eax
xorpd %xmm1, %xmm1
testl %eax, %eax
je 0x12cfb
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/dataset.c
// Function: export_subset_of_features
void export_subset_of_features(Datasetptr d, Instanceptr list, int featurecount, char* outfilename)
{
 /*!Last Changed 14.03.2007*/
 int bound, *selected, i;
 FILE* outfile;
 outfile = fopen(outfilename, "w");
 if (!outfile)
   return;
 selected = random_array(d->featurecount);
 /* If the class definition feature is in the selected feature list, increment bound so that exactly featurecount features will be selected*/
 if (selected[d->classdefno] < featurecount)
   bound = featurecount + 1;
 else
   bound = featurecount;
 for (i = 0; i < d->featurecount; i++)
   if (i != d->classdefno)
    {
     if (selected[i] < bound)
       d->features[i].selected = YES;
     else
       d->features[i].selected = NO;
    }
   else
     d->features[i].selected = YES;
 print_instance_list(outfile, d->separator, d, list);
 fclose(outfile);
 for (i = 0; i < d->featurecount; i++)
   d->features[i].selected = YES;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x95b79(%rip), %rsi     # 0xa88a1
movq %rcx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x12de5
movq %rax, %r15
movl 0x1bc(%rbx), %edi
callq 0x39fdc
movslq 0x1407128(%rbx), %rsi
xorl %ecx, %ecx
cmpl %ebp, (%rax,%rsi,4)
setl %dil
movslq 0x1bc(%rbx), %rdx
testq %rdx, %rdx
jle 0x12d9c
movl %esi, %esi
movb %dil, %cl
addl %ebp, %ecx
leaq 0x30f24(%rbx), %rdi
xorl %r8d, %r8d
movl $0x1, %r9d
cmpq %r8, %rsi
je 0x12d8a
xorl %r9d, %r9d
cmpl %ecx, (%rax,%r8,4)
setl %r9b
movl %r9d, (%rdi)
incq %r8
addq $0x340, %rdi            # imm = 0x340
cmpq %r8, %rdx
jne 0x12d74
movsbl 0x1a8(%rbx), %esi
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2fbad
movq %r15, %rdi
callq 0x42a0
movslq 0x1bc(%rbx), %rax
testq %rax, %rax
jle 0x12de5
imulq $0x340, %rax, %rax      # imm = 0x340
xorl %ecx, %ecx
movl $0x1, 0x30f24(%rbx,%rcx)
addq $0x340, %rcx            # imm = 0x340
cmpq %rcx, %rax
jne 0x12dce
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/dataset.c
// Function: subsample_regression
void subsample_regression(Datasetptr d, char* outputfile, Instanceptr list, int datacount)
{
 FILE* outfile;
 int i, *array;
 Instanceptr tmp;
 outfile = fopen(outputfile, "w");
 if (!outfile)
   return;
	array = random_array(data_size(list));
 for (i = 0; i < datacount; i++)
  {
   tmp = data_x(list, array[i]);
   print_instance(outfile, d->separator, d, tmp);
  }
 fclose(outfile);
 safe_free(array);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0x95850(%rip), %rsi     # 0xa88a1
movq %rax, %rdi
callq 0x40f0
testq %rax, %rax
je 0x130c4
movq %rax, %r15
movq %rbx, %rdi
callq 0x2fa14
movl %eax, %edi
callq 0x39fdc
movq %rax, %r12
testl %ebp, %ebp
jle 0x130a6
movl %ebp, %r13d
xorl %ebp, %ebp
movl (%r12,%rbp,4), %esi
movq %rbx, %rdi
callq 0x30fe5
movsbl 0x1a8(%r14), %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x2eb08
incq %rbp
cmpq %rbp, %r13
jne 0x1307c
movq %r15, %rdi
callq 0x42a0
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/dataset.c
// Function: deallocate_datasets
void deallocate_datasets()
{
 /*!Last Changed 29.11.2004*/
 Datasetptr tmp, tmp1;
 tmp = Datasets;
 while (tmp)
  {   
   tmp1 = tmp->next;
   free_dataset(tmp);
   tmp = tmp1;
  }
}

// Assembly:
pushq %rbx
leaq 0xbf131(%rip), %rax     # 0xd2878
movq (%rax), %rdi
testq %rdi, %rdi
je 0x13763
movq 0x1407270(%rdi), %rbx
callq 0x13765
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x1374f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/dataset.c
// Function: generate_data_with_noisy_classes_from_a_data_sample
void generate_data_with_noisy_classes_from_a_data_sample(Datasetptr d, char* inputfile, char *outputfile)
{
 /*!Last Changed 20.03.2009*/
 Instanceptr whereto, inst;
 FILE* outfile;
 double noiselevel = get_parameter_f ("noiselevel"), probability;
 int classno;
 read_from_data_file(d, inputfile, &whereto);
 inst = whereto;
 while (inst)
  {
   probability = produce_random_value (0.0, 1.0);
   classno = give_classno(inst);
   if (probability < noiselevel)
     do{
       inst->values[d->classdefno].stringindex = myrand() % d->classno;
     }while (inst->values[d->classdefno].stringindex == classno);
   inst = inst->next;
  }
 outfile = fopen(outputfile, "w");
 print_instance_list(outfile, d->separator, d, whereto);
 deallocate(whereto);
 fclose(outfile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8fd19(%rip), %rdi     # 0xa35fd
callq 0x534b6
movsd %xmm0, 0x10(%rsp)
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5c147
movq (%r12), %r15
testq %r15, %r15
je 0x13967
xorpd %xmm0, %xmm0
movsd 0x8ec09(%rip), %xmm1    # 0xa2520
callq 0x39f62
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
callq 0x2eaca
movsd 0x10(%rsp), %xmm0
ucomisd 0x18(%rsp), %xmm0
jbe 0x13961
movl %eax, %ebp
xorl %eax, %eax
callq 0x39f18
cltd
idivl 0x10(%rbx)
movq (%r15), %rax
movslq 0x1407128(%rbx), %rcx
movl %edx, (%rax,%rcx,8)
movq (%r15), %rax
movslq 0x1407128(%rbx), %rcx
cmpl %ebp, (%rax,%rcx,8)
je 0x1393a
movq 0x10(%r15), %r15
jmp 0x13906
leaq 0x94f33(%rip), %rsi     # 0xa88a1
movq %r14, %rdi
callq 0x40f0
movq %rax, %r14
movsbl 0x1a8(%rbx), %esi
movq 0x8(%rsp), %rcx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x2fbad
movq 0x8(%rsp), %rdi
callq 0x2f616
movq %r14, %rdi
callq 0x42a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/dataset.c
// Function: generate_data_with_noisy_features_from_a_dataset
void generate_data_with_noisy_features_from_a_dataset(Datasetptr d, Instanceptr data, char* fname, double stdev, double percentage)
{
 /*!Last Changed 13.10.2004*/
 FILE* outfile;
 int i;
 Instanceptr tmp;
 double value;
 outfile = fopen(fname, "w");
 if (!outfile)
  {
   printf(m1248, fname);
   return;
  }
 tmp = data;
 while (tmp)
  {
   for (i = 0; i < d->featurecount; i++)
     switch (d->features[i].type)
      {
       case INTEGER:if (produce_random_value(0, 1) < percentage)
                     {
                      value = tmp->values[i].intvalue + produce_normal_value(0, stdev);
                      tmp->values[i].intvalue = (int) value;
                     }
                    break;
       case    REAL:if (produce_random_value(0, 1) < percentage)
                     {
                      value = tmp->values[i].floatvalue + produce_normal_value(0, stdev);
                      tmp->values[i].floatvalue = (double) value;
                     } 
                    break;
      }
   tmp = tmp->next;
  }
 print_instance_list(outfile, ' ', d, data);
 fclose(outfile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x94ec8(%rip), %rsi     # 0xa88a1
movq %rdx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x13b17
movq %rax, %r15
movq %rbx, 0x10(%rsp)
testq %rbx, %rbx
je 0x13aec
leaq 0x30f08(%r14), %r12
movq 0x10(%rsp), %r13
cmpl $0x0, 0x1bc(%r14)
jle 0x13adf
movq %r12, %rbp
xorl %ebx, %ebx
movl (%rbp), %eax
cmpl $0x2, %eax
je 0x13a7b
testl %eax, %eax
jne 0x13ac5
xorpd %xmm0, %xmm0
movsd 0x8eaea(%rip), %xmm1    # 0xa2520
callq 0x39f62
movsd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x13ac5
movq (%r13), %rax
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%rbx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x8cd13
addsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %eax
movq (%r13), %rcx
movl %eax, (%rcx,%rbx,8)
jmp 0x13ac5
xorpd %xmm0, %xmm0
movsd 0x8ea99(%rip), %xmm1    # 0xa2520
callq 0x39f62
movsd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x13ac5
movq (%r13), %rax
movsd (%rax,%rbx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x8cd13
addsd 0x8(%rsp), %xmm0
movq (%r13), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
movslq 0x1bc(%r14), %rax
addq $0x340, %rbp            # imm = 0x340
cmpq %rax, %rbx
jl 0x13a1a
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x13a07
movq %r15, %rdi
movl $0x20, %esi
movq %r14, %rdx
movq 0x10(%rsp), %rcx
callq 0x2fbad
movq %r15, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42a0
leaq 0x8fa84(%rip), %rdi     # 0xa35a2
movq %r12, %rsi
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4030