LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x30309
movl %eax, %ebp
movl %eax, %edi
movl %eax, %esi
callq 0x3d79d
movq %rax, 0x10(%rsp)
movq %rdx, %r15
testl %ebp, %ebp
jle 0x10b5e
movl %ebp, %ebp
xorl %r14d, %r14d
movq 0x8(%rsp), %r12
xorl %ebx, %ebx
movq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2fe29
movq (%r15,%r14,8), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
movq 0x10(%r13), %r13
cmpq %rbx, %rbp
jne 0x10b31
incq %r14
movq 0x10(%r12), %r12
cmpq %rbp, %r14
jne 0x10b2a
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_O3/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 0x30309
movl %eax, %ebp
movl %eax, %edi
movl %eax, %esi
callq 0x3d79d
movq %rax, 0x8(%rsp)
movq %rdx, %r15
testl %ebp, %ebp
jle 0x10c04
movl %ebp, %ebp
xorl %r14d, %r14d
movq (%rsp), %r12
xorl %ebx, %ebx
movq (%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2fe29
movsd 0x95765(%rip), %xmm2    # 0xa6330
movq (%r15,%r14,8), %rax
movapd %xmm0, %xmm1
cmpltsd 0x10(%rsp), %xmm1
andpd %xmm1, %xmm0
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
movlpd %xmm1, (%rax,%rbx,8)
incq %rbx
movq 0x10(%r13), %r13
cmpq %rbx, %rbp
jne 0x10bb8
incq %r14
movq 0x10(%r12), %r12
cmpq %rbp, %r14
jne 0x10bb2
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_O3/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, %r15
callq 0x30309
movl %eax, %ebx
movl %eax, %edi
movl %eax, %esi
callq 0x3d79d
movq %rdx, %r14
testl %ebx, %ebx
jle 0x10d3b
movq %rax, 0x10(%rsp)
movl %ebx, 0x8(%rsp)
movl %ebx, %r12d
xorl %ebp, %ebp
movq %r15, %r13
movq %r15, 0x18(%rsp)
movq %r15, %rdi
movq %r13, %rsi
movl 0xc(%rsp), %edx
callq 0x3188e
addsd 0x95160(%rip), %xmm0    # 0xa5dd8
movsd %xmm0, 0x20(%rsp)
xorl %ebx, %ebx
movq %r13, %rdi
movq %r15, %rsi
callq 0x2fe29
movq (%r14,%rbp,8), %rax
movapd %xmm0, %xmm1
cmpltsd 0x20(%rsp), %xmm1
andpd %xmm1, %xmm0
movsd 0x9568a(%rip), %xmm2    # 0xa6330
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
movlpd %xmm1, (%rax,%rbx,8)
incq %rbx
movq 0x10(%r15), %r15
cmpq %rbx, %r12
jne 0x10c80
incq %rbp
movq 0x10(%r13), %r13
cmpq %r12, %rbp
movq 0x18(%rsp), %r15
jne 0x10c61
cmpl $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
jle 0x10d3b
xorl %r11d, %r11d
movq %r12, %rcx
movq %r14, %rdx
xorl %esi, %esi
movq %rsi, %rdi
incq %rsi
cmpq %r12, %rsi
jae 0x10d2b
movq (%r14,%rdi,8), %r8
addq %r11, %r8
movl $0x1, %r9d
movsd (%r8,%r9,8), %xmm0
movq (%rdx,%r9,8), %r10
movsd (%r10,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x10d1d
movsd %xmm0, (%r10,%rdi,8)
jmp 0x10d23
movsd %xmm1, (%r8,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x10cff
addq $0x8, %rdx
addq $0x8, %r11
decq %rcx
cmpq %r12, %rsi
jne 0x10ce7
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_O3/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 0xc4b05(%rip), %rbp     # 0xd5870
movq (%rbp), %rax
movl 0x1c0(%rax), %edi
decl %edi
movl %edi, %esi
callq 0x3d79d
movq %rax, 0x10(%rsp)
movq %rdx, %r14
xorl %ebx, %ebx
testq %r12, %r12
je 0x10e6e
movl %r13d, 0xc(%rsp)
movq %r12, %rdi
callq 0x2f33a
cmpl %r13d, %eax
jne 0x10e60
movq %rbx, 0x18(%rsp)
movq (%rbp), %rax
movl 0x1c0(%rax), %eax
cmpl $0x2, %eax
jl 0x10e54
xorl %r13d, %r13d
cmpl $0x1, %eax
jle 0x10e42
xorl %ebx, %ebx
movq %r12, %rdi
movl %r13d, %esi
callq 0x2ed6a
movsd %xmm0, (%rsp)
movq %r15, %rdi
movl %r13d, %esi
callq 0x2ed6a
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x2ed6a
movsd %xmm0, 0x20(%rsp)
movq %r15, %rdi
movl %ebx, %esi
callq 0x2ed6a
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
leaq -0x1(%rax), %rcx
cmpq %rcx, %rbx
jl 0x10dc9
jmp 0x10e48
leal -0x1(%rax), %ecx
movslq %ecx, %rcx
incq %r13
cmpq %rcx, %r13
jl 0x10dc2
movq 0x18(%rsp), %rbx
incl %ebx
movl 0xc(%rsp), %r13d
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x10d96
movq (%rbp), %rax
movl 0x1c0(%rax), %eax
cmpl $0x2, %eax
jl 0x10eb8
decl %eax
leal -0x1(%rbx), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
xorl %ecx, %ecx
movq (%r14,%rcx,8), %rdx
xorl %esi, %esi
xorpd %xmm1, %xmm1
cmpl $0x2, %ebx
jl 0x10ea3
movsd (%rdx,%rsi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x10e91
incq %rcx
cmpq %rax, %rcx
jne 0x10e8b
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_O3/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:
testq %rsi, %rsi
je 0x10ef3
movslq %edx, %rax
imulq $0x340, %rax, %rdx      # imm = 0x340
cmpl $0x0, 0x30f08(%rdi,%rdx)
movq (%rsi), %r9
je 0x10efc
movsd (%r9,%rax,8), %xmm0
jmp 0x10f02
xorl %eax, %eax
movq %rax, (%rcx)
movq %rax, (%r8)
retq
cvtsi2sdl (%r9,%rax,8), %xmm0
movsd %xmm0, (%rcx)
movsd %xmm0, (%r8)
movl 0x30f08(%rdi,%rdx), %edx
movq (%rsi), %rdi
testl %edx, %edx
je 0x10f20
movsd (%rdi,%rax,8), %xmm0
jmp 0x10f28
xorps %xmm0, %xmm0
cvtsi2sdl (%rdi,%rax,8), %xmm0
ucomisd (%r8), %xmm0
movq %r8, %rdi
ja 0x10f3f
movsd (%rcx), %xmm1
ucomisd %xmm0, %xmm1
movq %rcx, %rdi
jbe 0x10f43
movsd %xmm0, (%rdi)
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
jne 0x10f12
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0x10fb5
movl %edx, %ebp
movq %rdi, %r15
movq (%rdi), %rax
movslq %esi, %r12
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, (%r14)
movsd %xmm0, (%rbx)
movq %r15, %rdi
callq 0x2f33a
cmpl %ebp, %eax
jne 0x10faa
movq (%r15), %rax
movsd (%rax,%r12,8), %xmm0
ucomisd (%rbx), %xmm0
movq %rbx, %rax
ja 0x10fa6
movsd (%r14), %xmm1
ucomisd %xmm0, %xmm1
movq %r14, %rax
jbe 0x10faa
movsd %xmm0, (%rax)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x10f7a
jmp 0x10fbd
xorl %eax, %eax
movq %rax, (%r14)
movq %rax, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x11036
movl %ecx, %ebx
movl %esi, %ebp
movq %rdi, %r15
movslq %edx, %r12
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x2f33a
cmpl %ebp, %eax
jne 0x1102b
movq (%r15), %rax
movsd (%rax,%r12,8), %xmm0
testl %ebx, %ebx
jne 0x11014
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x11014
incl %r14d
jmp 0x1102b
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 0x10fea
jmp 0x11039
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_O3/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 0x30309
movl %eax, 0x14(%rsp)
leaq 0xc44b7(%rip), %rbp     # 0xd5870
movq (%rbp), %rax
movl 0x1c0(%rax), %edi
decl %edi
movl %edi, %esi
callq 0x3d79d
movq %rax, 0x18(%rsp)
movq %rdx, %r14
movq (%rbp), %rax
testq %r15, %r15
je 0x114a2
leaq 0x60(%rsp), %r12
movl 0x1c0(%rax), %ecx
cmpl $0x2, %ecx
jl 0x11495
xorl %r13d, %r13d
cmpl $0x1, %ecx
jle 0x1147c
xorl %ebx, %ebx
movq %r15, %rdi
movl %r13d, %esi
callq 0x2ed6a
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movl %r13d, %esi
callq 0x2ed6a
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
movl %ebx, %esi
callq 0x2ed6a
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
movl %ebx, %esi
callq 0x2ed6a
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), %rcx
leaq -0x1(%rcx), %rdx
cmpq %rdx, %rbx
jl 0x113ff
jmp 0x11489
movslq 0x1c0(%rax), %rcx
movq %rcx, %rdx
decq %rdx
incq %r13
cmpq %rdx, %r13
jl 0x113f8
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x113e6
movl 0x1c0(%rax), %eax
cmpl $0x2, %eax
jl 0x114e2
decl %eax
movl 0x14(%rsp), %ecx
decl %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
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 0x114c4
incq %rcx
cmpq %rax, %rcx
jne 0x114be
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_O3/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 0x11525
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2f33a
xorl %ecx, %ecx
cmpl %ebx, %eax
sete %cl
addl %ecx, %ebp
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x11509
jmp 0x11527
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1155a
movl %esi, %ebp
movq %rdi, %r14
movq %r14, %rdi
callq 0x2f33a
cmpl %ebp, %eax
je 0x11555
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x1153e
jmp 0x1155a
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x115a6
leaq 0xc4302(%rip), %rcx     # 0xd5870
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
testq %rcx, %rcx
jle 0x11594
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 0x11580
jmp 0x11598
xorl %edx, %edx
xorl %ebx, %ebx
subl %edx, %ebx
movq %rax, %rdi
callq 0x3a180
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc42bc(%rip), %rax     # 0xd5870
movq (%rax), %rax
movslq 0x10(%rax), %rdi
leaq 0x94dfe(%rip), %rdx     # 0xa63c0
movl $0x4, %esi
movl $0x4, %ecx
callq 0x3a1fc
movq %rax, %r14
testq %rbx, %rbx
je 0x115ed
movq %rbx, %rdi
callq 0x2f33a
cltq
incl (%r14,%rax,4)
movq 0x10(%rbx), %rbx
jmp 0x115d4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x115a6
leaq 0xc4261(%rip), %rcx     # 0xd5870
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
xorl %ebp, %ebp
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rcx, %rcx
jle 0x11646
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 0x1162b
jmp 0x1164c
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rax, %rdi
callq 0x3a180
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_O3/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 0x30309
movslq %eax, %rdi
shlq $0x2, %rdi
leaq 0x94d20(%rip), %rsi     # 0xa63b3
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r14
testq %rbx, %rbx
je 0x116c0
movq %r14, %r15
movq %rbx, %rdi
callq 0x2f33a
movl %eax, (%r15)
movq 0x10(%rbx), %rbx
addq $0x4, %r15
testq %rbx, %rbx
jne 0x116a8
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x15391
movq %rax, %r14
cmpl $0x2, %ebx
jl 0x116f8
decl %ebx
movq %r14, %r15
movl %ebp, %edi
callq 0x15391
movq %rax, 0x10(%r15)
movq %rax, %r15
decl %ebx
jne 0x116e6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc4158(%rip), %r15     # 0xd5870
movq (%r15), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x94ca8(%rip), %rsi     # 0xa63d2
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %rbx
movq (%r15), %rax
cmpl $0x0, 0x10(%rax)
jle 0x117c6
xorl %r12d, %r12d
leaq 0x94c84(%rip), %r14     # 0xa63d2
movslq 0x1bc(%rax), %rdi
shlq $0x3, %rdi
movq %r14, %rsi
movl $0x6, %edx
callq 0x3a0e1
movq %rax, (%rbx,%r12,8)
movq (%r15), %rax
cmpl $0x0, 0x1bc(%rax)
jle 0x117ba
movl $0x61e4, %r13d          # imm = 0x61E4
xorl %ebp, %ebp
cmpl $0x1, -0x18(%rax,%r13,8)
jne 0x117a7
movslq (%rax,%r13,8), %rdi
movl $0x4, %esi
movq %r14, %rdx
movl $0x9, %ecx
callq 0x3a1fc
movq (%rbx,%r12,8), %rcx
movq %rax, (%rcx,%rbp,8)
movq (%r15), %rax
incq %rbp
movslq 0x1bc(%rax), %rcx
addq $0x68, %r13
cmpq %rcx, %rbp
jl 0x1177e
incq %r12
movslq 0x10(%rax), %rcx
cmpq %rcx, %r12
jl 0x1174e
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_O3/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 0xc4085(%rip), %r14     # 0xd5870
movq (%r14), %rax
cmpl $0x0, 0x10(%rax)
jle 0x1184b
xorl %r15d, %r15d
cmpl $0x0, 0x1bc(%rax)
jle 0x11833
movl $0x61e1, %r12d          # imm = 0x61E1
xorl %r13d, %r13d
cmpl $0x1, (%rax,%r12,8)
jne 0x11820
movq (%rbx,%r15,8), %rax
movq (%rax,%r13,8), %rdi
callq 0x3a180
movq (%r14), %rax
incq %r13
movslq 0x1bc(%rax), %rcx
addq $0x68, %r12
cmpq %rcx, %r13
jl 0x11809
movq (%rbx,%r15,8), %rdi
callq 0x3a180
incq %r15
movq (%r14), %rax
movslq 0x10(%rax), %rcx
cmpq %rcx, %r15
jl 0x117f7
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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 0x11706
movq %rax, %r14
testq %rbx, %rbx
je 0x118d1
leaq 0xc3ff8(%rip), %r15     # 0xd5870
movq %rbx, %rdi
callq 0x2f33a
movq (%r15), %rcx
movl 0x1bc(%rcx), %esi
testl %esi, %esi
jle 0x118c8
leaq 0x30f08(%rcx), %rdx
cltq
xorl %edi, %edi
cmpl $0x1, (%rdx)
jne 0x118b6
movq (%r14,%rax,8), %rsi
movq (%rsi,%rdi,8), %rsi
movq (%rbx), %r8
movslq (%r8,%rdi,8), %r8
incl (%rsi,%r8,4)
movl 0x1bc(%rcx), %esi
incq %rdi
movslq %esi, %r8
addq $0x340, %rdx            # imm = 0x340
cmpq %r8, %rdi
jl 0x11898
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x11878
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc3c58(%rip), %r13     # 0xd5870
movq (%r13), %rax
movslq 0x10(%rax), %rdi
leaq 0x947c3(%rip), %rdx     # 0xa63ea
movl $0x8, %esi
movl $0x3, %ecx
callq 0x3a1fc
movq %rax, %r14
testq %r12, %r12
je 0x11caa
movq %r12, %rdi
callq 0x2f33a
movl %eax, %ebp
movq %r15, %rdi
movl %eax, %esi
callq 0x31851
movq (%r13), %rcx
movslq 0x1c0(%rcx), %rdx
testq %rdx, %rdx
jle 0x11c9e
movl 0x1407128(%rcx), %esi
movslq %ebp, %rdi
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x11c96
movq (%r12), %r9
movsd (%r9,%r8,8), %xmm0
movq (%rax), %r9
subsd (%r9,%r8,8), %xmm0
mulsd %xmm0, %xmm0
addsd (%r14,%rdi,8), %xmm0
movsd %xmm0, (%r14,%rdi,8)
incq %r8
cmpq %r8, %rdx
jne 0x11c6e
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x11c3e
jmp 0x11cae
movq (%r13), %rcx
movslq 0x10(%rcx), %rax
testq %rax, %rax
jle 0x11cec
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
cmpl $0x2, %edx
jl 0x11cdc
decl %edx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd (%r14,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r14,%rcx,8)
jmp 0x11ce4
movq $0x0, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x11cb9
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_O3/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 0xc36b1(%rip), %rax     # 0xd5870
movq (%rax), %rdi
movl 0x1c0(%rdi), %r13d
callq 0x1372c
movl %eax, %ebx
movl $0x1, %edi
movl %eax, %esi
callq 0x3d79d
movq %rdx, %r14
testq %r15, %r15
je 0x122c4
movl %ebx, 0xc(%rsp)
movq %rax, 0x10(%rsp)
leal -0x1(%r13), %ebp
movl %ebp, %eax
xorl %ecx, %ecx
movq %r13, 0x18(%rsp)
movq %rax, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
cmpl $0x2, %r13d
jl 0x1229e
xorl %r12d, %r12d
xorl %ebx, %ebx
movslq %ebx, %rbx
movl %r12d, %r13d
movq %r15, %rdi
movl %r12d, %esi
callq 0x2ed6a
movsd %xmm0, 0x30(%rsp)
movq %r15, %rdi
movl %r13d, %esi
callq 0x2ed6a
movq (%r14), %rax
mulsd 0x30(%rsp), %xmm0
addsd (%rax,%rbx,8), %xmm0
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
incl %r13d
cmpl %ebp, %r13d
jl 0x1221d
incl %r12d
cmpl %ebp, %r12d
jne 0x12217
movq 0x18(%rsp), %r13
cmpl $0x2, %r13d
jl 0x1229e
movslq %ebx, %rbx
shlq $0x3, %rbx
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x2ed6a
movq (%r14), %rax
addq %rbx, %rax
addsd (%rax,%r12,8), %xmm0
movsd %xmm0, (%rax,%r12,8)
movq 0x28(%rsp), %rax
incq %r12
cmpl %r12d, %eax
jne 0x12274
movq 0x20(%rsp), %rcx
incl %ecx
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x12203
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ebx
jmp 0x122c8
xorpd %xmm0, %xmm0
testl %ebx, %ebx
jle 0x122e9
movq (%r14), %rsi
movl %ebx, %ecx
xorl %edx, %edx
movsd (%rsi,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x122d3
movq %r14, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc2e41(%rip), %r15     # 0xd5870
movq (%r15), %rax
movl 0x1c0(%rax), %edi
decl %edi
movl %edi, %esi
callq 0x3d79d
movq %rax, 0x28(%rsp)
movq %rdx, %r14
movq %rbx, %rdi
callq 0x115a6
movq %rax, %rbp
movq %rbx, %rdi
movq %rax, %rsi
callq 0x118da
movq %rax, %r12
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x1247b
movq (%r15), %rax
cmpl $0x0, 0x10(%rax)
jle 0x12ba4
movq %r15, %rsi
xorl %edx, %edx
movq %r14, 0x20(%rsp)
movq %rbp, 0x30(%rsp)
movq %rdx, 0x18(%rsp)
movl 0x1c0(%rax), %ecx
cmpl $0x2, %ecx
jl 0x12b8f
xorl %r15d, %r15d
cmpl $0x1, %ecx
jle 0x12b7d
xorl %r14d, %r14d
movq 0x18(%rsp), %r13
xorps %xmm0, %xmm0
cvtsi2sdl (%rbp,%r13,4), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movq %rsi, %rbp
movl %r13d, %esi
callq 0x31851
movq %rax, %rdi
movl %r15d, %esi
callq 0x2ed6a
movsd %xmm0, 0x10(%rsp)
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2ed6a
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movq %r12, %rdi
movl %r13d, %esi
callq 0x31851
movq %rax, %rdi
movl %r14d, %esi
callq 0x2ed6a
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2ed6a
movq %rbp, %rsi
movq 0x30(%rsp), %rbp
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x10(%rsp), %xmm1
movq 0x20(%rsp), %rax
movq (%rax,%r15,8), %rax
addsd (%rax,%r14,8), %xmm1
movsd %xmm1, (%rax,%r14,8)
incq %r14
movq (%rsi), %rax
movslq 0x1c0(%rax), %rcx
leaq -0x1(%rcx), %rdx
cmpq %rdx, %r14
jl 0x12ab3
movq 0x20(%rsp), %r14
jmp 0x12b83
leal -0x1(%rcx), %edx
movslq %edx, %rdx
incq %r15
cmpq %rdx, %r15
jl 0x12aa2
movq 0x18(%rsp), %rdx
incq %rdx
movslq 0x10(%rax), %rcx
cmpq %rcx, %rdx
jl 0x12a8b
movq 0x38(%rsp), %rdi
callq 0x3a180
movq %rbp, %rdi
callq 0x3a180
movq %r12, %rdi
callq 0x2ff55
movq 0x28(%rsp), %rax
movq %r14, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x12c24
xorl %eax, %eax
xorl %ecx, %ecx
cmpl $0x0, 0x20(%rdi)
je 0x12c02
incl %ecx
cmpl $0x1, 0x1c(%rdi)
adcl $0x0, %eax
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0x12bf3
testl %ecx, %ecx
je 0x12c24
cvtsi2sd %eax, %xmm0
mulsd 0x93185(%rip), %xmm0    # 0xa5da0
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x988ec(%rip), %rsi     # 0xab96d
movq %rax, %rdi
callq 0x40f0
testq %rax, %rax
je 0x130f4
movq %rax, %r15
movq %rbx, %rdi
callq 0x30309
movl %eax, %edi
callq 0x3afe4
movq %rax, %r12
testl %ebp, %ebp
jle 0x130d6
movl %ebp, %r13d
xorl %ebp, %ebp
movl (%r12,%rbp,4), %esi
movq %rbx, %rdi
callq 0x31851
movsbl 0x1a8(%r14), %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x2f378
incq %rbp
cmpq %rbp, %r13
jne 0x130ac
movq %r15, %rdi
callq 0x42a0
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc212b(%rip), %rax     # 0xd5878
movq (%rax), %rdi
testq %rdi, %rdi
je 0x13769
movq 0x1407270(%rdi), %rbx
callq 0x1376b
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x13755
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x92d54(%rip), %rdi     # 0xa6641
callq 0x549ba
movsd %xmm0, 0x10(%rsp)
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5d65b
movq (%r12), %r15
testq %r15, %r15
je 0x13970
xorpd %xmm0, %xmm0
movsd 0x91c00(%rip), %xmm1    # 0xa5520
callq 0x3af6a
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
callq 0x2f33a
movsd 0x10(%rsp), %xmm0
ucomisd 0x18(%rsp), %xmm0
jbe 0x1396a
movl %eax, %ebp
xorl %eax, %eax
callq 0x3af20
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 0x13943
movq 0x10(%r15), %r15
jmp 0x1390f
leaq 0x97ff6(%rip), %rsi     # 0xab96d
movq %r14, %rdi
callq 0x40f0
movq %rax, %r14
movsbl 0x1a8(%rbx), %esi
movq 0x8(%rsp), %rcx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x304a2
movq 0x8(%rsp), %rdi
callq 0x2ff55
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_O3/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 0x97f8b(%rip), %rsi     # 0xab96d
movq %rdx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x13b21
movq %rax, %r15
movq %rbx, 0x10(%rsp)
testq %rbx, %rbx
je 0x13af6
leaq 0x30f08(%r14), %r12
movl 0x1bc(%r14), %eax
movq 0x10(%rsp), %r13
testl %eax, %eax
jle 0x13ae9
movq %r12, %rbp
xorl %ebx, %ebx
movl (%rbp), %eax
cmpl $0x2, %eax
je 0x13a85
testl %eax, %eax
jne 0x13acf
xorpd %xmm0, %xmm0
movsd 0x91ae0(%rip), %xmm1    # 0xa5520
callq 0x3af6a
movsd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x13acf
movq (%r13), %rax
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%rbx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x8f4b0
addsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %eax
movq (%r13), %rcx
movl %eax, (%rcx,%rbx,8)
jmp 0x13acf
xorpd %xmm0, %xmm0
movsd 0x91a8f(%rip), %xmm1    # 0xa5520
callq 0x3af6a
movsd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x13acf
movq (%r13), %rax
movsd (%rax,%rbx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x8f4b0
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 0x13a24
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x13a17
movq %r15, %rdi
movl $0x20, %esi
movq %r14, %rdx
movq 0x10(%rsp), %rcx
callq 0x304a2
movq %r15, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42a0
leaq 0x92abe(%rip), %rdi     # 0xa65e6
movq %r12, %rsi
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4030
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: k_way_anova_dataset
int k_way_anova_dataset(Datasetptr d, Instanceptr data, char** featurenos, int fcount)
{
 /*!Last Changed 07.05.2004*/
 int* features, i, fdependent, fno;
 fdependent = atoi(featurenos[1]) - 1;
 features = (int *) safemalloc((fcount - 2) * sizeof(int), "k_way_anova_dataset", 3);
 for (i = 2; i < fcount; i++)
  {
   fno = atoi(featurenos[i]) - 1;
   features[i - 2] = fno;
   if (in_list(d->features[fno].type, 3, REAL, INTEGER, REGDEF))
     return 0;
  }
 switch (d->features[fdependent].type)
  {
   case   REGDEF:
   case     REAL:
   case  INTEGER:k_way_anova_dataset_cont(d, data, features, fdependent);
                 break;
   case   STRING:
   case CLASSDEF:k_way_anova_dataset_discrete(d, data, features, fdependent);
                 break;
  }
 safe_free(features);
 return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movq %rdx, %r12
movq %rsi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x8(%rdx), %rdi
callq 0x4200
movl %eax, %ebp
movslq %r13d, %rbx
leaq -0x8(,%rbx,4), %rdi
leaq 0x91a53(%rip), %rsi     # 0xa6864
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %r15
cmpl $0x3, %ebx
jl 0x14e7a
movq 0x10(%rsp), %rax
leaq 0x30f08(%rax), %rbx
movl %r13d, %r14d
addq $-0x2, %r14
xorl %r13d, %r13d
movq 0x10(%r12,%r13,8), %rdi
callq 0x4200
decl %eax
movl %eax, (%r15,%r13,4)
cltq
imulq $0x340, %rax, %rax      # imm = 0x340
movl (%rbx,%rax), %edi
movl $0x3, %esi
movl $0x2, %edx
xorl %ecx, %ecx
movl $0x4, %r8d
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
jne 0x14eb2
incq %r13
cmpq %r13, %r14
jne 0x14e39
decl %ebp
movslq %ebp, %rax
imulq $0x340, %rax, %rax      # imm = 0x340
movq 0x10(%rsp), %rdi
movl 0x30f08(%rdi,%rax), %eax
cmpl $0x4, %eax
ja 0x14ec5
movl $0x15, %ecx
btl %eax, %ecx
jae 0x14eb6
movq 0x8(%rsp), %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x13b40
jmp 0x14ec5
xorl %eax, %eax
jmp 0x14ed2
movq 0x8(%rsp), %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x14157
movq %r15, %rdi
callq 0x3a180
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: class_entropy
double class_entropy(char* datasetname)
{
 /*!Last Changed 25.03.2004*/
 Datasetptr tmp;
 int i;
 double result = 0, p;
 tmp = search_dataset(Datasets, datasetname);
 if (!tmp)
   return -1;
 for (i = 0; i < tmp->classno; i++)
   if (tmp->classcounts[i] != 0)
    {
     p = tmp->classcounts[i] / ((double)(tmp->datacount));
     result += tmp->classcounts[i] * (-p * log2(p));
    }
 result /= tmp->datacount;
 return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0xc0989(%rip), %rax     # 0xd5878
movq (%rax), %r14
movsd 0x90eae(%rip), %xmm1    # 0xa5da8
testq %r14, %r14
je 0x14fab
movq %rdi, %rbx
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x4260
testl %eax, %eax
je 0x14f2c
movq 0x1407270(%r14), %r14
testq %r14, %r14
jne 0x14f06
movsd 0x90e7e(%rip), %xmm1    # 0xa5da8
jmp 0x14fab
movl 0x10(%r14), %eax
xorpd %xmm1, %xmm1
testl %eax, %eax
jle 0x14f9b
xorl %ebx, %ebx
movl 0x1407140(%r14,%rbx,4), %ecx
testl %ecx, %ecx
je 0x14f90
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
movsd %xmm2, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl 0x1407120(%r14), %xmm0
divsd %xmm0, %xmm2
movsd %xmm2, (%rsp)
movapd %xmm2, %xmm0
movsd %xmm1, 0x10(%rsp)
callq 0x39bdc
movsd 0x10(%rsp), %xmm1
mulsd (%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
subsd %xmm0, %xmm1
movl 0x10(%r14), %eax
incq %rbx
movslq %eax, %rcx
cmpq %rcx, %rbx
jl 0x14f3a
xorps %xmm0, %xmm0
cvtsi2sdl 0x1407120(%r14), %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: search_dataset
Datasetptr search_dataset(Datasetptr header, char *dataset_name)
{
 Datasetptr dataset = header;
 while (dataset)
  {
   if (!strcmp(dataset->name, dataset_name))
     return dataset;
   dataset = dataset->next;
  }
 return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x14fe2
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x4260
testl %eax, %eax
je 0x14fe4
movq 0x1407270(%rbx), %rbx
testq %rbx, %rbx
jne 0x14fc6
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: average_valuecount
double average_valuecount(Datasetptr d)
{
 /*!Last Changed 01.10.2006*/
 double sum = 0;
 int i, count = 0;
 for (i = 0; i < d->featurecount; i++)
   switch (d->features[i].type)
    {
     case REAL   :
     case INTEGER:sum += 1;
                  count++;
                  break;
     case STRING :sum += d->features[i].valuecount - 1;
                  count++;
                  break;
    }
 return sum/count;
}

// Assembly:
movslq 0x1bc(%rdi), %rax
testq %rax, %rax
jle 0x1505b
imulq $0x340, %rax, %rax      # imm = 0x340
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd 0x90510(%rip), %xmm1    # 0xa5520
xorl %edx, %edx
movl 0x30f08(%rdi,%rcx), %esi
cmpl $0x2, %esi
je 0x15027
cmpl $0x1, %esi
je 0x1502d
testl %esi, %esi
jne 0x15043
addsd %xmm1, %xmm0
jmp 0x15041
movl 0x30f20(%rdi,%rcx), %esi
decl %esi
xorps %xmm2, %xmm2
cvtsi2sd %esi, %xmm2
addsd %xmm2, %xmm0
incl %edx
addq $0x340, %rcx            # imm = 0x340
cmpq %rcx, %rax
jne 0x15012
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
retq
movsd 0x90cad(%rip), %xmm0    # 0xa5d10
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: symbolic_features
int* symbolic_features(Datasetptr d, int* count)
{
 /*!Last Changed 12.06.2006*/
 int *result = NULL, i;
 *count = 0;
 for (i = 0; i < d->featurecount; i++)
   if (d->features[i].type == STRING)
    {
     (*count)++;
     result = alloc(result, (*count) * sizeof(int), *count);
     result[(*count) - 1] = i;
    }
 return result;
}

// Assembly:
movl $0x0, (%rsi)
movl 0x1bc(%rdi), %ecx
testl %ecx, %ecx
jle 0x150da
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30f08(%rdi), %r15
xorl %r12d, %r12d
xorl %eax, %eax
cmpl $0x1, (%r15)
jne 0x150bc
movslq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, (%rbx)
leaq 0x4(,%rcx,4), %rsi
movq %rax, %rdi
callq 0x3a0b4
movslq (%rbx), %rcx
movl %r12d, -0x4(%rax,%rcx,4)
movl 0x1bc(%r14), %ecx
incq %r12
movslq %ecx, %rdx
addq $0x340, %r15            # imm = 0x340
cmpq %rdx, %r12
jl 0x1508e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/dataset.c
// Function: number_of_symbolic_features
int number_of_symbolic_features(char* datasetname)
{
 /*!Last Changed 25.03.2004*/
 Datasetptr tmp;
 int i, count = 0;
 tmp = search_dataset(Datasets, datasetname);
 if (!tmp)
   return -1;
 for (i = 0; i < tmp->featurecount; i++)
   if (tmp->features[i].type == STRING)
     count++;
 return count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xc078f(%rip), %rax     # 0xd5878
movq (%rax), %r15
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r15, %r15
je 0x1514e
movq %rdi, %r14
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x4260
testl %eax, %eax
je 0x15117
movq 0x1407270(%r15), %r15
testq %r15, %r15
jne 0x150f9
jmp 0x1514e
movslq 0x1bc(%r15), %rax
testq %rax, %rax
jle 0x1514c
imulq $0x340, %rax, %rax      # imm = 0x340
xorl %ecx, %ecx
xorl %ebx, %ebx
xorl %edx, %edx
cmpl $0x1, 0x30f08(%r15,%rcx)
sete %dl
addl %edx, %ebx
addq $0x340, %rcx            # imm = 0x340
cmpq %rcx, %rax
jne 0x1512e
jmp 0x1514e
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq