LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0xed0f3(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x187dd
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq 0xed0d6(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x187be
leaq 0xed0c4(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x10(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x187b1
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x52e80
jmp 0x187b3
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x18760
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x52e80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x18743
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x185f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x188ad
movq -0x18(%rbp), %rdi
callq 0x43530
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq 0xed00b(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x1889c
leaq 0xecff9(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x10(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x1888f
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x10(%rbp), %rdx
movslq (%rcx,%rdx,8), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x18891
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1882b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1880d
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xec9e5(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x8, %esi
leaq 0xca1fc(%rip), %rdx     # 0xe306a
movl $0x3, %ecx
callq 0x52f40
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x18f57
movq -0x30(%rbp), %rdi
callq 0x43530
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x46c40
movq %rax, -0x38(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
leaq 0xec984(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x1c0(%rcx), %eax
jge 0x18f46
movl -0x20(%rbp), %eax
leaq 0xec96f(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x1407128(%rcx), %eax
je 0x18f36
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm2
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x18f38
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x18eb2
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x18e84
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xec8d8(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x18fc5
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jle 0x18fa8
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x18fb8
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x18fba
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x18f5e
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
leaq 0xec0fd(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
leaq 0xec0e7(%rip), %rax     # 0x105840
movq (%rax), %rdi
callq 0x1b690
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
movl $0x1, %edi
callq 0x57fc0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x19888
movl $0x0, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x1982a
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x1981d
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x42c40
movsd %xmm0, -0x50(%rbp)
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x42c40
movaps %xmm0, %xmm2
movsd -0x50(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x197bf
jmp 0x1981f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x197b1
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x1986e
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x42c40
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x19831
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x19798
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x198c0
cvtsi2sdl -0x2c(%rbp), %xmm1
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1988f
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/data.c
// Function: count_exceptions
int count_exceptions(Instanceptr list)
{
 /*!Last Changed 08.05.2004*/
 int excount = 0;
 Instanceptr tmp = list;
 while (tmp)
  {
   if (tmp->isexception)
     excount++;
   tmp = tmp->next;
  }
 return excount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1a7cf
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x1a7c1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1a7a7
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1a83b
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x1a82d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x1a82b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1a82d
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1a7fe
cmpl $0x0, -0x14(%rbp)
je 0x1a869
cvtsi2sdl -0x18(%rbp), %xmm1
xorps %xmm0, %xmm0
addsd %xmm0, %xmm1
movsd 0xc81eb(%rip), %xmm0    # 0xe2a40
mulsd %xmm1, %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1a871
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xcd8ec(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x1a8e7
jmp 0x1aa33
movq -0x8(%rbp), %rax
movl 0x1bc(%rax), %edi
callq 0x54600
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x1407128(%rcx), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jge 0x1a91c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1a922
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x1a9cc
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1407128(%rcx), %eax
je 0x1a99d
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x24(%rbp), %eax
jge 0x1a97c
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x34(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl $0x1, 0x1c(%rax)
jmp 0x1a99b
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x34(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl $0x0, 0x1c(%rax)
jmp 0x1a9bc
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x34(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl $0x1, 0x1c(%rax)
jmp 0x1a9be
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1a929
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movb 0x1a8(%rax), %al
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movsbl %al, %esi
callq 0x44c60
movq -0x40(%rbp), %rdi
callq 0x4250
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x1aa33
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x34(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl $0x1, 0x1c(%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1a9fa
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xcd35c(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1ae74
jmp 0x1aeea
movq -0x18(%rbp), %rdi
callq 0x449f0
movl %eax, %edi
callq 0x54600
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1aed8
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x46c40
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movb 0x1a8(%rax), %al
movq -0x8(%rbp), %rdx
movq -0x40(%rbp), %rcx
movsbl %al, %esi
callq 0x435b0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1ae8f
movq -0x28(%rbp), %rdi
callq 0x4250
movq -0x38(%rbp), %rdi
callq 0x52e80
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xea179(%rip), %rax     # 0x105848
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1b6ff
movq -0x8(%rbp), %rax
movq 0x1407270(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b710
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b6d6
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xc78a6(%rip), %rdi     # 0xe3221
callq 0x79040
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x85390
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1ba2d
xorps %xmm0, %xmm0
movsd 0xc6664(%rip), %xmm1    # 0xe2018
callq 0x545a0
movsd %xmm0, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x43530
movl %eax, -0x44(%rbp)
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1ba1c
jmp 0x1b9dc
movb $0x0, %al
callq 0x54550
movq -0x8(%rbp), %rcx
cltd
idivl 0x10(%rcx)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x1407128(%rcx), %rcx
movl %edx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x1407128(%rcx), %rcx
movl (%rax,%rcx,8), %eax
cmpl -0x44(%rbp), %eax
je 0x1b9dc
jmp 0x1ba1c
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1b99e
movq -0x18(%rbp), %rdi
leaq 0xcc786(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movb 0x1a8(%rax), %al
movq -0x8(%rbp), %rdx
movq -0x20(%rbp), %rcx
movsbl %al, %esi
callq 0x44c60
movq -0x20(%rbp), %rdi
callq 0x44510
movq -0x30(%rbp), %rdi
callq 0x4250
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x41c0
subl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x24(%rbp), %eax
subl $0x2, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
leaq 0xc5b5c(%rip), %rsi     # 0xe346a
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x30(%rbp)
movl $0x2, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1d9a9
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x41c0
subl $0x1, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %edx
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x3c(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl (%rax), %edi
movl $0x3, %esi
movl $0x2, %edx
xorl %ecx, %ecx
movl $0x4, %r8d
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x1d999
movl $0x0, -0x4(%rbp)
jmp 0x1da2a
jmp 0x1d99b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1d923
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
testl %eax, %eax
je 0x1d9f0
jmp 0x1d9c8
movl -0x40(%rbp), %eax
subl $0x1, %eax
je 0x1da06
jmp 0x1d9d2
movl -0x40(%rbp), %eax
subl $0x2, %eax
je 0x1d9f0
jmp 0x1d9dc
movl -0x40(%rbp), %eax
subl $0x3, %eax
je 0x1da06
jmp 0x1d9e6
movl -0x40(%rbp), %eax
subl $0x4, %eax
jne 0x1da1a
jmp 0x1d9f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x38(%rbp), %ecx
callq 0x1bc40
jmp 0x1da1a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x38(%rbp), %ecx
callq 0x1c530
movq -0x30(%rbp), %rdi
callq 0x52e80
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
leaq 0xe7ded(%rip), %rax     # 0x105848
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1db80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1da84
movsd 0xc4fce(%rip), %xmm0    # 0xe2a48
movsd %xmm0, -0x8(%rbp)
jmp 0x1db6f
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x1db4b
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, 0x1407140(%rax,%rcx,4)
je 0x1db3b
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cvtsi2sdl 0x1407140(%rax,%rcx,4), %xmm0
movq -0x18(%rbp), %rax
cvtsi2sdl 0x1407120(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cvtsi2sdl 0x1407140(%rax,%rcx,4), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x52ad0
movsd -0x40(%rbp), %xmm2
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x1db3d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1da8b
movq -0x18(%rbp), %rax
cvtsi2sdl 0x1407120(%rax), %xmm1
movsd -0x28(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1dbd0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4210
cmpl $0x0, %eax
jne 0x1dbbf
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1dbd8
movq -0x20(%rbp), %rax
movq 0x1407270(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1db98
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x1dcb6
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x1dc54
jmp 0x1dc40
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x1dc71
jmp 0x1dc4a
movl -0x1c(%rbp), %eax
subl $0x2, %eax
jne 0x1dca6
jmp 0x1dc54
movsd 0xc43bc(%rip), %xmm0    # 0xe2018
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1dca6
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x14(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1dca8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1dc0e
movsd -0x10(%rbp), %xmm0
cvtsi2sdl -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x1dd71
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x1c(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x1dd64
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
shlq $0x2, %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
callq 0x52d10
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1dd66
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1dcf9
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
leaq 0xe7aae(%rip), %rax     # 0x105848
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1db80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1ddba
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1de09
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x1de03
movq -0x18(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x1c(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x1ddf6
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1ddf8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1ddc1
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x1dedd
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x14(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl (%rax), %edi
movl $0x2, %edx
xorl %ecx, %ecx
movl %edx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x1decd
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
addl $0x1, %edx
callq 0x52d10
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1decf
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1de49
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
leaq 0xe793e(%rip), %rax     # 0x105848
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1db80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1df2a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1df8b
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x1df85
movq -0x18(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x1c(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl (%rax), %edi
movl $0x2, %edx
xorl %ecx, %ecx
movl %edx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x1df78
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1df7a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1df31
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1e12c
movq -0x8(%rbp), %rax
movl 0x1bc(%rax), %edi
callq 0x1e140
movq %rax, -0x18(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x1bc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1e097
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %eax
movl %eax, -0x3c(%rbp)
subl $0x1, %eax
je 0x1e055
jmp 0x1e024
movl -0x3c(%rbp), %eax
subl $0x2, %eax
jne 0x1e087
jmp 0x1e02e
movsd 0xc4a12(%rip), %xmm0    # 0xe2a48
movsd 0xc3fda(%rip), %xmm1    # 0xe2018
callq 0x545a0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x1e087
movb $0x0, %al
callq 0x54550
movq -0x8(%rbp), %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movslq -0x38(%rbp), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rcx
cltd
idivl 0x18(%rcx)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
movl %edx, (%rax,%rcx,8)
jmp 0x1e089
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1dfec
movsd 0xc49a9(%rip), %xmm0    # 0xe2a48
movsd 0xc3f71(%rip), %xmm1    # 0xe2018
callq 0x545a0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x1e0db
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x1bc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,8)
jmp 0x1e0f9
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x1bc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl $0x1, (%rax,%rcx,8)
cmpq $0x0, -0x28(%rbp)
je 0x1e10e
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1e116
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1dfc6
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x30, %edi
leaq 0xc5de7(%rip), %rsi     # 0xe3f3e
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
leaq 0xc5dca(%rip), %rsi     # 0xe3f3e
movl $0x3, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movl $0x1407278, %edi        # imm = 0x1407278
leaq 0xc53ee(%rip), %rsi     # 0xe3a53
movl $0xc, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x54ba0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x1407118(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x54ba0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x1407118(%rax)
movq -0x28(%rbp), %rax
movq 0x1b0(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x54ba0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x1b0(%rax)
movb -0x19(%rbp), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x1a8(%rax)
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x1407108(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x1407110(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x140713c(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x1407210(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x1407270(%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x1407130(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/dataset.c
// Function: add_dataset
void add_dataset(Datasetptr dataset)
{
 /*!Last Changed 29.01.2004*/
 Datasetptr tmp;
 tmp = Datasets;
 if (tmp == NULL)
  {
   Datasets = dataset;
   return;
  }
 while (tmp->next != NULL)
   tmp = tmp->next;
 tmp->next = dataset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0xe6d49(%rip), %rax     # 0x105848
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1eb1d
movq -0x8(%rbp), %rcx
leaq 0xe6d30(%rip), %rax     # 0x105848
movq %rcx, (%rax)
jmp 0x1eb4d
jmp 0x1eb1f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1407270(%rax)
je 0x1eb3e
movq -0x10(%rbp), %rax
movq 0x1407270(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1eb1f
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1407270(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
decl %eax
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0xc4957(%rip), %rsi     # 0xe34cc
movl $0x1, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x1ebaf
jmp 0x1eba2
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x1ebf5
jmp 0x1ec39
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0xc(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cvtsi2sdl 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0xc(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cvtsi2sdl 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x1ec39
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0xc(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0xc(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1ec8f
movsd -0x30(%rbp), %xmm1
movl -0x14(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd -0x28(%rbp), %xmm2
subsd -0x30(%rbp), %xmm2
cvtsi2sdl -0x10(%rbp), %xmm3
divsd %xmm3, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1ec40
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/dataset.c
// Function: dataset_directory_name
char* dataset_directory_name(Datasetptr dataset)
{
 char *fname;
 fname = (char *)safemalloc(200, "dataset_directory_name", 2);
 if (get_parameter_l("currentos"))
   sprintf(fname, "%s/%s", datadir, dataset->directory);
 else
   sprintf(fname, "%s\\%s", datadir, dataset->directory);
 return fname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xc8, %edi
leaq 0xc43c5(%rip), %rsi     # 0xe3fcd
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
leaq 0xc43c7(%rip), %rdi     # 0xe3fe4
callq 0x792b0
cmpl $0x0, %eax
je 0x1fc50
movq -0x10(%rbp), %rdi
leaq 0xe5c1e(%rip), %rax     # 0x105850
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x1407118(%rax), %rcx
leaq 0xc43ef(%rip), %rsi     # 0xe4036
movb $0x0, %al
callq 0x4170
jmp 0x1fc77
movq -0x10(%rbp), %rdi
leaq 0xe5bf5(%rip), %rax     # 0x105850
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x1407118(%rax), %rcx
leaq 0xc43cf(%rip), %rsi     # 0xe403f
movb $0x0, %al
callq 0x4170
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/dataset.c
// Function: dataset_file_name
char* dataset_file_name(Datasetptr dataset)
{
 /*!Last Changed 31.10.2005*/
 char *fname;
 fname = (char *)safemalloc(200, "dataset_file_name", 2);
 if (get_parameter_l("currentos"))
   sprintf(fname, "%s/%s/%s", datadir, dataset->directory, dataset->file);
 else
   sprintf(fname, "%s\\%s\\%s", datadir, dataset->directory, dataset->file);
 return fname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xc8, %edi
leaq 0xc4379(%rip), %rsi     # 0xe4021
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
leaq 0xc4327(%rip), %rdi     # 0xe3fe4
callq 0x792b0
cmpl $0x0, %eax
je 0x1fcfb
movq -0x10(%rbp), %rdi
leaq 0xe5b7e(%rip), %rax     # 0x105850
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x1407118(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %r8
leaq 0xc4341(%rip), %rsi     # 0xe4033
movb $0x0, %al
callq 0x4170
jmp 0x1fd2d
movq -0x10(%rbp), %rdi
leaq 0xe5b4a(%rip), %rax     # 0x105850
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x1407118(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x1b0(%rax), %r8
leaq 0xc4316(%rip), %rsi     # 0xe403c
movb $0x0, %al
callq 0x4170
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0xc8, %edi
leaq 0xc332d(%rip), %rsi     # 0xe4045
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
leaq 0xc32b7(%rip), %rdi     # 0xe3fe4
callq 0x792b0
cmpl $0x0, %eax
je 0x20d9d
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0xe4b0a(%rip), %rax     # 0x105850
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x1407118(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xc32eb(%rip), %rdi     # 0xe4056
callq 0x78f10
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl %eax, %esi
movq -0x18(%rbp), %rax
movslq %esi, %rsi
movq 0x1407218(%rax,%rsi,8), %r8
leaq 0xc329f(%rip), %rsi     # 0xe4033
movb $0x0, %al
callq 0x4170
jmp 0x20e01
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0xe4aa4(%rip), %rax     # 0x105850
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x1407118(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0xc3285(%rip), %rdi     # 0xe4056
callq 0x78f10
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
movl %eax, %esi
movq -0x38(%rbp), %rax
movslq %esi, %rsi
movq 0x1407218(%rax,%rsi,8), %r8
leaq 0xc3242(%rip), %rsi     # 0xe403c
movb $0x0, %al
callq 0x4170
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0xe45dd(%rip), %rax     # 0x105848
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x212e7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4210
cmpl $0x0, %eax
jne 0x212ce
cmpq $0x0, -0x10(%rbp)
je 0x212ae
movq -0x18(%rbp), %rax
movq 0x1407270(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1407270(%rax)
jmp 0x212c3
movq -0x18(%rbp), %rax
movq 0x1407270(%rax), %rcx
leaq 0xe4588(%rip), %rax     # 0x105848
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x1b710
jmp 0x212e7
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x1407270(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x21272
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x229d2
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0xc(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0xc(%rbp), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0xc(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x229c2
movq -0x8(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0xc(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl $0x2, (%rax)
jmp 0x229c4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2293f
popq %rbp
retq
nopw %cs:(%rax,%rax)