LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
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 0x3191e3(%rip), %r13    # 0x3a9fa4
cmpl %ebp, %r15d
jge 0x90e0c
cmpl $0x0, (%r13)
jne 0x90de0
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x91271
testl %eax, %eax
jne 0x90e0c
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x91140
movl %eax, %r12d
leal -0x1(%r12), %edx
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %ecx
callq 0x90da5
incl %r12d
movl %r12d, %r15d
jmp 0x90dc1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0x31910d(%rip), %rax    # 0x3a9fa4
cmpl $0x0, (%rax)
je 0x90ee6
movq %r14, %rdi
movl %ebp, %esi
callq 0x2aea2
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2aea2
ucomisd 0x8(%rsp), %xmm0
ja 0x90f2d
movq %r14, %rdi
movl %ebp, %esi
callq 0x2aea2
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2aea2
xorl %eax, %eax
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jmp 0x90f20
leaq 0x3c983(%rip), %rax     # 0xcd870
movq (%rax), %rcx
movslq %ebp, %rax
imulq $0x340, %rax, %rdx      # imm = 0x340
cmpl $0x0, 0x30f08(%rcx,%rdx)
movq (%r14), %rcx
movq (%rbx), %rdx
je 0x90f25
movsd (%rcx,%rax,8), %xmm0
movsd (%rdx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x90f2d
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
jmp 0x90f30
movl (%rdx,%rax,8), %edx
cmpl %edx, (%rcx,%rax,8)
jge 0x90f39
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
setg %al
movzbl %al, %eax
jmp 0x90f30
// File: /workspace/github_c_makefile_star2_O2/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 $0x68, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
leal -0x1(%r12), %r13d
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
movl %r12d, %edx
movl %r15d, %ecx
movl %ebp, %r8d
callq 0x90f41
movslq %r12d, %r14
movslq %r15d, %r12
imulq $0x30, %r14, %r15
addq %rbx, %r15
cmpq %r12, %r14
jge 0x91200
movq %r15, %rdi
leaq 0x38(%rsp), %rsi
movl %ebp, %edx
callq 0x90e80
testl %eax, %eax
jg 0x911f7
incl %r13d
movslq %r13d, %rax
imulq $0x30, %rax, %rax
movups (%rbx,%rax), %xmm0
movups 0x10(%rbx,%rax), %xmm1
movups 0x20(%rbx,%rax), %xmm2
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rbx,%rax)
movups %xmm1, 0x10(%rbx,%rax)
movups %xmm0, (%rbx,%rax)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
incq %r14
addq $0x30, %r15
jmp 0x91181
incl %r13d
movslq %r13d, %rax
imulq $0x30, %rax, %rcx
movups (%rbx,%rcx), %xmm0
movups 0x10(%rbx,%rcx), %xmm1
movups 0x20(%rbx,%rcx), %xmm2
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
imulq $0x30, %r12, %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 (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x20(%rbx,%rdx)
movups %xmm1, 0x10(%rbx,%rdx)
movups %xmm0, (%rbx,%rdx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3c5f8(%rip), %rax     # 0xcd870
movq (%rax), %rax
movslq %ecx, %rcx
imulq $0x340, %rcx, %r8       # imm = 0x340
cmpl $0x0, 0x30f08(%rax,%r8)
movslq %esi, %rsi
movslq %edx, %rdx
je 0x912c6
imulq $0x30, %rsi, %rax
addq %rax, %rdi
decq %rsi
pushq $0x1
popq %rax
incq %rsi
cmpq %rdx, %rsi
jge 0x912f2
movq (%rdi), %r8
movq 0x30(%rdi), %r9
addq $0x30, %rdi
movsd (%r8,%rcx,8), %xmm0
ucomisd (%r9,%rcx,8), %xmm0
jbe 0x912a3
jmp 0x912f0
imulq $0x30, %rsi, %rax
addq %rax, %rdi
decq %rsi
pushq $0x1
popq %rax
incq %rsi
cmpq %rdx, %rsi
jge 0x912f2
movq (%rdi), %r8
movq 0x30(%rdi), %r9
addq $0x30, %rdi
movl (%r9,%rcx,8), %r9d
cmpl (%r8,%rcx,8), %r9d
jge 0x912d3
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
andl $0x0, (%rdx)
movslq %esi, %r15
xorl %ecx, %ecx
leaq 0x3c55b(%rip), %r12     # 0xcd870
imulq $0x340, %r15, %r13      # imm = 0x340
xorl %eax, %eax
testq %r14, %r14
je 0x91399
movq (%r12), %rdx
cmpl $0x0, 0x30f08(%rdx,%r13)
movq (%r14), %rdx
je 0x9133d
movsd (%rdx,%r15,8), %xmm1
jmp 0x91343
cvtsi2sdl (%rdx,%r15,8), %xmm1
testl %ecx, %ecx
movl $0x0, %edx
cmovgl %ecx, %edx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x91366
movsd (%rax,%rsi,8), %xmm0
incq %rsi
ucomisd %xmm1, %xmm0
jne 0x9134f
jp 0x9134f
jmp 0x91393
leal 0x1(%rcx), %edx
movl %edx, (%rbx)
movslq %ecx, %rcx
leaq 0x8(,%rcx,8), %rsi
movq %rax, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0x34f30
movslq (%rbx), %rcx
movsd 0x8(%rsp), %xmm0
movsd %xmm0, -0x8(%rax,%rcx,8)
movq 0x10(%r14), %r14
jmp 0x9131e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %r14
movq %rdi, %r15
movabsq $0x41dfffffffc00000, %rax # imm = 0x41DFFFFFFFC00000
movq %rsp, %r12
movq %rax, (%r12)
pushq $-0x1
popq %rbp
xorl %ebx, %ebx
leaq 0x3c277(%rip), %r13     # 0xcd870
movq (%r13), %rax
cmpl 0x1bc(%rax), %ebx
jge 0x91630
movq %r15, %rdi
movl %ebx, %esi
movq %r14, %rdx
movq %r12, %rcx
callq 0x913a7
testl %eax, %eax
je 0x9162c
movsd (%rsp), %xmm0
ucomisd 0x46f2(%rip), %xmm0     # 0x95d18
movl %ebx, %ebp
jne 0x9162c
jnp 0x91646
incl %ebx
jmp 0x915f9
movsd (%rsp), %xmm0
ucomisd 0x46bb(%rip), %xmm0     # 0x95cf8
pushq $-0x1
popq %rbx
cmovnel %ebp, %ebx
cmovpl %ebp, %ebx
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_O2/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 0x3bf11(%rip), %rax     # 0xcd870
movq (%rax), %rax
leaq 0x30f08(%rax), %rsi
xorl %edi, %edi
testl %edx, %edx
cmovlel %edi, %ebx
pushq $0x1
popq %rdx
cmpq %rdi, %rbx
je 0x91990
movslq (%r14,%rdi,4), %r8
imulq $0x340, %r8, %r8        # imm = 0x340
imull 0x18(%rsi,%r8), %edx
movl %edx, (%rcx)
incq %rdi
jmp 0x91973
movl 0x10(%rax), %ecx
leaq 0x724a(%rip), %r8       # 0x98be4
pushq $0x8
popq %rdi
pushq $0x4
popq %rsi
pushq $0x7
popq %r9
callq 0x3509c
movq %rax, %r12
movl $0x30f08, %ebp          # imm = 0x30F08
pushq $0x1
popq %r13
testq %r15, %r15
je 0x91a11
movq %r15, %rdi
callq 0x2b47e
leaq 0x3bea7(%rip), %rcx     # 0xcd870
movq (%rcx), %rcx
addq %rbp, %rcx
xorl %edx, %edx
xorl %esi, %esi
movl %r13d, %edi
cmpq %rdx, %rbx
je 0x919ff
movq (%r15), %r8
movslq (%r14,%rdx,4), %r9
movl (%r8,%r9,8), %r8d
imull %edi, %r8d
addl %r8d, %esi
imulq $0x340, %r9, %r8        # imm = 0x340
imull 0x18(%rcx,%r8), %edi
incq %rdx
jmp 0x919d6
movslq %esi, %rcx
movq (%r12,%rcx,8), %rcx
cltq
incl (%rcx,%rax,4)
movq 0x10(%r15), %r15
jmp 0x919b5
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_O2/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
pushq %rax
movl %edi, %ebx
callq 0x3463b
xorl %r14d, %r14d
testl %ebx, %ebx
movl $0x0, %r12d
cmovgl %ebx, %r12d
movq %rax, %r15
pushq $0x1
popq %rbp
pushq $0x1
popq %r13
xorl %eax, %eax
movq %rbp, %rdx
xorl %ecx, %ecx
cmpq %r12, %rax
je 0x91a7a
movq %rdx, %rsi
cmpl %ebx, %esi
jge 0x91a72
movl (%r15,%rax,4), %edi
cmpl (%r15,%rsi,4), %edi
cmovel %r13d, %ecx
incq %rsi
jmp 0x91a5d
incq %rax
incq %rdx
jmp 0x91a55
leaq 0x3bdef(%rip), %rax     # 0xcd870
movq (%rax), %rax
xorl %edx, %edx
cmpq %rdx, %r12
je 0x91a9e
movl (%r15,%rdx,4), %esi
cmpl 0x1407128(%rax), %esi
cmovel %r13d, %ecx
incq %rdx
jmp 0x91a86
testl %ecx, %ecx
jne 0x91b0d
movq %r14, (%rsp)
xorl %ebp, %ebp
movl %r13d, %r14d
leaq 0x3bdbe(%rip), %rax     # 0xcd870
movq (%rax), %rax
leaq 0x30f08(%rax), %rcx
cmpq %rbp, %r12
je 0x91ade
movslq (%r15,%rbp,4), %rax
imulq $0x340, %rax, %rax      # imm = 0x340
movl 0x18(%rcx,%rax), %edi
callq 0x34dbc
imull %eax, %r14d
incq %rbp
jmp 0x91aab
xorl %esi, %esi
movl %r13d, %edx
pushq $0x1
popq %rbp
cmpq %rsi, %r12
je 0x91b00
movslq (%r15,%rsi,4), %rdi
imulq $0x340, %rdi, %rdi      # imm = 0x340
imull 0x18(%rcx,%rdi), %edx
incq %rsi
jmp 0x91ae6
decl %edx
imull %r14d, %edx
movq (%rsp), %r14
addl %edx, %r14d
movl 0x1bc(%rax), %edx
decl %edx
movq %r15, %rdi
movl %ebx, %esi
callq 0x34ae8
testl %eax, %eax
jne 0x91a4e
movq %r15, %rdi
callq 0x34ff7
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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
leaq 0x3bd1a(%rip), %r15     # 0xcd870
andl $0x0, 0x98(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1abee
testl %eax, %eax
je 0x91bfb
movq 0x20(%r14), %rdi
leaq 0x28(%r14), %rsi
callq 0x915cb
movl %eax, 0x30(%r14)
movq %r14, %rdi
callq 0x91657
testl %eax, %eax
je 0x91bfb
movq (%r15), %rax
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %edx
testl %edx, %edx
je 0x91bac
cmpl $0x2, %edx
jne 0x91bbd
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x91b41
movq 0x8(%r14), %r14
jmp 0x91b56
cmpl $0x1, %edx
jne 0x91bfb
addq %rcx, %rax
addq $0x30f08, %rax          # imm = 0x30F08
movl 0x18(%rax), %eax
xorl %r15d, %r15d
testl %eax, %eax
cmovlel %r15d, %eax
imulq $0x160, %rax, %r12      # imm = 0x160
cmpq %r15, %r12
je 0x91bfb
movq 0x10(%r14), %rdi
addq %r15, %rdi
movq %rbx, %rsi
callq 0x91b41
addq $0x160, %r15            # imm = 0x160
jmp 0x91bde
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0x32, %rax
je 0x91c74
andl $0x0, (%r15,%rax,4)
andl $0x0, (%r14,%rax,4)
incq %rax
jmp 0x91c5f
movslq 0x4(%rsp), %r13
imulq $0x340, %r13, %rbp      # imm = 0x340
testq %r12, %r12
je 0x91ceb
cmpl $0x2, %ebx
jne 0x91c98
movq %r12, %rdi
movl 0x4(%rsp), %esi
callq 0x2aea2
jmp 0x91cbe
leaq 0x3bbd1(%rip), %rax     # 0xcd870
movq (%rax), %rax
cmpl $0x0, 0x30f08(%rax,%rbp)
movq (%r12), %rax
je 0x91cb8
movsd (%rax,%r13,8), %xmm0
jmp 0x91cbe
cvtsi2sdl (%rax,%r13,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x2b47e
movsd 0x10(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
cltq
movq %r15, %rcx
cmovbq %r14, %rcx
incl (%rcx,%rax,4)
movq 0x10(%r12), %r12
jmp 0x91c80
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0x98(%rsp), %eax
movl %eax, 0x34(%rsp)
andq $0x0, (%rdx)
movl %esi, 0x24(%rsp)
andq $0x0, (%rcx)
andl $0x0, (%r8)
andl $0x0, (%r9)
testq %rdi, %rdi
je 0x91d6e
cmpl $0x0, 0x24(%rsp)
js 0x91d6e
cmpl $0x0, 0x90(%rsp)
je 0x91d6e
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 0x4dbfb
testl %eax, %eax
je 0x91d7d
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 0x4dc2f
movq %rax, %rbp
movl 0x24(%rsp), %ecx
movq %rcx, 0x38(%rsp)
imulq $0x340, %rcx, %rax      # imm = 0x340
movq %rax, 0x40(%rsp)
testq %r13, %r13
je 0x91e3a
cmpl $0x2, 0x34(%rsp)
jne 0x91dcb
movq %r13, %rdi
movl 0x24(%rsp), %esi
callq 0x2aea2
jmp 0x91dfe
leaq 0x3ba9e(%rip), %rax     # 0xcd870
movq (%rax), %rax
movq 0x40(%rsp), %rcx
cmpl $0x0, 0x30f08(%rax,%rcx)
movq (%r13), %rax
je 0x91df4
movq 0x38(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
jmp 0x91dfe
movq 0x38(%rsp), %rcx
cvtsi2sdl (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x28(%rsp)
movq %r13, %rdi
callq 0x2b47e
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
jmp 0x91dad
movq %rbp, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, (%rdx)
movq %rcx, 0x28(%rsp)
andq $0x0, (%rcx)
andl $0x0, (%r8)
movq %r9, 0x30(%rsp)
andl $0x0, (%r9)
testq %rdi, %rdi
je 0x91ed0
movl %esi, %ebx
testl %esi, %esi
js 0x91ed0
cmpl $0x0, 0xa0(%rsp)
je 0x91ed0
movq %r8, %r14
movq %rdx, %r12
movq %rdi, %r13
leaq 0x90(%rsp), %r15
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x4dbfb
testl %eax, %eax
je 0x91edf
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movupd (%r15), %xmm0
movupd %xmm0, (%rsp)
callq 0x4dc2f
movq %rax, %rbp
movl %ebx, %ebx
imulq $0x340, %rbx, %r15      # imm = 0x340
testq %r13, %r13
je 0x91f99
leaq 0x3b95d(%rip), %rax     # 0xcd870
movq (%rax), %rax
cmpl $0x0, 0x30f08(%rax,%r15)
movq (%r13), %rax
je 0x91f2c
movsd (%rax,%rbx,8), %xmm0
jmp 0x91f31
cvtsi2sdl (%rax,%rbx,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r13, %rdi
callq 0x2b47e
cltq
cmpl $0x0, (%rbp,%rax,4)
movsd 0x20(%rsp), %xmm1
jne 0x91f68
ucomisd 0x50(%rsp), %xmm1
jb 0x91f68
movsd 0x48(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movq %r14, %rcx
movq %r12, %rax
jae 0x91f86
ucomisd 0x40(%rsp), %xmm1
jb 0x91f90
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rax
jb 0x91f90
incl (%rcx)
addsd (%rax), %xmm1
movsd %xmm1, (%rax)
movq 0x10(%r13), %r13
jmp 0x91f03
movq %rbp, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, (%rdx)
movq %rcx, 0x20(%rsp)
andq $0x0, (%rcx)
testq %rdi, %rdi
je 0x9202a
movl %esi, %ebp
testl %esi, %esi
js 0x9202a
cmpl $0x0, 0xa0(%rsp)
je 0x9202a
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 0x4dbfb
testl %eax, %eax
je 0x92039
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 0x4dc2f
movq %rax, %r12
movl %ebp, %r13d
leaq 0x3b813(%rip), %rbp     # 0xcd870
imulq $0x340, %r13, %rbx      # imm = 0x340
testq %r15, %r15
je 0x920fe
movq (%rbp), %rax
cmpl $0x0, 0x30f08(%rax,%rbx)
movq (%r15), %rax
je 0x92086
movsd (%rax,%r13,8), %xmm0
jmp 0x9208c
cvtsi2sdl (%rax,%r13,8), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
callq 0x2b47e
cltq
cmpl $0x0, (%r12,%rax,4)
movsd 0x18(%rsp), %xmm1
jne 0x920c6
ucomisd 0x50(%rsp), %xmm1
jb 0x920c6
movsd 0x48(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movsd 0x40(%rsp), %xmm0
movq %r14, %rax
jae 0x920e5
ucomisd 0x38(%rsp), %xmm1
jb 0x920f5
movsd 0x30(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movsd 0x28(%rsp), %xmm0
movq 0x20(%rsp), %rax
jb 0x920f5
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
addsd (%rax), %xmm1
movsd %xmm1, (%rax)
movq 0x10(%r15), %r15
jmp 0x92064
movq %r12, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, (%rdx)
andq $0x0, (%rcx)
testq %rdi, %rdi
je 0x9217a
movl %esi, %ebp
testl %esi, %esi
js 0x9217a
cmpl $0x0, 0x90(%rsp)
je 0x9217a
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 0x4dbfb
testl %eax, %eax
je 0x92189
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 0x4dc2f
movq %rax, %r13
movl %ebp, %ecx
movq %rcx, 0x28(%rsp)
imulq $0x340, %rcx, %rax      # imm = 0x340
movq %rax, 0x30(%rsp)
testq %r12, %r12
je 0x92250
cmpl $0x2, %ebx
jne 0x921d2
movq %r12, %rdi
movl %ebp, %esi
callq 0x2aea2
jmp 0x92205
leaq 0x3b697(%rip), %rax     # 0xcd870
movq (%rax), %rax
movq 0x30(%rsp), %rcx
cmpl $0x0, 0x30f08(%rax,%rcx)
movq (%r12), %rax
je 0x921fb
movq 0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
jmp 0x92205
movq 0x28(%rsp), %rcx
cvtsi2sdl (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
callq 0x2b47e
cltq
cmpl $0x0, (%r13,%rax,4)
movsd 0x40(%rsp), %xmm0
je 0x92229
movsd 0x38(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
subsd %xmm0, %xmm1
movq %r14, %rax
cmoveq %r15, %rax
mulsd %xmm1, %xmm1
addsd (%rax), %xmm1
movsd %xmm1, (%rax)
movq 0x10(%r12), %r12
jmp 0x921b8
movq %r13, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x24(%rsp)
andl $0x0, 0x20(%rsp)
testl %esi, %esi
js 0x929bb
movq %rdi, %r14
testq %rdi, %rdi
je 0x929bb
cmpl $0x0, 0xa0(%rsp)
je 0x929bb
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 0x4dbfb
testl %eax, %eax
je 0x929d2
movsd 0x3335(%rip), %xmm0     # 0x95cf8
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 0x91cfa
movl (%r15), %r15d
testl %r15d, %r15d
jle 0x929bb
movl 0x20(%rsp), %r12d
testl %r12d, %r12d
jle 0x929bb
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 0x92114
xorpd %xmm3, %xmm3
xorpd %xmm2, %xmm2
cmpl $0x1, %r15d
je 0x92a90
leal -0x1(%r15), %eax
cvtsi2sd %eax, %xmm0
movsd 0x38(%rsp), %xmm2
divsd %xmm0, %xmm2
cmpl $0x1, %r12d
je 0x92aa9
leal -0x1(%r12), %eax
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 0x92266
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x3a421(%rip), %r15     # 0xcd870
andl $0x0, 0x98(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1abee
testl %eax, %eax
je 0x934f4
movq 0x20(%r14), %rdi
leaq 0x28(%r14), %rsi
callq 0x92f52
movl %eax, 0x30(%r14)
movq %r14, %rdi
callq 0x91657
testl %eax, %eax
je 0x934f4
movq (%r15), %rax
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %edx
testl %edx, %edx
je 0x934a5
cmpl $0x2, %edx
jne 0x934b6
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x9343a
movq 0x8(%r14), %r14
jmp 0x9344f
cmpl $0x1, %edx
jne 0x934f4
addq %rcx, %rax
addq $0x30f08, %rax          # imm = 0x30F08
movl 0x18(%rax), %eax
xorl %r15d, %r15d
testl %eax, %eax
cmovlel %r15d, %eax
imulq $0x160, %rax, %r12      # imm = 0x160
cmpq %r15, %r12
je 0x934f4
movq 0x10(%r14), %rdi
addq %r15, %rdi
movq %rbx, %rsi
callq 0x9343a
addq $0x160, %r15            # imm = 0x160
jmp 0x934d7
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xefb4(%rip), %r15      # 0xa24d0
leaq 0xefcd(%rip), %r12      # 0xa24f0
xorpd %xmm1, %xmm1
cmpq $0x18, %r14
je 0x93571
movsd (%rbx,%r14), %xmm2
subsd (%r14,%r15), %xmm2
movsd (%r14,%r12), %xmm0
ucomisd %xmm1, %xmm0
jb 0x9354b
sqrtsd %xmm0, %xmm0
jmp 0x93560
movsd %xmm2, 0x8(%rsp)
callq 0x4300
movsd 0x8(%rsp), %xmm2
xorpd %xmm1, %xmm1
divsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsp,%r14)
addq $0x8, %r14
jmp 0x93527
movsd 0xee9f(%rip), %xmm0     # 0xa2418
xorl %eax, %eax
leaq 0xefce(%rip), %rcx      # 0xa2550
cmpq $0x3, %rax
je 0x9359d
movsd 0x8(%rcx,%rax,8), %xmm1
mulsd 0x10(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x93582
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xef4f(%rip), %r15      # 0xa2510
leaq 0xef68(%rip), %r12      # 0xa2530
xorpd %xmm1, %xmm1
cmpq $0x18, %r14
je 0x93616
movsd (%rbx,%r14), %xmm2
subsd (%r14,%r15), %xmm2
movsd (%r14,%r12), %xmm0
ucomisd %xmm1, %xmm0
jb 0x935f0
sqrtsd %xmm0, %xmm0
jmp 0x93605
movsd %xmm2, 0x8(%rsp)
callq 0x4300
movsd 0x8(%rsp), %xmm2
xorpd %xmm1, %xmm1
divsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsp,%r14)
addq $0x8, %r14
jmp 0x935cc
movsd 0xee02(%rip), %xmm0     # 0xa2420
xorl %eax, %eax
leaq 0xef49(%rip), %rcx      # 0xa2570
cmpq $0x3, %rax
je 0x93642
movsd 0x8(%rcx,%rax,8), %xmm1
mulsd 0x10(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x93627
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xee0e(%rip), %xmm0     # 0xa2470
movaps %xmm0, 0x40(%rsp)
movaps 0xee12(%rip), %xmm0     # 0xa2480
movaps %xmm0, 0x50(%rsp)
movabsq $0x402f000000000000, %rax # imm = 0x402F000000000000
movq %rax, 0x60(%rsp)
movaps 0xee07(%rip), %xmm0     # 0xa2490
movaps %xmm0, 0x10(%rsp)
movaps 0xee0b(%rip), %xmm0     # 0xa24a0
movaps %xmm0, 0x20(%rsp)
movabsq $0x4052cab3cc4ac6ce, %rax # imm = 0x4052CAB3CC4AC6CE
movq %rax, 0x30(%rsp)
movaps 0xee00(%rip), %xmm0     # 0xa24b0
movups %xmm0, 0x78(%rsp)
movapd 0xee03(%rip), %xmm0     # 0xa24c0
movupd %xmm0, 0x88(%rsp)
movabsq $0x4013281450efdc9c, %rax # imm = 0x4013281450EFDC9C
movq %rax, 0x98(%rsp)
xorl %r14d, %r14d
xorpd %xmm1, %xmm1
cmpq $0x5, %r14
je 0x9372d
movsd (%rbx,%r14,8), %xmm2
subsd 0x40(%rsp,%r14,8), %xmm2
movsd 0x10(%rsp,%r14,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x93705
sqrtsd %xmm0, %xmm0
jmp 0x9371a
movsd %xmm2, 0x8(%rsp)
callq 0x4300
movsd 0x8(%rsp), %xmm2
xorpd %xmm1, %xmm1
divsd %xmm0, %xmm2
movsd %xmm2, 0xa0(%rsp,%r14,8)
incq %r14
jmp 0x936df
movsd 0xecf3(%rip), %xmm0     # 0xa2428
pushq $0x1
popq %rax
cmpq $0x6, %rax
je 0x93756
movsd 0x70(%rsp,%rax,8), %xmm1
mulsd 0x98(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x93738
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rbx
testl %esi, %esi
je 0x937d6
movq %rdi, %r14
cvtsi2sdl 0x1bc(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
cvtsi2sd %esi, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x34d77
ucomisd 0x8(%rsp), %xmm0
ja 0x937d6
cvtsi2sdl 0x1bc(%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x34d77
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
addsd 0x2885(%rip), %xmm1     # 0x96048
movapd %xmm1, %xmm0
callq 0x34d77
mulsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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), %eax
cmpl $0x2, %edx
je 0x93827
cmpl $0x1, %edx
je 0x93835
testl %edx, %edx
jne 0x93839
pushq %rax
incl %esi
cvtsi2sd %esi, %xmm0
movsd %xmm0, (%rsp)
cvtsi2sd %eax, %xmm0
callq 0x34d77
addsd 0x1d0f(%rip), %xmm0     # 0x95520
mulsd (%rsp), %xmm0
mulsd 0x2502(%rip), %xmm0     # 0x95d20
cvttsd2si %xmm0, %eax
addq $0x8, %rsp
retq
leal 0x1(%rax), %ecx
imull %eax, %ecx
pushq $0x2
popq %rdi
movl %ecx, %eax
cltd
idivl %edi
imull %esi, %eax
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x938f0
pushq %rbx
subq $0x20, %rsp
movl 0x1bc(%rdi), %ebx
decl %ebx
movq %rsi, %rdi
callq 0x1a8d0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xebc2(%rip), %xmm1     # 0xa2430
mulsd %xmm0, %xmm1
addsd 0xebbe(%rip), %xmm1     # 0xa2438
movsd %xmm1, 0x8(%rsp)
cvtsi2sd %ebx, %xmm1
movsd %xmm1, 0x10(%rsp)
callq 0x34d77
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x34d77
mulsd 0xeb96(%rip), %xmm0     # 0xa2440
movsd 0x18(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x34d77
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x34d77
mulsd 0xeb64(%rip), %xmm0     # 0xa2448
addsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
movsd 0x1c28(%rip), %xmm0     # 0x95520
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_discrete_recursive_old
double decisiontree_vc_dimension_discrete_recursive_old(int d, Decisionnodeptr rootnode)
{
 /*Last Changed 20.04.2008*/
 int N;
 double leftplusright;
 if (rootnode->featureno == LEAF_NODE)
   return 1;
 N = decisiontree_node_count(rootnode);
 leftplusright = decisiontree_vc_dimension_discrete_recursive_old(d - 1, &(rootnode->string[0])) + decisiontree_vc_dimension_discrete_recursive_old(d - 1, &(rootnode->string[1]));
 return 0.6076 + 1.0077 * leftplusright + 0.3657 * log2(d) - 0.8058 * log2(N);
}

// Assembly:
cmpl $-0x1, 0x30(%rsi)
je 0x93995
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %r14d
movq %rsi, %rdi
callq 0x1a8d0
movl %eax, %ebx
leal -0x1(%r14), %ebp
movq 0x10(%r15), %rsi
movl %ebp, %edi
callq 0x938f9
movsd %xmm0, (%rsp)
movl $0x160, %esi            # imm = 0x160
addq 0x10(%r15), %rsi
movl %ebp, %edi
callq 0x938f9
addsd (%rsp), %xmm0
mulsd 0xeb05(%rip), %xmm0     # 0xa2450
addsd 0xeb05(%rip), %xmm0     # 0xa2458
movsd %xmm0, (%rsp)
cvtsi2sd %r14d, %xmm0
callq 0x34d77
mulsd 0xeaf6(%rip), %xmm0     # 0xa2460
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
cvtsi2sd %ebx, %xmm0
callq 0x34d77
mulsd 0xeae3(%rip), %xmm0     # 0xa2468
addsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movsd 0x1b83(%rip), %xmm0     # 0x95520
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_discrete_recursive
double decisiontree_vc_dimension_discrete_recursive(Datasetptr current_dataset, int d, Decisionnodeptr rootnode)
{
 int i, sum;
 BOOLEAN all_leaves = BOOLEAN_TRUE;
 if (rootnode->featureno == LEAF_NODE)
   return 1;
 for (i = 0; i < current_dataset->features[rootnode->featureno].valuecount; i++)
   if (rootnode->string[i].featureno != LEAF_NODE)
     all_leaves = BOOLEAN_FALSE;
 if (all_leaves)
  {
   sum = 1;
   for (i = 0; i < current_dataset->featurecount; i++)
     if (current_dataset->features[i].type != CLASSDEF)
       sum += pow(2, current_dataset->features[i].valuecount - 1) - 1; 
   return log2(sum) + 1;
  }
 sum = 0;
 for (i = 0; i < current_dataset->features[rootnode->featureno].valuecount; i++)
   sum += ((int) decisiontree_vc_dimension_discrete_recursive(current_dataset, d - 1, &(rootnode->string[i])));
 return sum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, (%rsp)
movslq 0x30(%rdx), %rax
cmpq $-0x1, %rax
je 0x93a73
movq %rdx, %r14
movq %rdi, %rbx
imulq $0x340, %rax, %rax      # imm = 0x340
movl 0x30f20(%rdi,%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
leaq 0x30f08(%rdi), %r15
imulq $0x160, %rdx, %rsi      # imm = 0x160
pushq $0x1
popq %rdx
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x93a08
movq 0x10(%r14), %r8
cmpl $-0x1, 0x30(%r8,%rdi)
cmovnel %ecx, %edx
addq $0x160, %rdi            # imm = 0x160
jmp 0x939ed
testl %edx, %edx
je 0x93a7d
leaq 0x30f20(%rbx), %r14
pushq $0x1
popq %rax
xorl %r15d, %r15d
movslq 0x1bc(%rbx), %rcx
cvtsi2sd %eax, %xmm0
cmpq %rcx, %r15
jge 0x93a64
cmpl $0x3, -0x18(%r14)
je 0x93a58
movl (%r14), %edi
decl %edi
movsd %xmm0, (%rsp)
movsd 0x1ade(%rip), %xmm0     # 0x95520
callq 0x4080
addsd 0x2361(%rip), %xmm0     # 0x95db0
addsd (%rsp), %xmm0
cvttsd2si %xmm0, %eax
incq %r15
addq $0x340, %r14            # imm = 0x340
jmp 0x93a19
callq 0x34d77
addsd 0x1aaf(%rip), %xmm0     # 0x95520
jmp 0x93ac9
movsd 0x1aa5(%rip), %xmm0     # 0x95520
jmp 0x93ac9
decl (%rsp)
xorl %r12d, %r12d
xorl %ebp, %ebp
xorl %r13d, %r13d
cltq
cmpq %rax, %rbp
jge 0x93ac4
movq 0x10(%r14), %rdx
addq %r12, %rdx
movq %rbx, %rdi
movl (%rsp), %esi
callq 0x9399e
cvttsd2si %xmm0, %eax
addl %eax, %r13d
incq %rbp
movslq 0x30(%r14), %rax
imulq $0x340, %rax, %rax      # imm = 0x340
movl 0x18(%r15,%rax), %eax
addq $0x160, %r12            # imm = 0x160
jmp 0x93a88
cvtsi2sd %r13d, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_continuous_recursive
double decisiontree_vc_dimension_continuous_recursive(Datasetptr current_dataset, Decisionnodeptr rootnode)
{
 if (rootnode->featureno == LEAF_NODE)
   return 1;
 if (rootnode->left->featureno == LEAF_NODE && rootnode->right->featureno == LEAF_NODE)
   return log2(current_dataset->featurecount - 1) + 1;
 return decisiontree_vc_dimension_continuous_recursive(current_dataset, rootnode->left) + decisiontree_vc_dimension_continuous_recursive(current_dataset, rootnode->right);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $-0x1, 0x30(%rsi)
je 0x93b1b
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
cmpl $-0x1, 0x30(%rsi)
jne 0x93afb
movq 0x8(%r14), %rax
cmpl $-0x1, 0x30(%rax)
je 0x93b2b
movq %rbx, %rdi
callq 0x93ad8
movsd %xmm0, (%rsp)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x93ad8
addsd (%rsp), %xmm0
jmp 0x93b23
movsd 0x19fd(%rip), %xmm0     # 0x95520
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x1bc(%rbx), %eax
decl %eax
cvtsi2sd %eax, %xmm0
callq 0x34d77
addsd 0x19dc(%rip), %xmm0     # 0x95520
jmp 0x93b23