LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xbce4e(%rip), %rbx     # 0xcd870
movq (%rbx), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x8599e(%rip), %rsi     # 0x963d2
pushq $0x3
popq %rdx
callq 0x34f59
movq %rax, %r14
movq %rbx, %r15
movq (%rbx), %rax
xorl %ebp, %ebp
pushq $0x9
popq %r12
movslq 0x10(%rax), %rcx
cmpq %rcx, %rbp
jge 0x10ac0
movslq 0x1bc(%rax), %rdi
shlq $0x3, %rdi
leaq 0x8596c(%rip), %rsi     # 0x963d2
pushq $0x6
popq %rdx
callq 0x34f59
movq %rax, (%r14,%rbp,8)
movq (%r15), %rax
movl $0x61e4, %r13d          # imm = 0x61E4
xorl %ebx, %ebx
movslq 0x1bc(%rax), %rcx
cmpq %rcx, %rbx
jge 0x10abb
cmpl $0x1, -0x18(%rax,%r13,8)
jne 0x10ab2
movslq (%rax,%r13,8), %rdi
pushq $0x4
popq %rsi
leaq 0x85933(%rip), %rdx     # 0x963d2
movl %r12d, %ecx
callq 0x35067
movq (%r14,%rbp,8), %rcx
movq %rax, (%rcx,%rbx,8)
movq (%r15), %rax
incq %rbx
addq $0x68, %r13
jmp 0x10a7d
incq %rbp
jmp 0x10a4b
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_O2/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
xorl %r14d, %r14d
leaq 0xbcd88(%rip), %r15     # 0xcd870
movq (%r15), %rax
movslq 0x10(%rax), %rcx
cmpq %rcx, %r14
jge 0x10b37
movl $0x61e1, %r12d          # imm = 0x61E1
xorl %r13d, %r13d
movslq 0x1bc(%rax), %rcx
cmpq %rcx, %r13
jge 0x10b29
cmpl $0x1, (%rax,%r12,8)
jne 0x10b20
movq (%rbx,%r14,8), %rax
movq (%rax,%r13,8), %rdi
callq 0x34ff7
movq (%r15), %rax
incq %r13
addq $0x68, %r12
jmp 0x10afd
movq (%rbx,%r14,8), %rdi
callq 0x34ff7
incq %r14
jmp 0x10ae8
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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 0x10a10
movq %rax, %r14
leaq 0xbcd11(%rip), %r15     # 0xcd870
testq %rbx, %rbx
je 0x10bb0
movq %rbx, %rdi
callq 0x2b47e
movq (%r15), %rcx
leaq 0x30f08(%rcx), %rdx
cltq
xorl %esi, %esi
movslq 0x1bc(%rcx), %rdi
cmpq %rdi, %rsi
jge 0x10baa
cmpl $0x1, (%rdx)
jne 0x10b9e
movq (%r14,%rax,8), %rdi
movq (%rdi,%rsi,8), %rdi
movq (%rbx), %r8
movslq (%r8,%rsi,8), %r8
incl (%rdi,%r8,4)
incq %rsi
addq $0x340, %rdx            # imm = 0x340
jmp 0x10b7a
movq 0x10(%rbx), %rbx
jmp 0x10b5f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbc9d8(%rip), %r13     # 0xcd870
movq (%r13), %rax
movslq 0x10(%rax), %rdi
leaq 0x85543(%rip), %rdx     # 0x963ea
pushq $0x8
popq %rsi
pushq $0x3
popq %rcx
callq 0x35067
movq %rax, %r14
testq %r12, %r12
je 0x10f1e
movq %r12, %rdi
callq 0x2b47e
movl %eax, %ebp
movq %r15, %rdi
movl %eax, %esi
callq 0x2d761
movq (%r13), %rcx
movslq 0x1c0(%rcx), %rdx
movslq %ebp, %rsi
xorl %edi, %edi
cmpq %rdx, %rdi
jge 0x10f17
movl 0x1407128(%rcx), %r8d
cmpq %r8, %rdi
je 0x10f12
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
jmp 0x10ede
movq 0x10(%r12), %r12
jmp 0x10eb5
movq (%r13), %rax
movl 0x10(%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x10f5b
movl (%rbx,%rcx,4), %edx
cmpl $0x2, %edx
jl 0x10f51
decl %edx
cvtsi2sd %edx, %xmm0
movsd (%r14,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r14,%rcx,8)
jmp 0x10f56
andq $0x0, (%r14,%rcx,8)
incq %rcx
jmp 0x10f2c
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_O2/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 $0x58, %rsp
movq %rdi, %r12
leaq 0xbc48d(%rip), %rax     # 0xcd870
movq (%rax), %rdi
movl 0x1c0(%rdi), %ebx
leal -0x1(%rbx), %ebp
callq 0x126ea
pushq $0x1
popq %rdi
movq %rax, 0x28(%rsp)
movl %eax, %esi
callq 0x380d3
movq %rax, 0x20(%rsp)
movq %rdx, %r15
xorl %eax, %eax
testl %ebp, %ebp
movl $0x0, %r14d
movl %ebp, 0xc(%rsp)
cmovgl %ebp, %r14d
addl $-0x2, %ebx
movq %rbx, 0x30(%rsp)
movq %r14, 0x40(%rsp)
testq %r12, %r12
je 0x11519
movq %rax, 0x38(%rsp)
xorl %edx, %edx
movl 0xc(%rsp), %ecx
movl %ecx, %esi
movq 0x30(%rsp), %rax
xorl %edi, %edi
xorl %ebp, %ebp
cmpl %r14d, %ebp
je 0x114d7
movl %eax, 0x14(%rsp)
movl %edx, 0x1c(%rsp)
movl %esi, 0x18(%rsp)
movslq %esi, %r14
movslq %edi, %rbx
movq %rcx, 0x48(%rsp)
leal (%rbx,%rcx), %eax
movl %eax, 0x10(%rsp)
movl %ebp, %r13d
cmpq %rbx, %r14
je 0x114ae
movq %r12, %rdi
movl %ebp, %esi
callq 0x2aea2
movsd %xmm0, 0x50(%rsp)
movq %r12, %rdi
movl %r13d, %esi
callq 0x2aea2
movq (%r15), %rax
mulsd 0x50(%rsp), %xmm0
addsd (%rax,%rbx,8), %xmm0
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
incl %r13d
jmp 0x11473
incl %ebp
movl 0x18(%rsp), %esi
movl 0x14(%rsp), %eax
addl %eax, %esi
decl %eax
movl 0x1c(%rsp), %edx
movq 0x48(%rsp), %rcx
addl %ecx, %edx
decl %ecx
movq 0x40(%rsp), %r14
movl 0x10(%rsp), %edi
jmp 0x11449
movslq %edx, %rbx
shlq $0x3, %rbx
xorl %r13d, %r13d
cmpl %r13d, %r14d
je 0x11508
movq %r12, %rdi
movl %r13d, %esi
callq 0x2aea2
movq (%r15), %rax
addq %rbx, %rax
addsd (%rax,%r13,8), %xmm0
movsd %xmm0, (%rax,%r13,8)
incq %r13
jmp 0x114e1
movq 0x38(%rsp), %rax
incl %eax
movq 0x10(%r12), %r12
jmp 0x1142a
cvtsi2sd %eax, %xmm0
xorl %eax, %eax
movq 0x28(%rsp), %rdx
testl %edx, %edx
cmovlel %eax, %edx
cmpq %rax, %rdx
je 0x11544
movq (%r15), %rcx
movsd (%rcx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rax,8)
incq %rax
jmp 0x11529
movq 0x20(%rsp), %rax
movq %r15, %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: 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 $0x58, %rsp
movq %rdi, %rbx
leaq 0xbbcce(%rip), %r14     # 0xcd870
movq (%r14), %rax
movl 0x1c0(%rax), %edi
decl %edi
movl %edi, %esi
callq 0x380d3
movq %rax, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rbx, %rdi
callq 0x108c8
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10bb9
movq %rax, %r12
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x116b6
movq (%r14), %rax
xorl %ebp, %ebp
movslq 0x10(%rax), %rcx
cmpq %rcx, %rbp
jge 0x11cd9
movl 0x1c0(%rax), %ecx
xorl %ebx, %ebx
decl %ecx
movslq %ecx, %rcx
cmpq %rcx, %rbx
jge 0x11cd1
xorl %r14d, %r14d
movslq 0x1c0(%rax), %rcx
leaq -0x1(%rcx), %rdx
cmpq %rdx, %r14
jge 0x11cc9
cvtsi2sdl (%r15,%rbp,4), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movl %ebp, %esi
callq 0x2d761
movq %rax, %rdi
movl %ebx, %esi
callq 0x2aea2
movsd %xmm0, 0x10(%rsp)
movq %r13, %rdi
movl %ebx, %esi
callq 0x2aea2
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movq %r12, %rdi
movl %ebp, %esi
callq 0x2d761
movq %rax, %rdi
movl %r14d, %esi
callq 0x2aea2
movsd %xmm0, 0x8(%rsp)
movq %r13, %rdi
movl %r14d, %esi
callq 0x2aea2
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x10(%rsp), %xmm1
movq 0x18(%rsp), %rax
movq (%rax,%rbx,8), %rax
addsd (%rax,%r14,8), %xmm1
movsd %xmm1, (%rax,%r14,8)
incq %r14
leaq 0xbbbaf(%rip), %rax     # 0xcd870
movq (%rax), %rax
jmp 0x11c12
incq %rbx
jmp 0x11c01
incq %rbp
jmp 0x11bec
movq 0x28(%rsp), %rdi
callq 0x34ff7
movq %r15, %rdi
callq 0x34ff7
movq %r12, %rdi
callq 0x2c010
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/data.c
// Function: 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:
xorl %eax, %eax
xorl %ecx, %ecx
testq %rdi, %rdi
je 0x11d3f
cmpl $0x0, 0x20(%rdi)
je 0x11d39
incl %eax
cmpl $0x1, 0x1c(%rdi)
adcl $0x0, %ecx
movq 0x10(%rdi), %rdi
jmp 0x11d25
xorpd %xmm0, %xmm0
testl %eax, %eax
je 0x11d5b
cvtsi2sd %ecx, %xmm0
mulsd 0x84055(%rip), %xmm0    # 0x95da8
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x89b09(%rip), %rsi     # 0x9b891
movq %rcx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x11e68
movq %rax, %r15
movl 0x1bc(%rbx), %edi
callq 0x35cf7
movl 0x1407128(%rbx), %r8d
movslq %r8d, %rdx
xorl %ecx, %ecx
cmpl %ebp, (%rax,%rdx,4)
setl %cl
addl %ebp, %ecx
movl 0x1bc(%rbx), %edi
xorl %edx, %edx
testl %edi, %edi
cmovlel %edx, %edi
imulq $0x340, %r8, %rsi       # imm = 0x340
addq %rbx, %rsi
addq $0x30f24, %rsi          # imm = 0x30F24
imulq $0xd0, %rdi, %rdi
imulq $0xd0, %r8, %r8
cmpq %rdx, %rdi
je 0x11e1f
cmpq %rdx, %r8
jne 0x11df9
movl $0x1, (%rsi)
jmp 0x11e12
cmpl %ecx, (%rax)
jge 0x11e0a
movl $0x1, 0x30f24(%rbx,%rdx,4)
jmp 0x11e12
andl $0x0, 0x30f24(%rbx,%rdx,4)
addq $0xd0, %rdx
addq $0x4, %rax
jmp 0x11de7
movsbl 0x1a8(%rbx), %esi
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2c563
movq %r15, %rdi
callq 0x42a0
movl 0x1bc(%rbx), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
imulq $0x340, %rcx, %rcx      # imm = 0x340
cmpq %rax, %rcx
je 0x11e68
movl $0x1, 0x30f24(%rbx,%rax)
addq $0x340, %rax            # imm = 0x340
jmp 0x11e50
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %r15
leaq 0x897db(%rip), %rsi     # 0x9b891
movq %rax, %rdi
callq 0x40f0
testq %rax, %rax
je 0x1212a
movq %rax, %r12
movq %r14, %rdi
callq 0x2c3cc
movl %eax, %edi
callq 0x35cf7
movq %rax, %r13
xorl %ebp, %ebp
testl %ebx, %ebx
cmovlel %ebp, %ebx
cmpq %rbp, %rbx
je 0x1210c
movl (%r13,%rbp,4), %esi
movq %r14, %rdi
callq 0x2d761
movsbl 0x1a8(%r15), %esi
movq %r12, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x2b4ba
incq %rbp
jmp 0x120df
movq %r12, %rdi
callq 0x42a0
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0xbb170(%rip), %rax     # 0xcd878
movq (%rax), %rdi
testq %rdi, %rdi
je 0x12721
movq 0x1407270(%rdi), %rbx
callq 0x12723
movq %rbx, %rdi
jmp 0x1270b
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movq %rdi, %rbx
leaq 0x83d4c(%rip), %rdi     # 0x965e1
callq 0x4cdcf
movsd %xmm0, 0x10(%rsp)
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x550f7
movq (%r15), %r15
testq %r15, %r15
je 0x12917
xorpd %xmm0, %xmm0
movsd 0x82c59(%rip), %xmm1    # 0x95520
callq 0x35cae
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
callq 0x2b47e
movsd 0x10(%rsp), %xmm0
ucomisd 0x18(%rsp), %xmm0
jbe 0x12911
movl %eax, %ebp
xorl %eax, %eax
callq 0x35c7f
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 0x128ea
addq $0x10, %r15
jmp 0x128b3
leaq 0x88f73(%rip), %rsi     # 0x9b891
movq %r14, %rdi
callq 0x40f0
movq %rax, %r14
movsbl 0x1a8(%rbx), %esi
movq 0x8(%rsp), %rcx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x2c563
movq 0x8(%rsp), %rdi
callq 0x2c010
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_O2/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, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x88f08(%rip), %rsi     # 0x9b891
movq %rdx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x12ab3
movq %rax, %r15
leaq 0x30f08(%r14), %r12
movq %rbx, 0x20(%rsp)
movq %rbx, %r13
testq %r13, %r13
je 0x12a8a
movq %r12, %rbp
xorl %ebx, %ebx
movslq 0x1bc(%r14), %rax
cmpq %rax, %rbx
jge 0x12a81
movl (%rbp), %eax
cmpl $0x2, %eax
je 0x12a28
testl %eax, %eax
jne 0x12a72
xorpd %xmm0, %xmm0
movsd 0x82b3a(%rip), %xmm1    # 0x95520
callq 0x35cae
movsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x12a72
movq (%r13), %rax
cvtsi2sdl (%rax,%rbx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x81937
addsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %eax
movq (%r13), %rcx
movl %eax, (%rcx,%rbx,8)
jmp 0x12a72
xorpd %xmm0, %xmm0
movsd 0x82aec(%rip), %xmm1    # 0x95520
callq 0x35cae
movsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x12a72
movq (%r13), %rax
movsd (%rax,%rbx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x81937
addsd 0x8(%rsp), %xmm0
movq (%r13), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
addq $0x340, %rbp            # imm = 0x340
jmp 0x129ba
movq 0x10(%r13), %r13
jmp 0x129ac
pushq $0x20
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
movq 0x20(%rsp), %rcx
callq 0x2c563
movq %r15, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42a0
leaq 0x83acc(%rip), %rdi     # 0x96586
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_O2/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, %ebx
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movq 0x8(%rdx), %rdi
callq 0x4200
decl %eax
movl %eax, 0x4(%rsp)
movslq %ebx, %r13
leaq -0x8(,%r13,4), %rdi
leaq 0x82bbb(%rip), %rsi     # 0x96804
pushq $0x3
popq %rdx
callq 0x34f59
movq %rax, %r15
movq %r14, 0x8(%rsp)
leaq 0x30f08(%r14), %rbx
pushq $0x2
popq %r14
xorl %ebp, %ebp
cmpq %r13, %r14
jge 0x13ca3
movq (%r12,%r14,8), %rdi
callq 0x4200
decl %eax
movl %eax, -0x8(%r15,%r14,4)
cltq
imulq $0x340, %rax, %rax      # imm = 0x340
movl (%rbx,%rax), %edi
pushq $0x3
popq %rsi
pushq $0x2
popq %rdx
xorl %ecx, %ecx
pushq $0x4
popq %r8
xorl %eax, %eax
callq 0x35812
incq %r14
testl %eax, %eax
je 0x13c66
jmp 0x13cf2
movl 0x4(%rsp), %ecx
movslq %ecx, %rax
imulq $0x340, %rax, %rax      # imm = 0x340
movl (%rbx,%rax), %eax
cmpl $0x4, %eax
ja 0x13ce7
pushq $0x15
popq %rdx
btl %eax, %edx
jae 0x13cd5
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x12ad2
jmp 0x13ce7
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x13088
movq %r15, %rdi
callq 0x34ff7
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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
movq %rdi, %rsi
leaq 0xb9b64(%rip), %rax     # 0xcd878
movq (%rax), %rdi
callq 0x13da6
testq %rax, %rax
je 0x13d92
movq %rax, %rbx
xorpd %xmm1, %xmm1
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jge 0x13d84
movl 0x1407140(%rbx,%r14,4), %eax
testl %eax, %eax
je 0x13d7f
cvtsi2sd %eax, %xmm2
movsd %xmm2, 0x8(%rsp)
cvtsi2sdl 0x1407120(%rbx), %xmm0
divsd %xmm0, %xmm2
movsd %xmm2, (%rsp)
movapd %xmm2, %xmm0
movsd %xmm1, 0x10(%rsp)
callq 0x34d77
movsd 0x10(%rsp), %xmm1
mulsd (%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
subsd %xmm0, %xmm1
incq %r14
jmp 0x13d2b
cvtsi2sdl 0x1407120(%rbx), %xmm0
divsd %xmm0, %xmm1
jmp 0x13d9a
movsd 0x82016(%rip), %xmm1    # 0x95db0
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %r14
movq %rdi, %rbx
testq %rbx, %rbx
je 0x13dce
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x4260
testl %eax, %eax
je 0x13dce
movq 0x1407270(%rbx), %rbx
jmp 0x13db0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x1bc(%rdi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
imulq $0x340, %rcx, %rcx      # imm = 0x340
xorpd %xmm0, %xmm0
movsd 0x81727(%rip), %xmm1    # 0x95520
xorl %edx, %edx
cmpq %rax, %rcx
je 0x13e36
movl 0x30f08(%rdi,%rax), %esi
cmpl $0x2, %esi
je 0x13e15
cmpl $0x1, %esi
je 0x13e1b
testl %esi, %esi
jne 0x13e2e
addsd %xmm1, %xmm0
jmp 0x13e2c
movl 0x30f20(%rdi,%rax), %esi
decl %esi
cvtsi2sd %esi, %xmm2
addsd %xmm2, %xmm0
incl %edx
addq $0x340, %rax            # imm = 0x340
jmp 0x13dfb
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
andl $0x0, (%rsi)
movq %rdi, %r14
leaq 0x30f08(%rdi), %r15
xorl %r12d, %r12d
xorl %eax, %eax
movslq 0x1bc(%r14), %rcx
cmpq %rcx, %r12
jge 0x13e9b
cmpl $0x1, (%r15)
jne 0x13e8f
movslq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, (%rbx)
leaq 0x4(,%rcx,4), %rsi
movq %rax, %rdi
callq 0x34f30
movslq (%rbx), %rcx
movl %r12d, -0x4(%rax,%rcx,4)
incq %r12
addq $0x340, %r15            # imm = 0x340
jmp 0x13e5c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movq %rdi, %rsi
leaq 0xb99c6(%rip), %rax     # 0xcd878
movq (%rax), %rdi
callq 0x13da6
testq %rax, %rax
je 0x13ef3
movl 0x1bc(%rax), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
imulq $0x340, %rcx, %rsi      # imm = 0x340
xorl %ecx, %ecx
cmpq %rdx, %rsi
je 0x13ef6
xorl %edi, %edi
cmpl $0x1, 0x30f08(%rax,%rdx)
sete %dil
addl %edi, %ecx
addq $0x340, %rdx            # imm = 0x340
jmp 0x13ed5
pushq $-0x1
popq %rcx
movl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dataset.c
// Function: numeric_features
int* numeric_features(Datasetptr d, int* count)
{
 /*!Last Changed 12.06.2006*/
 int i, *result = NULL;
 *count = 0;
 for (i = 0; i < d->featurecount; i++)
   if (in_list(d->features[i].type, 2, REAL, INTEGER))
    {
     result = alloc(result, (*count + 1) * sizeof(int), *count + 1);
     result[*count] = i;
     (*count)++;
    }
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
andl $0x0, (%rsi)
leaq 0x30f08(%rdi), %r12
pushq $0x2
popq %rbp
xorl %r13d, %r13d
xorl %r15d, %r15d
movslq 0x1bc(%r14), %rax
cmpq %rax, %r13
jge 0x13f6d
movl (%r12), %edi
movl %ebp, %esi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x13f61
movslq (%rbx), %rdx
leaq 0x4(,%rdx,4), %rsi
incq %rdx
movq %r15, %rdi
callq 0x34f30
movq %rax, %r15
movslq (%rbx), %rax
movl %r13d, (%r15,%rax,4)
incl (%rbx)
incq %r13
addq $0x340, %r12            # imm = 0x340
jmp 0x13f1e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dataset.c
// Function: number_of_numeric_features
int number_of_numeric_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 (in_list(tmp->features[i].type, 2, REAL, INTEGER))
     count++;
 return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rsi
leaq 0xb98e7(%rip), %rax     # 0xcd878
movq (%rax), %rdi
callq 0x13da6
testq %rax, %rax
je 0x13fe4
movq %rax, %rbx
movq %rax, %r15
addq $0x30f08, %r15          # imm = 0x30F08
pushq $0x2
popq %r14
xorl %r12d, %r12d
xorl %ebp, %ebp
movslq 0x1bc(%rbx), %rax
cmpq %rax, %r12
jge 0x13fe7
movl (%r15), %edi
movl %r14d, %esi
movl %r14d, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x35812
cmpl $0x1, %eax
sbbl $-0x1, %ebp
incq %r12
addq $0x340, %r15            # imm = 0x340
jmp 0x13fb4
pushq $-0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dataset.c
// Function: generate_random_data
Instanceptr generate_random_data(Datasetptr d, int datasize)
{
 /*!Last Changed 24.09.2006 added string type*/
 /*!Last Changed 09.03.2006*/
 Instanceptr tmp, head = NULL, tmpbefore = NULL;
 double value;
 int i, j;
 for (i = 0; i < datasize; i++)
  {
   tmp = empty_instance(d->featurecount);
   for (j = 0; j < d->featurecount - 1; j++)
     switch (d->features[j].type)
      {
       case REAL  :tmp->values[j].floatvalue = produce_random_value(-1, 1);
                   break;
       case STRING:tmp->values[j].stringindex = myrand() % d->features[j].valuecount;
                   break;
      }
   value = produce_random_value(-1, 1);
   if (value < 0)
     tmp->values[d->featurecount - 1].stringindex = 0;
   else
     tmp->values[d->featurecount - 1].stringindex = 1;
   if (tmpbefore)
     tmpbefore->next = tmp;
   else
     head = tmp;
   tmpbefore = tmp;
  }
 return head;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movl %esi, 0x4(%rsp)
movq %rdi, %r14
leaq 0x30f20(%rdi), %rax
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
xorl %eax, %eax
xorl %ebp, %ebp
cmpl 0x4(%rsp), %ebp
je 0x140ee
movq %rax, 0x10(%rsp)
movl 0x1bc(%r14), %edi
callq 0x140fd
movq %rax, %r12
movq 0x8(%rsp), %rbx
xorl %r15d, %r15d
movslq 0x1bc(%r14), %rax
decq %rax
cmpq %rax, %r15
jge 0x140a2
movl -0x18(%rbx), %eax
cmpl $0x1, %eax
je 0x14084
cmpl $0x2, %eax
jne 0x14096
movsd 0x81d45(%rip), %xmm0    # 0x95db0
movsd 0x814ad(%rip), %xmm1    # 0x95520
callq 0x35cae
movq (%r12), %rax
movsd %xmm0, (%rax,%r15,8)
jmp 0x14096
xorl %eax, %eax
callq 0x35c7f
cltd
idivl (%rbx)
movq (%r12), %rax
movl %edx, (%rax,%r15,8)
incq %r15
addq $0x340, %rbx            # imm = 0x340
jmp 0x14047
movsd 0x81d06(%rip), %xmm0    # 0x95db0
movsd 0x8146e(%rip), %xmm1    # 0x95520
callq 0x35cae
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
setbe %al
movq (%r12), %rcx
movslq 0x1bc(%r14), %rdx
movl %eax, -0x8(%rcx,%rdx,8)
movq %r12, %rax
testq %r13, %r13
je 0x140e4
movq %r12, 0x10(%r13)
movq 0x10(%rsp), %rax
incl %ebp
movq %r12, %r13
jmp 0x14021
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dataset.c
// Function: empty_instance
Instanceptr empty_instance(int fcount)
{
 /*!Last Changed 07.01.2007 added sublist*/
 /*!Last Changed 26.11.2005 removed unused dataset parameter*/
 /*!Last Changed 24.03.2005*/
 Instanceptr currentinstance;
 currentinstance = (Instanceptr)safemalloc(sizeof(Instance), "empty_instance", 2);
 currentinstance->values = (union value*) safemalloc(fcount * sizeof(union value), "empty_instance", 3);
 currentinstance->isexception = NO;
 currentinstance->next = NULL;
 currentinstance->sublist = NULL;
 currentinstance->class_labels = NULL;
 return currentinstance;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x82fed(%rip), %r14     # 0x970f8
pushq $0x30
popq %rdi
pushq $0x2
popq %rdx
movq %r14, %rsi
callq 0x34f59
movq %rax, %r15
movslq %ebx, %rdi
shlq $0x3, %rdi
pushq $0x3
popq %rdx
movq %r14, %rsi
callq 0x34f59
movq %rax, (%r15)
andl $0x0, 0x20(%r15)
andq $0x0, 0x28(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dataset.c
// Function: empty_dataset
Datasetptr empty_dataset(char* datasetname, char* directoryname, char* filename, char separator)
{
 /*!Last Changed 24.12.2006*/
 Datasetptr tmp;
 tmp = safemalloc(sizeof(Dataset), "create_dataset", 12);
 tmp->name = strcopy(tmp->name, datasetname);
 tmp->directory = strcopy(tmp->directory, directoryname);
 tmp->file = strcopy(tmp->file, filename);
 tmp->separator = separator;
 tmp->active = 1;
 tmp->dsnname = NULL;
 tmp->tablename = NULL;
 tmp->storetype = STORE_TEXT;
 tmp->kernel = NULL;
 tmp->next = NULL;
 tmp->sigma = 0.0;
 return tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x82a87(%rip), %rsi     # 0x96ded
pushq $0xc
popq %rdx
movl $0x1407278, %edi        # imm = 0x1407278
callq 0x34f59
movq %rax, %r14
movq 0x8(%rax), %rdi
movq %r13, %rsi
callq 0x3604c
movq %rax, 0x8(%r14)
movq 0x1407118(%r14), %rdi
movq %r12, %rsi
callq 0x3604c
movq %rax, 0x1407118(%r14)
movq 0x1b0(%r14), %rdi
movq %r15, %rsi
callq 0x3604c
movq %rax, 0x1b0(%r14)
movb %bl, 0x1a8(%r14)
movl $0x1, (%r14)
andl $0x0, 0x140713c(%r14)
andq $0x0, 0x1407210(%r14)
andq $0x0, 0x1407270(%r14)
andq $0x0, 0x1407130(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x1407108(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dataset.c
// Function: discretization_equalwidth
double* discretization_equalwidth(Datasetptr original, int fno, int valuecount)
{
 int i;
 double* splits, max, min;
 splits = safemalloc((valuecount - 1) * sizeof(double), "discretization_equalwidth", 1);
 switch (original->features[fno].type)
  {
   case INTEGER:min = original->features[fno].min.intvalue;
                max = original->features[fno].max.intvalue;
                break;
   case    REAL:min = original->features[fno].min.floatvalue;
                max = original->features[fno].max.floatvalue;
                break;
  }
 for (i = 0; i < valuecount - 1; i++)
   splits[i] = min + (i + 1) * ((max - min) / valuecount);
 return splits;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leal -0x1(%rbx), %r15d
movslq %edx, %rax
leaq -0x8(,%rax,8), %rdi
leaq 0x8224b(%rip), %rsi     # 0x96866
pushq $0x1
popq %rdx
callq 0x34f59
movslq %ebp, %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %r14, %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movl (%rcx), %edx
cmpl $0x2, %edx
je 0x1464e
testl %edx, %edx
jne 0x14658
cvtsi2sdl 0x8(%rcx), %xmm0
cvtsi2sdl 0x10(%rcx), %xmm1
jmp 0x14658
movsd 0x8(%rcx), %xmm0
movsd 0x10(%rcx), %xmm1
subsd %xmm0, %xmm1
cvtsi2sd %ebx, %xmm2
divsd %xmm2, %xmm1
xorl %ecx, %ecx
testl %r15d, %r15d
cmovlel %ecx, %r15d
cmpq %rcx, %r15
je 0x1468c
leaq 0x1(%rcx), %rdx
cvtsi2sd %edx, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, (%rax,%rcx,8)
movq %rdx, %rcx
jmp 0x1466d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dataset.c
// Function: kernel_file_name
char* kernel_file_name(Datasetptr dataset)
{
 char *fname;
 fname = (char *)safemalloc(200, "kernel_file_name", 2);
 if (get_parameter_l("currentos"))
   sprintf(fname, "%s/%s/%s", datadir, dataset->directory, dataset->kernelfiles[get_parameter_i("kernelindex")]);
 else
   sprintf(fname, "%s\\%s\\%s", datadir, dataset->directory, dataset->kernelfiles[get_parameter_i("kernelindex")]);
 return fname;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x81878(%rip), %rsi     # 0x971ff
pushq $0x2
popq %rdx
movl $0xc8, %edi
callq 0x34f59
movq %rax, %rbx
leaq 0x81800(%rip), %rdi     # 0x9719e
callq 0x4cf11
movl %eax, %ebp
leaq 0xb7ed4(%rip), %rax     # 0xcd880
movq (%rax), %r15
movq 0x1407118(%r14), %r12
leaq 0x81853(%rip), %rdi     # 0x97210
callq 0x4cd35
testl %ebp, %ebp
cltq
movq 0x1407218(%r14,%rax,8), %r8
leaq 0x81821(%rip), %rax     # 0x971f6
leaq 0x81811(%rip), %rsi     # 0x971ed
cmoveq %rax, %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x41b0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dataset.c
// Function: delete_dataset
void delete_dataset(char *dataset_name)
{
 Datasetptr previous = NULL, dataset = Datasets;
 while (dataset)
  {
   if (!strcmp(dataset->name, dataset_name))
    {
     if (previous)
       previous->next = dataset->next;
     else
       Datasets = dataset->next;
     free_dataset(dataset);
     break;
    }
   previous = dataset;
   dataset = dataset->next;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0xb7b8a(%rip), %rax     # 0xcd878
xorl %r15d, %r15d
movq (%rax), %rbx
testq %rbx, %rbx
je 0x15d15
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x4260
testl %eax, %eax
je 0x15d1b
leaq 0x1407270(%rbx), %rax
movq %rbx, %r15
jmp 0x15cf1
popq %rbx
popq %r14
popq %r15
retq
movq 0x1407270(%rbx), %rax
testq %r15, %r15
jne 0x15d30
leaq 0xb7b4a(%rip), %r15     # 0xcd878
jmp 0x15d37
addq $0x1407270, %r15        # imm = 0x1407270
movq %rax, (%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12723
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dataset.c
// Function: type_change
void type_change(Datasetptr d)
{
/*!Last Changed 19.03.2002*/
 int i;
 for (i = 0; i < d->featurecount; i++)
  {
   d->features[i].oldtype = d->features[i].type;
   if (d->features[i].type == INTEGER)
     d->features[i].type = REAL;
  }
}

// Assembly:
movslq 0x1bc(%rdi), %rax
addq $0x30f08, %rdi          # imm = 0x30F08
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x16cc5
movl (%rdi), %edx
movl %edx, 0x4(%rdi)
testl %edx, %edx
jne 0x16cb9
movl $0x2, (%rdi)
incq %rcx
addq $0x340, %rdi            # imm = 0x340
jmp 0x16ca5
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dataset.c
// Function: type_restore
void type_restore(Datasetptr d)
{
/*!Last Changed 19.03.2002*/
 int i;
 for (i = 0; i < d->featurecount; i++)
   d->features[i].type = d->features[i].oldtype;
}

// Assembly:
movslq 0x1bc(%rdi), %rax
addq $0x30f0c, %rdi          # imm = 0x30F0C
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x16cec
movl (%rdi), %edx
movl %edx, -0x4(%rdi)
incq %rcx
addq $0x340, %rdi            # imm = 0x340
jmp 0x16cd6
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dataset.c
// Function: print_datasets
void print_datasets(Datasetptr header, DATASET_TYPE printwhat)
{
 int i=1;
 Datasetptr dataset=header;
 if (!dataset)
  {
   printf(m1056);
   return;
  }
 printf("|Dataset Name      |# of Classes|# of Features|# of Instances|Base Error|\n");
 while (dataset)
  {
   if (printwhat == ALL || (printwhat == CLASSIFICATION_DATASETS && dataset->classno > 0) || (printwhat == REGRESSION_DATASETS && dataset->classno == 0) || (printwhat == TWOCLASS_DATASETS && dataset->classno == 2) || (printwhat == KCLASS_DATASETS && dataset->classno > 2) || (printwhat == DISCRETE_DATASETS && number_of_symbolic_features(dataset->name) == dataset->featurecount - 1) || (printwhat == CONTINUOUS_DATASETS && number_of_numeric_features(dataset->name) == dataset->featurecount - 1) || (printwhat == MIXED_DATASETS && number_of_numeric_features(dataset->name) != dataset->featurecount - 1 && number_of_symbolic_features(dataset->name) != dataset->featurecount - 1))
    {
     printf("|%18s|%12d|%13d|%14d|%10.2f|\n", dataset->name, dataset->classno, dataset->featurecount, dataset->datacount, dataset->baseerror);
     i++;  
    }
   dataset=dataset->next;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x16df3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x809f8(%rip), %rdi     # 0x97705
callq 0x4090
movl %ebx, %r12d
leaq 0x7f788(%rip), %r13     # 0x964a4
leaq 0x803b7(%rip), %r15     # 0x970da
testq %r14, %r14
je 0x16de4
cmpl $0x7, %ebx
ja 0x16dd8
movslq (%r13,%r12,4), %rax
addq %r13, %rax
jmpq *%rax
cmpl $0x0, 0x10(%r14)
jg 0x16daf
jmp 0x16dd8
cmpl $0x2, 0x10(%r14)
jg 0x16daf
jmp 0x16dd8
cmpl $0x0, 0x10(%r14)
jne 0x16dd8
jmp 0x16daf
cmpl $0x2, 0x10(%r14)
je 0x16daf
jmp 0x16dd8
movq 0x8(%r14), %rdi
callq 0x13f7f
movl 0x1bc(%r14), %ebp
decl %ebp
cmpl %ebp, %eax
je 0x16dd8
movq 0x8(%r14), %rdi
callq 0x13ea7
cmpl %ebp, %eax
jne 0x16daf
jmp 0x16dd8
movq 0x8(%r14), %rdi
callq 0x13ea7
jmp 0x16da2
movq 0x8(%r14), %rdi
callq 0x13f7f
movl 0x1bc(%r14), %ecx
decl %ecx
cmpl %ecx, %eax
jne 0x16dd8
movq 0x8(%r14), %rsi
movl 0x10(%r14), %edx
movl 0x1bc(%r14), %ecx
movl 0x1407120(%r14), %r8d
movsd 0x1407208(%r14), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x4030
movq 0x1407270(%r14), %r14
jmp 0x16d23
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x808f5(%rip), %rdi     # 0x976ef
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dataset.c
// Function: print_cmu_data_header
void print_cmu_data_header(FILE* outfile, Datasetptr d)
{
 /*!Last Changed 02.05.2007 added regression*/
 /*!Last Changed 21.04.2007*/
 int i;
 fprintf(outfile, "$SETUP\n\n");
 fprintf(outfile, "PROTOCOL:  IO;\n");
 fprintf(outfile, "OFFSET:     0;\n");
 fprintf(outfile, "INPUTS:     %d;\n", d->multifeaturecount - 1);
 if (d->classno != 0)
   fprintf(outfile, "OUTPUTS:    %d;\n\n", d->classno);
 else
   fprintf(outfile, "OUTPUTS:    1;\n\n");
 for (i = 0; i < d->multifeaturecount - 1; i++)
   fprintf(outfile, "IN [%d]: CONT;\n", i + 1);
 fprintf(outfile, "\n");
 if (d->classno != 0)
   for (i = 0; i < d->classno; i++)
     fprintf(outfile, "OUT [%d]: BINARY;\n", i + 1);
 else
   fprintf(outfile, "OUT [1]: CONT;\n");
 fprintf(outfile, "\n\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7f888(%rip), %rdi     # 0x972ac
pushq $0x8
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %rbx, %rcx
callq 0x42c0
leaq 0x7f878(%rip), %rdi     # 0x972b5
pushq $0xf
popq %r12
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x42c0
leaq 0x7f86f(%rip), %rdi     # 0x972c5
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x42c0
movl 0x1c0(%r14), %edx
decl %edx
leaq 0x7f861(%rip), %rsi     # 0x972d5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
movl 0x10(%r14), %edx
testl %edx, %edx
je 0x17a99
leaq 0x7f859(%rip), %rsi     # 0x972e6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
jmp 0x17aae
leaq 0x7f858(%rip), %rdi     # 0x972f8
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x42c0
pushq $0x1
popq %r15
leaq 0x7f850(%rip), %r12     # 0x97309
leal -0x1(%r15), %eax
movl 0x1c0(%r14), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0x17adf
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x42e0
incl %r15d
jmp 0x17ab9
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x4150
movl 0x10(%r14), %eax
testl %eax, %eax
je 0x17b1e
pushq $0x1
popq %r15
leaq 0x7f81c(%rip), %r12     # 0x97319
leal -0x1(%r15), %ecx
cmpl %eax, %ecx
jge 0x17b33
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x42e0
movl 0x10(%r14), %eax
incl %r15d
jmp 0x17afd
leaq 0x7f807(%rip), %rdi     # 0x9732c
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x42c0
leaq 0x7f7cc(%rip), %rdi     # 0x97306
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x42c0
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dataset.c
// Function: volume_overlap_region
double volume_overlap_region(Datasetptr d)
{
 /* multiclass is handled by one vs one */
 Instanceptr traindata;
 int i, j, k;
 double result = 0, classsum, min1, max1, min2, max2;
 read_from_train_file(d, &traindata);
 realize(traindata);
 exchange_classdefno(d);
 result = 1;
 for (i = 0; i < d->multifeaturecount; i++)
  {
   if (i != d->classdefno)
    {   
     classsum = 0;
     for (j = 0; j < d->classno; j++)
      {
       for (k = j + 1; k < d->classno; k++)
        {
         find_bounds_of_feature_class(traindata, i, j, &min1, &max1);
         find_bounds_of_feature_class(traindata, i, k, &min2, &max2);
         classsum += (fmin(max1, max2) - fmax(min1, min2)) / (fmax(max1, max2) + fmin(min1, min2));
        }
      }
     result *= (classsum / (d->classno * (d->classno - 1) / 2));
    }
  }
 exchange_classdefno(d); 
 deallocate(traindata);
 traindata = NULL;
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rsi
callq 0x5577a
movq (%r14), %rdi
callq 0xfc81
movq %rbx, %rdi
callq 0x11d5c
movsd 0x7d428(%rip), %xmm0    # 0x95520
movsd %xmm0, 0x8(%rsp)
xorl %ebp, %ebp
leaq 0x30(%rsp), %r12
leaq 0x28(%rsp), %r13
cmpl 0x1c0(%rbx), %ebp
jge 0x1822e
cmpl 0x1407128(%rbx), %ebp
je 0x18227
movl 0x10(%rbx), %ecx
xorpd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %r14d, %r14d
cmpl %ecx, %r14d
jge 0x181fd
leal 0x1(%r14), %r15d
movl %r15d, 0x24(%rsp)
cmpl %ecx, %r15d
jge 0x181f1
movq 0x18(%rsp), %rdi
movl %ebp, %esi
movl %r14d, %edx
leaq 0x40(%rsp), %rcx
leaq 0x38(%rsp), %r8
callq 0x10267
movq 0x18(%rsp), %rdi
movl %ebp, %esi
movl %r15d, %edx
movq %r12, %rcx
movq %r13, %r8
callq 0x10267
movsd 0x38(%rsp), %xmm0
movhpd 0x40(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
movsd 0x28(%rsp), %xmm1
movhpd 0x30(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
movapd %xmm1, %xmm2
maxpd %xmm0, %xmm2
movapd %xmm1, %xmm3
minpd %xmm0, %xmm1
cmpunordpd %xmm0, %xmm0
movapd %xmm0, %xmm4
andnpd %xmm2, %xmm4
andpd %xmm0, %xmm3
orpd %xmm3, %xmm4
andnpd %xmm1, %xmm0
orpd %xmm3, %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
addsd %xmm4, %xmm1
pshufd $0xee, %xmm4, %xmm2     # xmm2 = xmm4[2,3,2,3]
subsd %xmm2, %xmm0
divsd %xmm1, %xmm0
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
incl %r15d
movl 0x10(%rbx), %ecx
jmp 0x18144
movl 0x24(%rsp), %eax
movl %eax, %r14d
jmp 0x18132
leal -0x1(%rcx), %eax
imull %ecx, %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
cvtsi2sd %eax, %xmm0
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
incl %ebp
jmp 0x1810a
movq %rbx, %rdi
callq 0x11d5c
movq 0x18(%rsp), %rdi
callq 0x2c010
movsd 0x8(%rsp), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq