LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: test_univariate
int test_univariate(Instanceptr testingdata, int fno, double split, int leftclass, int rightclass)
{
 /*!Last Changed 23.09.2004*/
 int i, error = 0;
 double value;
 Instanceptr test = testingdata;
 while (test)
  {
   value = real_feature(test, fno);   
   i = give_classno(test);
   if (value <= split)
    {
     if (i != leftclass)
       error++;
    }
   else
    {
     if (i != rightclass)
       error++;
    }
   test = test->next;
  }
 return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x9fcc6
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r12
xorl %r15d, %r15d
movsd %xmm0, (%rsp)
movq %r12, %rdi
movl %r14d, %esi
callq 0x2ed6a
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x2f33a
movsd (%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
movl %ebp, %ecx
cmovbl %ebx, %ecx
xorl %edx, %edx
cmpl %ecx, %eax
setne %dl
addl %edx, %r15d
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x9fc87
jmp 0x9fcc9
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: find_occurences_for_discrete_feature
void find_occurences_for_discrete_feature(Instanceptr instances, int fno, int ratio[MAXVALUES][MAXCLASSES])
{
/*!Last Changed 22.04.2003*/
 int i, j;
 Instanceptr tmp = instances;
 for (i = 0; i < MAXVALUES; i++)
   for (j = 0;j < MAXCLASSES; j++)
     ratio[i][j] = 0;
 while (tmp)
  {
   j = give_classno(tmp);
   i = tmp->values[fno].stringindex;
   ratio[i][j]++;
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x4e20, %edx           # imm = 0x4E20
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4050
testq %r14, %r14
je 0x9fd26
movslq %ebp, %r15
movq %r14, %rdi
callq 0x2f33a
movq (%r14), %rcx
movslq (%rcx,%r15,8), %rcx
cltq
imulq $0xc8, %rcx, %rcx
addq %rbx, %rcx
incl (%rcx,%rax,4)
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x9fcff
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: quicksort_instances
void quicksort_instances(Instanceptr instances,int start,int end,int fno)
{
 /*!Last Changed 26.01.2003*/
 int pivot;
 if (start < end)
  {
   if (!mustrealize)
     if (quicksort_all_sorted(instances, start, end, fno))
       return;
   pivot = quicksort_partition(instances, start, end, fno);
   quicksort_instances(instances, start, pivot - 1, fno);
   quicksort_instances(instances, pivot + 1, end, fno);
  }
}

// Assembly:
cmpl %edx, %esi
jge 0xa0263
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
leaq 0x311d98(%rip), %r13    # 0x3b1fa4
cmpl $0x0, (%r13)
jne 0xa0226
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xa070a
testl %eax, %eax
jne 0xa0255
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xa05a8
movl %eax, %r12d
leal -0x1(%r12), %edx
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %ecx
callq 0xa01ec
incl %r12d
movl %r12d, %r15d
cmpl %ebp, %r12d
jl 0xa020c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: sort_function_instances
int sort_function_instances(Instanceptr x, Instanceptr y, int fno)
{
 /*!Last Changed 22.05.2005*/
 if (!mustrealize)
   if (current_dataset->features[fno].type == INTEGER)
     if (x->values[fno].intvalue < y->values[fno].intvalue)
       return -1;
     else
       if (x->values[fno].intvalue > y->values[fno].intvalue)
         return 1;
       else
         return 0;
   else
     if (x->values[fno].floatvalue < y->values[fno].floatvalue)
       return -1;
     else
       if (x->values[fno].floatvalue > y->values[fno].floatvalue)
         return 1;
       else
         return 0;
 else
   if (real_feature(x, fno) < real_feature(y, fno))
     return -1;
   else
     if (real_feature(x, fno) > real_feature(y, fno))
       return 1;
     else
       return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x311cbc(%rip), %rax    # 0x3b1fa4
cmpl $0x0, (%rax)
je 0xa033c
movq %r14, %rdi
movl %ebp, %esi
callq 0x2ed6a
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2ed6a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ucomisd 0x8(%rsp), %xmm0
ja 0xa037e
movq %r14, %rdi
movl %ebp, %esi
callq 0x2ed6a
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2ed6a
xorl %eax, %eax
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jmp 0xa037b
leaq 0x3552d(%rip), %rax     # 0xd5870
movq (%rax), %rax
movslq %ebp, %rcx
imulq $0x340, %rcx, %rdx      # imm = 0x340
cmpl $0x0, 0x30f08(%rax,%rdx)
movq (%r14), %rdx
movq (%rbx), %rax
je 0xa0387
movsd (%rdx,%rcx,8), %xmm0
movsd (%rax,%rcx,8), %xmm1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ucomisd %xmm0, %xmm1
ja 0xa037e
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl (%rax,%rcx,8), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, (%rdx,%rcx,8)
jl 0xa037e
setg %al
movzbl %al, %eax
jmp 0xa037e
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: quicksort_partition
int quicksort_partition(Instanceptr instances, int start, int end, int fno)
{
 /*!Last Changed 22.01.2004*/
 /*!Last Changed 26.01.2003*/
 Instance x;
 int i = start - 1, j;
 x = quicksort_three_elements(instances, start, end, fno);
 for (j = start; j < end; j++)
   if (sort_function_instances(&(instances[j]), &x, fno) <= 0)
    {
     i++;
     exchange_instances(instances,i,j);
    }
 exchange_instances(instances,i+1,end);
 return i + 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %r12d, %ecx
movl %r15d, %r8d
callq 0xa039c
movl %r12d, %ebp
subl %r14d, %ebp
jle 0xa068f
movl %r12d, 0xc(%rsp)
movslq %r14d, %rax
decl %r14d
leaq (%rax,%rax,2), %r12
shlq $0x4, %r12
addq %rbx, %r12
leaq 0x48(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0xa02d1
testl %eax, %eax
jg 0xa067b
incl %r14d
movslq %r14d, %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movups (%rbx,%rax), %xmm0
movups 0x10(%rbx,%rax), %xmm1
movups 0x20(%rbx,%rax), %xmm2
movaps %xmm2, 0x30(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rbx,%rax)
movups %xmm1, 0x10(%rbx,%rax)
movups %xmm0, (%rbx,%rax)
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movaps 0x30(%rsp), %xmm2
movups %xmm2, 0x20(%r12)
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
addq $0x30, %r12
decl %ebp
jne 0xa05ff
incl %r14d
movl 0xc(%rsp), %r12d
movslq %r14d, %rax
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
movups (%rbx,%rcx), %xmm0
movups 0x10(%rbx,%rcx), %xmm1
movups 0x20(%rbx,%rcx), %xmm2
movaps %xmm2, 0x30(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movslq %r12d, %rdx
leaq (%rdx,%rdx,2), %rdx
shlq $0x4, %rdx
movups (%rbx,%rdx), %xmm0
movups 0x10(%rbx,%rdx), %xmm1
movups 0x20(%rbx,%rdx), %xmm2
movups %xmm2, 0x20(%rbx,%rcx)
movups %xmm1, 0x10(%rbx,%rcx)
movups %xmm0, (%rbx,%rcx)
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movaps 0x30(%rsp), %xmm2
movups %xmm2, 0x20(%rbx,%rdx)
movups %xmm1, 0x10(%rbx,%rdx)
movups %xmm0, (%rbx,%rdx)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: quicksort_all_sorted
int quicksort_all_sorted(Instanceptr instances, int start, int end, int fno)
{
 /*!Last Changed 21.05.2005*/
 int i;
 if (current_dataset->features[fno].type == INTEGER)
  {
   for (i = start + 1; i <= end; i++)
     if (instances[i].values[fno].intvalue < instances[i - 1].values[fno].intvalue)
       return 0;
  }
 else
  {
   for (i = start + 1; i <= end; i++)
     if (instances[i].values[fno].floatvalue < instances[i - 1].values[fno].floatvalue)
       return 0;
  }   
 return 1;
}

// Assembly:
leaq 0x3515f(%rip), %rax     # 0xd5870
movq (%rax), %r8
movslq %ecx, %rax
imulq $0x340, %rax, %rcx      # imm = 0x340
cmpl %esi, %edx
cmovlel %esi, %edx
cmpl $0x0, 0x30f08(%r8,%rcx)
movslq %esi, %rsi
movslq %edx, %rcx
je 0xa0763
subq %rsi, %rcx
incq %rcx
leaq (%rsi,%rsi,2), %rdx
shlq $0x4, %rdx
addq %rdx, %rdi
decq %rcx
je 0xa078f
movq (%rdi), %rdx
movq 0x30(%rdi), %rsi
addq $0x30, %rdi
movsd (%rdx,%rax,8), %xmm0
ucomisd (%rsi,%rax,8), %xmm0
jbe 0xa0745
jmp 0xa078c
subq %rsi, %rcx
incq %rcx
leaq (%rsi,%rsi,2), %rdx
shlq $0x4, %rdx
addq %rdx, %rdi
decq %rcx
je 0xa078f
movq (%rdi), %rdx
movq 0x30(%rdi), %rsi
addq $0x30, %rdi
movl (%rsi,%rax,8), %esi
cmpl (%rdx,%rax,8), %esi
jge 0xa0774
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: find_value_list
double* find_value_list(Instanceptr instances, int fno, int* size)
{
/*!Last Changed 22.03.2002*/
 Instanceptr tmp = instances;
 double* values = NULL, value;
 int i, found;
 (*size) = 0;
 while (tmp)
  {
   found = 0;
   if (current_dataset->features[fno].type == INTEGER)
     value = tmp->values[fno].intvalue;
   else
     value = tmp->values[fno].floatvalue;
   for (i = 0; i < (*size); i++)
     if (values[i] == value)
      {
       found = 1;
       break;
      }
   if (!found)
    {
     (*size)++;
     values = (double *)alloc(values, (*size) * sizeof(double), (*size));
     values[(*size) - 1] = value;
    }
   tmp = tmp->next;
  }
 return values;
}

// Assembly:
movl $0x0, (%rdx)
xorl %ecx, %ecx
testq %rdi, %rdi
je 0xa0854
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movslq %esi, %r15
leaq 0x350ad(%rip), %r12     # 0xd5870
movq (%r12), %rdx
imulq $0x340, %r15, %r13      # imm = 0x340
xorl %eax, %eax
cmpl $0x0, 0x30f08(%rdx,%r13)
movq (%r14), %rsi
je 0xa07e6
movsd (%rsi,%r15,8), %xmm1
jmp 0xa07ef
xorps %xmm1, %xmm1
cvtsi2sdl (%rsi,%r15,8), %xmm1
testl %ecx, %ecx
jle 0xa080c
movl %ecx, %esi
xorl %edi, %edi
movsd (%rax,%rdi,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0xa0804
jnp 0xa083d
incq %rdi
cmpq %rdi, %rsi
jne 0xa07f7
leal 0x1(%rcx), %edx
movl %edx, (%rbx)
movslq %ecx, %rcx
leaq 0x8(,%rcx,8), %rsi
movq %rax, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0x3a0b4
movslq (%rbx), %rcx
movsd 0x8(%rsp), %xmm0
movsd %xmm0, -0x8(%rax,%rcx,8)
movq (%r12), %rdx
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0xa07d0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: find_best_feature
int find_best_feature(Instanceptr instances, double* split)
{
/*!Last Changed 23.03.2002*/
 int i, bestfeature = -1;
 double bestgain = +INT_MAX;
 for (i = 0; i < current_dataset->featurecount; i++)
   if (find_best_split_for_feature_i(instances, i, split, &bestgain))
    {
     bestfeature = i;
     if (bestgain == 0)
       return i;
    }
 if (bestgain == ISELL)
   return -1;
 else
   return bestfeature;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movabsq $0x41dfffffffc00000, %rax # imm = 0x41DFFFFFFFC00000
movq %rax, (%rsp)
leaq 0x34d92(%rip), %r13     # 0xd5870
movq (%r13), %rax
cmpl $0x0, 0x1bc(%rax)
jle 0xa0b4a
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rsp, %r12
movq %r15, %rdi
movl %ebx, %esi
movq %r14, %rdx
movq %r12, %rcx
callq 0xa0857
testl %eax, %eax
je 0xa0b22
movsd (%rsp), %xmm0
ucomisd 0x51ec(%rip), %xmm0     # 0xa5d08
movl %ebx, %ebp
jne 0xa0b22
jnp 0xa0b4f
incl %ebx
movq (%r13), %rax
cmpl 0x1bc(%rax), %ebx
jl 0xa0afb
movsd (%rsp), %xmm0
ucomisd 0x51b3(%rip), %xmm0     # 0xa5cf0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmovnel %ebp, %ebx
cmovpl %ebp, %ebx
jmp 0xa0b4f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: count_feature_combinations
int** count_feature_combinations(Instanceptr instances, int* iter, int size, int* permsize)
{
 int i, classno, permpos, permmultiplier;
 int** featurecounts;
 Instanceptr tmp = instances;
 (*permsize) = 1;
 for (i = 0; i < size; i++)
   (*permsize) *= current_dataset->features[iter[i]].valuecount;
 featurecounts = (int**) safecalloc_2d(sizeof(int*), sizeof(int), *permsize, current_dataset->classno, "count_feature_combinations", 7);
 while (tmp != NULL)
  {
   classno = give_classno(tmp);
   permpos = 0;
   permmultiplier = 1;
   for (i = 0; i < size; i++)
    {
     permpos += permmultiplier * tmp->values[iter[i]].stringindex;
     permmultiplier *= current_dataset->features[iter[i]].valuecount;
    }
   featurecounts[permpos][classno]++;
   tmp = tmp->next;
  }
 return featurecounts;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, (%rcx)
leaq 0x349ee(%rip), %rax     # 0xd5870
movq (%rax), %rax
movl %edx, %ebp
testl %edx, %edx
jle 0xa0eb6
leaq 0x30f08(%rax), %rsi
movl $0x1, %edx
xorl %edi, %edi
movslq (%r14,%rdi,4), %r8
imulq $0x340, %r8, %r8        # imm = 0x340
imull 0x18(%rsi,%r8), %edx
movl %edx, (%rcx)
incq %rdi
cmpq %rdi, %rbp
jne 0xa0e99
jmp 0xa0ebb
movl $0x1, %edx
movl 0x10(%rax), %ecx
leaq 0x7d9f(%rip), %r8       # 0xa8c64
movl $0x8, %edi
movl $0x4, %esi
movl $0x7, %r9d
callq 0x3a231
movq %rax, %r12
testq %r15, %r15
je 0xa0f4b
movl $0x30f08, %r13d         # imm = 0x30F08
movq %r15, %rdi
callq 0x2f33a
testl %ebx, %ebx
jle 0xa0f37
movq (%r15), %rcx
leaq 0x34972(%rip), %rdx     # 0xd5870
movq (%rdx), %rdx
addq %r13, %rdx
xorl %esi, %esi
movl $0x1, %edi
xorl %r8d, %r8d
movslq (%r14,%rsi,4), %r9
movl (%rcx,%r9,8), %r10d
imull %edi, %r10d
addl %r10d, %r8d
imulq $0x340, %r9, %r9        # imm = 0x340
imull 0x18(%rdx,%r9), %edi
incq %rsi
cmpq %rsi, %rbp
jne 0xa0f0e
movslq %r8d, %rcx
jmp 0xa0f39
xorl %ecx, %ecx
movq (%r12,%rcx,8), %rcx
cltq
incl (%rcx,%rax,4)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0xa0ee8
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: find_discrete_split_count
int find_discrete_split_count(int size)
{
 int* iter;
 int i, j, sum = 0, anysame, multiplier1, multiplier2;
 iter = first_iterator(size);
 do{
   anysame = NO;
   for (i = 0; i < size; i++)
     for (j = i + 1; j < size; j++)
       if (iter[i] == iter[j])
         anysame = YES;
   for (i = 0; i < size; i++)
     if (iter[i] == current_dataset->classdefno)
       anysame = YES;
   if (anysame)
     continue;
   multiplier1 = 1;
   for (i = 0; i < size; i++)
     multiplier1 *= factorial(current_dataset->features[iter[i]].valuecount); 
   multiplier2 = 1;
   for (i = 0; i < size; i++)
     multiplier2 *= current_dataset->features[iter[i]].valuecount; 
   sum += multiplier1 * (multiplier2 - 1);
 }while (next_iterator(iter, size, current_dataset->featurecount - 1));
 safe_free(iter); 
 return sum; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %r12d
callq 0x3930e
movq %rax, %r14
movslq %r12d, %r9
movl %r9d, %r13d
movq $0x0, (%rsp)
movl $0x1, %ebp
leaq 0x348e0(%rip), %r10     # 0xd5870
movq %r9, 0x10(%rsp)
movl %r12d, 0xc(%rsp)
movl $0x1, %r15d
movl $0x0, %ebx
testl %r12d, %r12d
jle 0xa1094
xorl %esi, %esi
movq %r13, %rcx
movq %r14, %rdx
xorl %eax, %eax
movq %rsi, %rdi
incq %rsi
cmpq %r9, %rsi
jge 0xa0fdc
movl (%r14,%rdi,4), %edi
movl $0x1, %r8d
cmpl (%rdx,%r8,4), %edi
cmovel %ebp, %eax
incq %r8
cmpq %r8, %rcx
jne 0xa0fcd
addq $0x4, %rdx
decq %rcx
cmpq %r13, %rsi
jne 0xa0fb8
testl %r12d, %r12d
jle 0xa1088
movq (%r10), %rcx
movl 0x1407128(%rcx), %ecx
xorl %edx, %edx
cmpl %ecx, (%r14,%rdx,4)
cmovel %ebp, %eax
incq %rdx
cmpq %rdx, %r13
jne 0xa0ffc
testl %eax, %eax
jne 0xa10a3
xorl %ebx, %ebx
testl %r12d, %r12d
jle 0xa108e
movl $0x1, %r15d
xorl %r12d, %r12d
movq (%r10), %rax
movslq (%r14,%r12,4), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f20(%rax,%rcx), %edi
callq 0x39c21
leaq 0x3482c(%rip), %r10     # 0xd5870
imull %eax, %r15d
incq %r12
cmpq %r12, %r13
jne 0xa1023
movl 0xc(%rsp), %r12d
testl %r12d, %r12d
jle 0xa1094
movq (%r10), %rax
movl $0x30f08, %ecx          # imm = 0x30F08
addq %rcx, %rax
movl $0x1, %ebx
xorl %ecx, %ecx
movslq (%r14,%rcx,4), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
imull 0x18(%rax,%rdx), %ebx
incq %rcx
cmpq %rcx, %r13
jne 0xa106c
decl %ebx
jmp 0xa1094
testl %eax, %eax
jne 0xa10a3
xorl %ebx, %ebx
movl $0x1, %r15d
imull %ebx, %r15d
movq (%rsp), %rax
addl %r15d, %eax
movq %rax, (%rsp)
movq (%r10), %rax
movl 0x1bc(%rax), %edx
decl %edx
movq %r14, %rdi
movl %r12d, %esi
callq 0x3991a
leaq 0x347b0(%rip), %r10     # 0xd5870
testl %eax, %eax
movq 0x10(%rsp), %r9
jne 0xa0f9a
movq %r14, %rdi
callq 0x3a180
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: create_c45children
int create_c45children(Decisionnodeptr node, C45_parameterptr p)
{
 /*!Last Changed 10.08.2005 parametre eklendi*/
 /*!Last Changed 23.01.2003*/
 int count, i;
 node->conditiontype = UNIVARIATE_CONDITION;
 if (!(can_be_divided(node, p)))
   return 1;
 node->featureno = find_best_feature(node->instances,&(node->split));
 if (!(make_children(node)))
   return 1;
 switch (current_dataset->features[node->featureno].type)
  {
   case INTEGER:
   case REAL   :create_c45children(node->left, p);
                create_c45children(node->right, p);
                break;
   case STRING :count = current_dataset->features[node->featureno].valuecount;
                for (i = 0; i < count; i++)
                  create_c45children(&(node->string[i]), p);
                break;
  }
 return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, 0x98(%rdi)
callq 0x1d053
testl %eax, %eax
je 0xa11ba
leaq 0x3475c(%rip), %r15     # 0xd5870
movq 0x20(%r14), %rdi
leaq 0x28(%r14), %rsi
callq 0xa0abe
movl %eax, 0x30(%r14)
movq %r14, %rdi
callq 0xa0b60
testl %eax, %eax
je 0xa11ba
movq (%r15), %rax
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %edx
testl %edx, %edx
je 0xa1153
cmpl $0x2, %edx
jne 0xa117e
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xa10e8
movq 0x8(%r14), %r14
movl $0x0, 0x98(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d053
testl %eax, %eax
jne 0xa1114
jmp 0xa11ba
cmpl $0x1, %edx
jne 0xa11ba
addq %rcx, %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq 0x18(%rax), %rax
testq %rax, %rax
jle 0xa11ba
imulq $0x160, %rax, %r15      # imm = 0x160
xorl %r12d, %r12d
movq 0x10(%r14), %rdi
addq %r12, %rdi
movq %rbx, %rsi
callq 0xa10e8
addq $0x160, %r12            # imm = 0x160
cmpq %r12, %r15
jne 0xa119f
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: find_counts_for_split
void find_counts_for_split(Instanceptr instances, int fno, double split, int* leftcounts, int* rightcounts, int conditiontype)
{
 /*!Last Changed 23.09.2004 added hybridcondition*/
 /*!Last Changed 09.02.2003*/
 int j;
 double value;
 Instanceptr tmp = instances;
 for (j = 0; j < MAXCLASSES; j++)
  {
   leftcounts[j] = 0;
   rightcounts[j] = 0;
  }
 while (tmp)
  {
   if (conditiontype != HYBRID_CONDITION)
     if (current_dataset->features[fno].type==INTEGER)
       value = tmp->values[fno].intvalue;
     else
       value = tmp->values[fno].floatvalue;
   else
     value = real_feature(tmp, fno);
   j = give_classno(tmp);
   if (value <= split)
     leftcounts[j]++;
   else
     rightcounts[j]++;
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movsd %xmm0, 0x10(%rsp)
movl %esi, 0x4(%rsp)
movq %rdi, %r12
xorl %eax, %eax
xorl %ecx, %ecx
movl %eax, (%r15,%rcx,4)
movl %eax, (%r14,%rcx,4)
incq %rcx
cmpq $0x32, %rcx
jne 0xa1222
testq %r12, %r12
je 0xa12b0
movslq 0x4(%rsp), %r13
imulq $0x340, %r13, %rbp      # imm = 0x340
cmpl $0x2, %ebx
jne 0xa1257
movq %r12, %rdi
movl 0x4(%rsp), %esi
callq 0x2ed6a
jmp 0xa1280
leaq 0x34612(%rip), %rax     # 0xd5870
movq (%rax), %rax
cmpl $0x0, 0x30f08(%rax,%rbp)
movq (%r12), %rax
je 0xa1277
movsd (%rax,%r13,8), %xmm0
jmp 0xa1280
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%r13,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x2f33a
movsd 0x10(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
movq %r15, %rcx
cmovbq %r14, %rcx
cltq
incl (%rcx,%rax,4)
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0xa1244
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: left_and_right_sum
void left_and_right_sum(Instanceptr instances, Partition p, int fno, double* leftsum, double* rightsum, int* leftcount, int* rightcount, int conditiontype)
{
/* Last Changed 09.02.2003*/
 int *classassignments, i;
 double value;
 Instanceptr tmp;
 *leftsum = 0;
 *rightsum = 0;
 *leftcount = 0;
 *rightcount = 0;
 if (fno < 0 || instances == NULL || p.count == 0 || all_same_side(p))
   return;
 classassignments = find_class_assignments(p);
 tmp = instances;
 while (tmp)
  {
   if (conditiontype == HYBRID_CONDITION)
     value = real_feature(tmp, fno);
   else
     if (current_dataset->features[fno].type == INTEGER)
       value = tmp->values[fno].intvalue;
     else
       value = tmp->values[fno].floatvalue;
   i = give_classno(tmp);
   if (classassignments[i]==LEFT)
    {
     (*leftcount)++;
     (*leftsum) += value;
    }
   else
    {
     (*rightcount)++;
     (*rightsum) += value;
    }
   tmp = tmp->next;
  }
 safe_free(classassignments);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, 0x24(%rsp)
movl 0x98(%rsp), %eax
movl %eax, 0x34(%rsp)
xorl %eax, %eax
movq %rax, (%rdx)
movq %rax, (%rcx)
movl %eax, (%r8)
movl %eax, (%r9)
testq %rdi, %rdi
je 0xa1331
cmpl $0x0, 0x24(%rsp)
js 0xa1331
cmpl $0x0, 0x90(%rsp)
je 0xa1331
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
leaq 0x80(%rsp), %rbp
movq 0x10(%rbp), %rax
movq %rax, 0x10(%rsp)
movups (%rbp), %xmm0
movups %xmm0, (%rsp)
callq 0x558e2
testl %eax, %eax
je 0xa1340
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbp), %rax
movq %rax, 0x10(%rsp)
movupd (%rbp), %xmm0
movupd %xmm0, (%rsp)
callq 0x55918
movq %rax, %rbp
movl 0x24(%rsp), %ecx
movq %rcx, 0x38(%rsp)
imulq $0x340, %rcx, %rax      # imm = 0x340
movq %rax, 0x40(%rsp)
cmpl $0x2, 0x34(%rsp)
jne 0xa1385
movq %r13, %rdi
movl 0x24(%rsp), %esi
callq 0x2ed6a
jmp 0xa13bb
leaq 0x344e4(%rip), %rax     # 0xd5870
movq (%rax), %rax
movq 0x40(%rsp), %rcx
cmpl $0x0, 0x30f08(%rax,%rcx)
movq (%r13), %rax
je 0xa13ae
movq 0x38(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
jmp 0xa13bb
movq 0x38(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x28(%rsp)
movq %r13, %rdi
callq 0x2f33a
cltq
cmpl $0x0, (%rbp,%rax,4)
movq %rbx, %rax
cmoveq %r14, %rax
movq %r15, %rcx
cmoveq %r12, %rcx
incl (%rax)
movsd 0x28(%rsp), %xmm0
addsd (%rcx), %xmm0
movsd %xmm0, (%rcx)
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0xa1370
movq %rbp, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: left_and_right_sum_without_outliers
void left_and_right_sum_without_outliers(Instanceptr instances, Partition p, int fno, double* leftsum, double* rightsum, int* leftcount, int* rightcount, double llower, double lupper, double rlower, double rupper)
{
/* Last Changed 30.12.2003*/
 int *classassignments, i;
 double value;
 Instanceptr tmp;
 *leftsum = 0;
 *rightsum = 0;
 *leftcount = 0;
 *rightcount = 0;
 if (fno < 0 || instances == NULL || p.count == 0 || all_same_side(p))
   return;
 classassignments = find_class_assignments(p);
 tmp = instances;
 while (tmp)
  {
   if (current_dataset->features[fno].type == INTEGER)
     value = tmp->values[fno].intvalue;
   else
     value = tmp->values[fno].floatvalue;
   i = give_classno(tmp);
   if (classassignments[i]==LEFT && value >= llower && value <= lupper)
    {
     (*leftcount)++;
     (*leftsum) += value;
    }
   else
     if (value >= rlower && value <= rupper)
      {
       (*rightcount)++;
       (*rightsum) += value;
      }
   tmp = tmp->next;
  }
 safe_free(classassignments);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movsd %xmm3, 0x38(%rsp)
movsd %xmm2, 0x40(%rsp)
movsd %xmm1, 0x48(%rsp)
movsd %xmm0, 0x50(%rsp)
xorl %eax, %eax
movq %rax, (%rdx)
movq %rcx, 0x28(%rsp)
movq %rax, (%rcx)
movl %eax, (%r8)
movq %r9, 0x30(%rsp)
movl %eax, (%r9)
testq %rdi, %rdi
je 0xa148f
movl %esi, %r15d
testl %esi, %esi
js 0xa148f
cmpl $0x0, 0xa0(%rsp)
je 0xa148f
movq %r8, %r14
movq %rdx, %r12
movq %rdi, %r13
leaq 0x90(%rsp), %rbx
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x558e2
testl %eax, %eax
je 0xa149e
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movupd (%rbx), %xmm0
movupd %xmm0, (%rsp)
callq 0x55918
movq %rax, %rbp
movl %r15d, %ebx
imulq $0x340, %rbx, %r15      # imm = 0x340
leaq 0x343a7(%rip), %rax     # 0xd5870
movq (%rax), %rax
cmpl $0x0, 0x30f08(%rax,%r15)
movq (%r13), %rax
je 0xa14e2
movsd (%rax,%rbx,8), %xmm0
jmp 0xa14ea
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%rbx,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r13, %rdi
callq 0x2f33a
cltq
cmpl $0x0, (%rbp,%rax,4)
movsd 0x20(%rsp), %xmm1
jne 0xa1521
ucomisd 0x50(%rsp), %xmm1
jb 0xa1521
movsd 0x48(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movq %r14, %rcx
movq %r12, %rax
jae 0xa153f
ucomisd 0x40(%rsp), %xmm1
jb 0xa1549
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rax
jb 0xa1549
incl (%rcx)
addsd (%rax), %xmm1
movsd %xmm1, (%rax)
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0xa14c2
movq %rbp, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: left_and_right_variance_without_outliers
void left_and_right_variance_without_outliers(Instanceptr instances, Partition p, int fno, double* leftsum, double* rightsum, double leftmean, double rightmean, double llower, double lupper, double rlower, double rupper)
{
/* Last Changed 30.12.2003*/
 int *classassignments, i;
 double value, sub, added;
 Instanceptr tmp;
 *leftsum = 0;
 *rightsum = 0;
 if (fno < 0 || instances == NULL || p.count == 0 || all_same_side(p))
   return;
 classassignments = find_class_assignments(p);
 tmp = instances;
 while (tmp)
  {
   if (current_dataset->features[fno].type == INTEGER)
     value = tmp->values[fno].intvalue;
   else
     value = tmp->values[fno].floatvalue;
   i = give_classno(tmp);
   if (classassignments[i] == LEFT && value >= llower && value <= lupper)
    {
     sub = value - leftmean;
     added = sub * sub;
     (*leftsum) += added;
    }
   else
     if (value >= rlower && value <= rupper)
      {
       sub = value - rightmean;
       added = sub * sub;
       (*rightsum) += added;
      }
   tmp = tmp->next;
  }
 safe_free(classassignments);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movsd %xmm5, 0x30(%rsp)
movsd %xmm4, 0x38(%rsp)
movsd %xmm3, 0x48(%rsp)
movsd %xmm2, 0x50(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x40(%rsp)
xorl %eax, %eax
movq %rax, (%rdx)
movq %rcx, 0x20(%rsp)
movq %rax, (%rcx)
testq %rdi, %rdi
je 0xa15e7
movl %esi, %ebp
testl %esi, %esi
js 0xa15e7
cmpl $0x0, 0xa0(%rsp)
je 0xa15e7
movq %rdx, %r14
movq %rdi, %r15
leaq 0x90(%rsp), %rbx
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x558e2
testl %eax, %eax
je 0xa15f6
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movupd (%rbx), %xmm0
movupd %xmm0, (%rsp)
callq 0x55918
movq %rax, %r12
movl %ebp, %r13d
leaq 0x34256(%rip), %rbp     # 0xd5870
imulq $0x340, %r13, %rbx      # imm = 0x340
movq (%rbp), %rax
cmpl $0x0, 0x30f08(%rax,%rbx)
movq (%r15), %rax
je 0xa163a
movsd (%rax,%r13,8), %xmm0
jmp 0xa1643
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%r13,8), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
callq 0x2f33a
cltq
cmpl $0x0, (%r12,%rax,4)
movsd 0x18(%rsp), %xmm1
jne 0xa167d
ucomisd 0x50(%rsp), %xmm1
jb 0xa167d
movsd 0x48(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movsd 0x40(%rsp), %xmm0
movq %r14, %rax
jae 0xa169c
ucomisd 0x38(%rsp), %xmm1
jb 0xa16ac
movsd 0x30(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movsd 0x28(%rsp), %xmm0
movq 0x20(%rsp), %rax
jb 0xa16ac
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
addsd (%rax), %xmm1
movsd %xmm1, (%rax)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0xa1621
movq %r12, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: left_and_right_variance
void left_and_right_variance(Instanceptr instances, Partition p, int fno, double* leftsum, double* rightsum, double leftmean, double rightmean, int conditiontype)
{
/* Last Changed 09.02.2003*/
 int *classassignments, i;
 double value, sub, added;
 Instanceptr tmp;
 *leftsum = 0;
 *rightsum = 0;
 if (fno < 0 || instances == NULL || p.count == 0 || all_same_side(p))
   return;
 classassignments = find_class_assignments(p);
 tmp = instances;
 while (tmp)
  {
   if (conditiontype == HYBRID_CONDITION)
     value = real_feature(tmp, fno);
   else
     if (current_dataset->features[fno].type == INTEGER)
       value = tmp->values[fno].intvalue;
     else
       value = tmp->values[fno].floatvalue;
   i = give_classno(tmp);
   if (classassignments[i] == LEFT)
    {
     sub = value - leftmean;
     added = sub * sub;
     (*leftsum) += added;
    }
   else
    {
     sub = value - rightmean;
     added = sub * sub;
     (*rightsum) += added;
    }
   tmp = tmp->next;
  }
 safe_free(classassignments);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movsd %xmm1, 0x38(%rsp)
movsd %xmm0, 0x40(%rsp)
xorl %eax, %eax
movq %rax, (%rdx)
movq %rax, (%rcx)
testq %rdi, %rdi
je 0xa1735
movl %esi, %ebp
testl %esi, %esi
js 0xa1735
cmpl $0x0, 0x90(%rsp)
je 0xa1735
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
leaq 0x80(%rsp), %r13
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
callq 0x558e2
testl %eax, %eax
je 0xa1744
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movupd (%r13), %xmm0
movupd %xmm0, (%rsp)
callq 0x55918
movq %rax, %r13
movl %ebp, %ecx
movq %rcx, 0x28(%rsp)
imulq $0x340, %rcx, %rax      # imm = 0x340
movq %rax, 0x30(%rsp)
cmpl $0x2, %ebx
jne 0xa1784
movq %r12, %rdi
movl %ebp, %esi
callq 0x2ed6a
jmp 0xa17ba
leaq 0x340e5(%rip), %rax     # 0xd5870
movq (%rax), %rax
movq 0x30(%rsp), %rcx
cmpl $0x0, 0x30f08(%rax,%rcx)
movq (%r12), %rax
je 0xa17ad
movq 0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
jmp 0xa17ba
movq 0x28(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
callq 0x2f33a
cltq
cmpl $0x0, (%r13,%rax,4)
movsd 0x40(%rsp), %xmm0
je 0xa17de
movsd 0x38(%rsp), %xmm0
movq %r14, %rax
cmoveq %r15, %rax
movsd 0x20(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
addsd (%rax), %xmm1
movsd %xmm1, (%rax)
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0xa1773
movq %r13, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: find_split_for_partition
double find_split_for_partition(Instanceptr instances, Partition p, int fno, int conditiontype)
{
/*!Last Changed 29.12.2003*/
 int nl = 0, nr = 0;
 double ml, mr, sr, sl;
 if (p.count == 0 || instances == NULL || fno < 0 || all_same_side(p))
   return ISELL;
 left_and_right_sum(instances, p, fno, &ml, &mr, &nl, &nr, conditiontype);
 if (nl > 0)
   ml /= nl;
 else
   return ISELL;
 if (nr > 0)
   mr /= nr;
 else
   return ISELL;
 left_and_right_variance(instances, p, fno, &sl, &sr, ml, mr, conditiontype);
 if (nl > 1)
   sl /= (nl-1);
 else
   sl = 0;
 if (nr > 1)
   sr /= (nr-1);
 else
   sr = 0;
 return solve_for_ldt_second_order_equation(ml, mr, sl, sr, nl, nr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorl %eax, %eax
movl %eax, 0x24(%rsp)
movl %eax, 0x20(%rsp)
testl %esi, %esi
js 0xa1f95
movq %rdi, %r14
testq %rdi, %rdi
je 0xa1f95
cmpl $0x0, 0xa0(%rsp)
je 0xa1f95
movl %edx, %ebx
movl %esi, %ebp
leaq 0x90(%rsp), %r13
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
callq 0x558e2
testl %eax, %eax
je 0xa1fac
movsd 0x3d53(%rip), %xmm0     # 0xa5cf0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
movl %ebx, 0x18(%rsp)
leaq 0x50(%rsp), %rdx
leaq 0x48(%rsp), %rcx
leaq 0x24(%rsp), %r15
leaq 0x20(%rsp), %r9
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %r8
callq 0xa12bf
movl (%r15), %r15d
testl %r15d, %r15d
jle 0xa1f95
movl 0x20(%rsp), %r12d
testl %r12d, %r12d
jle 0xa1f95
movsd 0x50(%rsp), %xmm0
cvtsi2sd %r15d, %xmm1
divsd %xmm1, %xmm0
cvtsi2sd %r12d, %xmm2
movsd 0x48(%rsp), %xmm1
divsd %xmm2, %xmm1
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movupd (%r13), %xmm2
movupd %xmm2, (%rsp)
leaq 0x38(%rsp), %rdx
leaq 0x40(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movl %ebx, %r8d
callq 0xa16cf
xorpd %xmm3, %xmm3
xorpd %xmm2, %xmm2
cmpl $0x1, %r15d
je 0xa206d
leal -0x1(%r15), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x38(%rsp), %xmm2
divsd %xmm0, %xmm2
cmpl $0x1, %r12d
je 0xa2089
leal -0x1(%r12), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x40(%rsp), %xmm3
divsd %xmm0, %xmm3
movsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movl %r15d, %edi
movl %r12d, %esi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa181f
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: find_gain_for_partition
double find_gain_for_partition(Instanceptr instances, Partition p, int fno, double* split, int conditiontype)
{
 /*!Last Changed 29.12.2003*/
 /*!Last Changed 06.02.2003*/
 (*split) = find_split_for_partition(instances, p, fno, conditiontype);
 return information_gain_for_split(instances, fno, (*split), conditiontype);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq 0x1f0(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x1e0(%rsp), %xmm0
movups %xmm0, (%rsp)
movl %ecx, %edx
callq 0xa1f40
movsd %xmm0, (%r14)
leaq 0xe8(%rsp), %rcx
leaq 0x20(%rsp), %r14
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %r8d
callq 0xa11fa
movq %r14, %rdi
callq 0x1df2d
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: log_likelihood_for_uni_ldt_splits
double log_likelihood_for_uni_ldt_splits(Instanceptr data, int fno, double split, int conditiontype)
{
 /*!Last Changed 22.11.2004*/
 int counts[2][MAXCLASSES];
 double result = 0;
 find_counts_for_split(data, fno, split, counts[0], counts[1], conditiontype);
 result += log_likelihood_for_classification(counts[0]);
 result += log_likelihood_for_classification(counts[1]);
 return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %r8d
leaq 0xd8(%rsp), %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdx
movq %rbx, %rcx
callq 0xa11fa
movq %r14, %rdi
callq 0x1de84
xorpd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x1de84
addsd 0x8(%rsp), %xmm0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/univariatetree.c
// Function: create_ldtchildren
int create_ldtchildren(Decisionnodeptr node, C45_parameterptr p)
{
/*!Last Changed 23.01.2003*/
 int count, i;
 node->conditiontype = UNIVARIATE_CONDITION;
 if (!(can_be_divided(node, p)))
   return 1;
#ifdef MPI
 if (get_parameter_o("parallel") && get_parameter_i("proccount")>1)
  {
   switch (get_parameter_i("paralleltype"))
    {
     case 0:node->featureno = find_best_ldt_feature_mpi(node->instances,&(node->split));
            break;
     case 1:node->featureno = find_best_ldt_feature_mpi_rulebased(node);
            break;            
     case 2:Firsttime = 1;
            node->featureno = divide_data_to_find_best_feature(node->instances,&(node->split));
            break;
     case 3:create_ldtchildren_iterative(node);
            return 1;
            break;
    }
  }
 else
   node->featureno = find_best_ldt_feature(node->instances,&(node->split));
#else
 node->featureno = find_best_ldt_feature(node->instances,&(node->split)); 
#endif
 if (!(make_children(node)))
   return 1;
 switch (current_dataset->features[node->featureno].type)
  {
   case INTEGER:
   case REAL   :create_ldtchildren(node->left, p);
                create_ldtchildren(node->right, p);
                break;
   case STRING :count = current_dataset->features[node->featureno].valuecount;
                for (i = 0; i < count; i++)
                  create_ldtchildren(&(node->string[i]), p);
                break;
  }
 return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, 0x98(%rdi)
callq 0x1d053
testl %eax, %eax
je 0xa2b48
leaq 0x32dce(%rip), %r15     # 0xd5870
movq 0x20(%r14), %rdi
leaq 0x28(%r14), %rsi
callq 0xa2571
movl %eax, 0x30(%r14)
movq %r14, %rdi
callq 0xa0b60
testl %eax, %eax
je 0xa2b48
movq (%r15), %rax
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %edx
testl %edx, %edx
je 0xa2ae1
cmpl $0x2, %edx
jne 0xa2b0c
movq (%r14), %rdi
movq %rbx, %rsi
callq 0xa2a76
movq 0x8(%r14), %r14
movl $0x0, 0x98(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d053
testl %eax, %eax
jne 0xa2aa2
jmp 0xa2b48
cmpl $0x1, %edx
jne 0xa2b48
addq %rcx, %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq 0x18(%rax), %rax
testq %rax, %rax
jle 0xa2b48
imulq $0x160, %rax, %r15      # imm = 0x160
xorl %r12d, %r12d
movq 0x10(%r14), %rdi
addq %r12, %rdi
movq %rbx, %rsi
callq 0xa2a76
addq $0x160, %r12            # imm = 0x160
cmpq %r12, %r15
jne 0xa2b2d
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_univariate1
double decisiontree_vc_dimension_univariate1(double* testdata)
{
 /*Last Changed 01.10.2006*/
 const double mean[3] = {77.871900,3.053800,25.500000};
 const double variance[3] = {3066.280443,1.307234,208.458458};
 const double weights0[4] = {75.767898 ,45.757710 ,1.083343 ,3.206944 };
 double sum, weights_j, x_j, output;
 int i, j;
 double testdataconverted[3];
 for (i = 0; i < 3; i++)
   testdataconverted[i] = (testdata[i] - mean[i]) / sqrt(variance[i]);
 sum = weights0[0];
 for (j = 1; j < 4; j++)
  {
   weights_j = weights0[j];
   x_j = testdataconverted[j - 1];
   sum = sum + weights_j * x_j;
  }
 output = sum;
 return output;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0xf9fc(%rip), %r15      # 0xb2570
leaq 0xfa15(%rip), %r12      # 0xb2590
xorpd %xmm1, %xmm1
movsd (%rbx,%r14), %xmm2
subsd (%r14,%r15), %xmm2
movsd (%r14,%r12), %xmm0
ucomisd %xmm1, %xmm0
jb 0xa2b9d
sqrtsd %xmm0, %xmm0
jmp 0xa2bb2
movsd %xmm2, 0x8(%rsp)
callq 0x4300
movsd 0x8(%rsp), %xmm2
xorpd %xmm1, %xmm1
divsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsp,%r14)
addq $0x8, %r14
cmpq $0x18, %r14
jne 0xa2b7f
movsd 0xf8e9(%rip), %xmm0     # 0xb24b8
xorl %eax, %eax
leaq 0xfa18(%rip), %rcx      # 0xb25f0
movsd 0x8(%rcx,%rax,8), %xmm1
mulsd 0x10(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x3, %rax
jne 0xa2bd8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_linear1
double decisiontree_vc_dimension_linear1(double* testdata)
{
 /*Last Changed 01.10.2006*/
 const double mean[3] = {267.750000,10.500000,25.500000};
 const double variance[3] = {51556.243744,33.283283,208.458458};
 const double weights0[4] = {85.843669 ,47.643896 ,2.714944 ,11.436310 };
 double sum, weights_j, x_j, output;
 int i, j;
 double testdataconverted[3];
 for (i = 0; i < 3; i++)
   testdataconverted[i] = (testdata[i] - mean[i]) / sqrt(variance[i]);
 sum = weights0[0];
 for (j = 1; j < 4; j++)
  {
   weights_j = weights0[j];
   x_j = testdataconverted[j - 1];
   sum = sum + weights_j * x_j;
  }
 output = sum;
 return output;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0xf99b(%rip), %r15      # 0xb25b0
leaq 0xf9b4(%rip), %r12      # 0xb25d0
xorpd %xmm1, %xmm1
movsd (%rbx,%r14), %xmm2
subsd (%r14,%r15), %xmm2
movsd (%r14,%r12), %xmm0
ucomisd %xmm1, %xmm0
jb 0xa2c3e
sqrtsd %xmm0, %xmm0
jmp 0xa2c53
movsd %xmm2, 0x8(%rsp)
callq 0x4300
movsd 0x8(%rsp), %xmm2
xorpd %xmm1, %xmm1
divsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsp,%r14)
addq $0x8, %r14
cmpq $0x18, %r14
jne 0xa2c20
movsd 0xf850(%rip), %xmm0     # 0xb24c0
xorl %eax, %eax
leaq 0xf997(%rip), %rcx      # 0xb2610
movsd 0x8(%rcx,%rax,8), %xmm1
mulsd 0x10(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x3, %rax
jne 0xa2c79
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_quadratic1
double decisiontree_vc_dimension_quadratic1(double* testdata)
{
 /*Last Changed 01.10.2006*/
 const double mean[5] = {596.750000,38.500000,85.250000,5.500000,15.500000};
 const double variance[5] = {443780.422241,1054.565217,4882.629599,8.277592,75.167224};
 const double weights0[6] = {92.533543 ,1.971860 ,12.871168 ,50.327602 ,6.863087 ,4.789140 };
 double sum, weights_j, x_j, output;
 int i, j;
 double testdataconverted[5];
 for (i = 0; i < 5; i++)
   testdataconverted[i] = (testdata[i] - mean[i]) / sqrt(variance[i]);
 sum = weights0[0];
 for (j = 1; j < 6; j++)
  {
   weights_j = weights0[j];
   x_j = testdataconverted[j - 1];
   sum = sum + weights_j * x_j;
  }
 output = sum;
 return output;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movaps 0xf85e(%rip), %xmm0     # 0xb2510
movaps %xmm0, 0x40(%rsp)
movaps 0xf862(%rip), %xmm0     # 0xb2520
movaps %xmm0, 0x50(%rsp)
movabsq $0x402f000000000000, %rax # imm = 0x402F000000000000
movq %rax, 0x60(%rsp)
movaps 0xf857(%rip), %xmm0     # 0xb2530
movaps %xmm0, 0x10(%rsp)
movaps 0xf85b(%rip), %xmm0     # 0xb2540
movaps %xmm0, 0x20(%rsp)
movabsq $0x4052cab3cc4ac6ce, %rax # imm = 0x4052CAB3CC4AC6CE
movq %rax, 0x30(%rsp)
movaps 0xf850(%rip), %xmm0     # 0xb2550
movups %xmm0, 0x78(%rsp)
movapd 0xf853(%rip), %xmm0     # 0xb2560
movupd %xmm0, 0x88(%rsp)
movabsq $0x4013281450efdc9c, %rax # imm = 0x4013281450EFDC9C
movq %rax, 0x98(%rsp)
xorl %r14d, %r14d
xorpd %xmm1, %xmm1
movsd (%rbx,%r14,8), %xmm2
subsd 0x40(%rsp,%r14,8), %xmm2
movsd 0x10(%rsp,%r14,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0xa2d4f
sqrtsd %xmm0, %xmm0
jmp 0xa2d64
movsd %xmm2, 0x8(%rsp)
callq 0x4300
movsd 0x8(%rsp), %xmm2
xorpd %xmm1, %xmm1
divsd %xmm0, %xmm2
movsd %xmm2, 0xa0(%rsp,%r14,8)
incq %r14
cmpq $0x5, %r14
jne 0xa2d2f
movsd 0xf745(%rip), %xmm0     # 0xb24c8
movl $0x1, %eax
movsd 0x70(%rsp,%rax,8), %xmm1
mulsd 0x98(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x6, %rax
jne 0xa2d88
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_preestimation_discrete
int decisiontree_vc_dimension_preestimation_discrete(Datasetptr d, int nodecount)
{
 /*Last Changed 01.10.2006*/
 /*Last Changed 23.05.2006*/
 if (nodecount == 0 || (d->featurecount - log2(nodecount)) < 0)
   return 1;
 return (int) (log2(d->featurecount - log2(nodecount) + 2) * nodecount);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl $0x1, %ebx
testl %esi, %esi
je 0xa2e2c
movq %rdi, %r14
cvtsi2sdl 0x1bc(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x39bdc
ucomisd 0x8(%rsp), %xmm0
ja 0xa2e2c
xorps %xmm0, %xmm0
cvtsi2sdl 0x1bc(%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x39bdc
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
addsd 0x3227(%rip), %xmm1     # 0xa6040
movapd %xmm1, %xmm0
callq 0x39bdc
mulsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_preestimation
int decisiontree_vc_dimension_preestimation(Datasetptr d, int nodecount, MODEL_TYPE nodetype)
{
 /*Last Changed 06.11.2007*/
 int dim = d->multifeaturecount - 1;
 switch (nodetype)
  {
   case MODEL_UNI:return (nodecount + 1) * (log2(dim + 1) + 1) / 2;
                  break;
   case MODEL_LIN:return nodecount * (dim + 1);
                  break;
   case MODEL_QUA:return nodecount * (((dim + 1) * (dim + 2)) / 2);
                  break;
  }
 return 1;
}

// Assembly:
movl 0x1c0(%rdi), %ecx
cmpl $0x2, %edx
je 0xa2e8b
cmpl $0x1, %edx
je 0xa2e85
movl $0x1, %eax
testl %edx, %edx
jne 0xa2e9d
pushq %rax
incl %esi
cvtsi2sd %esi, %xmm0
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
callq 0x39bdc
addsd 0x26b1(%rip), %xmm0     # 0xa5520
mulsd (%rsp), %xmm0
mulsd 0x2e9c(%rip), %xmm0     # 0xa5d18
cvttsd2si %xmm0, %eax
addq $0x8, %rsp
retq
imull %esi, %ecx
movl %ecx, %eax
retq
leal 0x1(%rcx), %edx
imull %ecx, %edx
movl %edx, %eax
shrl $0x1f, %eax
addl %edx, %eax
sarl %eax
imull %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_discrete_old
double decisiontree_vc_dimension_discrete_old(Datasetptr d, Decisionnodeptr rootnode)
{
 /*!Last Changed 04.11.2009*/
 int D, N;
 if (rootnode->featureno == LEAF_NODE)
   return 1;
 D = d->featurecount - 1;
 N = decisiontree_node_count(rootnode);
 return 0.6734 + 1.0117 * N + 0.1939 * log2(D - log2(N)) * N + 0.7147 * log2(D - log2(N));
}

// Assembly:
cmpl $-0x1, 0x30(%rsi)
je 0xa2f54
pushq %rbx
subq $0x20, %rsp
movl 0x1bc(%rdi), %ebx
decl %ebx
movq %rsi, %rdi
callq 0x1cce7
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xf601(%rip), %xmm1     # 0xb24d0
mulsd %xmm0, %xmm1
addsd 0xf5fd(%rip), %xmm1     # 0xb24d8
movsd %xmm1, 0x8(%rsp)
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
movsd %xmm1, 0x10(%rsp)
callq 0x39bdc
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x39bdc
mulsd 0xf5d2(%rip), %xmm0     # 0xb24e0
movsd 0x18(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x39bdc
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x39bdc
mulsd 0xf5a0(%rip), %xmm0     # 0xb24e8
addsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
movsd 0x25c4(%rip), %xmm0     # 0xa5520
retq