LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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, %r15d
callq 0x38632
movq %rax, %r14
movslq %r15d, %r12
movl %r12d, %r13d
xorl %ebx, %ebx
movl $0x1, %ebp
leaq 0x348fe(%rip), %r9      # 0xd2870
movl %r15d, 0xc(%rsp)
movl $0x0, %eax
testl %r15d, %r15d
jle 0x9dfbb
xorl %esi, %esi
movq %r13, %rcx
movq %r14, %rdx
xorl %eax, %eax
movq %rsi, %rdi
incq %rsi
cmpq %r12, %rsi
jge 0x9dfaf
movl (%r14,%rdi,4), %edi
movl $0x1, %r8d
cmpl (%rdx,%r8,4), %edi
cmovel %ebp, %eax
incq %r8
cmpq %r8, %rcx
jne 0x9dfa0
addq $0x4, %rdx
decq %rcx
cmpq %r13, %rsi
jne 0x9df8b
testl %r15d, %r15d
jle 0x9dfda
movq (%r9), %rcx
movl 0x1407128(%rcx), %ecx
xorl %edx, %edx
cmpl %ecx, (%r14,%rdx,4)
cmovel %ebp, %eax
incq %rdx
cmpq %rdx, %r13
jne 0x9dfcb
testl %eax, %eax
jne 0x9e064
movq %rbx, 0x10(%rsp)
movl $0x1, %ebx
testl %r15d, %r15d
jle 0x9e020
xorl %r15d, %r15d
movq (%r9), %rax
movslq (%r14,%r15,4), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f20(%rax,%rcx), %edi
callq 0x38ede
leaq 0x3485b(%rip), %r9      # 0xd2870
imull %eax, %ebx
incq %r15
cmpq %r15, %r13
jne 0x9dff4
movl 0xc(%rsp), %r15d
testl %r15d, %r15d
jle 0x9e058
movq (%r9), %rcx
movl $0x30f08, %eax          # imm = 0x30F08
addq %rax, %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%r14,%rdx,4), %rsi
imulq $0x340, %rsi, %rsi      # imm = 0x340
imull 0x18(%rcx,%rsi), %eax
incq %rdx
cmpq %rdx, %r13
jne 0x9e03c
decl %eax
jmp 0x9e05a
xorl %eax, %eax
imull %ebx, %eax
movq 0x10(%rsp), %rbx
addl %eax, %ebx
movq (%r9), %rax
movl 0x1bc(%rax), %edx
decl %edx
movq %r14, %rdi
movl %r15d, %esi
callq 0x38bb6
leaq 0x347ef(%rip), %r9      # 0xd2870
testl %eax, %eax
jne 0x9df77
movq %r14, %rdi
callq 0x39194
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x347b3(%rip), %r12     # 0xd2870
movl $0x1, %r13d
movl $0x0, 0x98(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c8e2
testl %eax, %eax
je 0x9e175
movq 0x20(%r14), %rdi
leaq 0x28(%r14), %rsi
callq 0x9daab
movl %eax, 0x30(%r14)
movq %r14, %rdi
callq 0x9db4a
testl %eax, %eax
je 0x9e175
movq (%r12), %rax
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %edx
testl %edx, %edx
je 0x9e11d
cmpl $0x2, %edx
jne 0x9e139
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x9e0a2
movq 0x8(%r14), %r14
testb $0x1, %r15b
cmovel %r13d, %ebp
movb $0x1, %r15b
jmp 0x9e0c3
cmpl $0x1, %edx
jne 0x9e175
addq %rcx, %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq 0x18(%rax), %rax
testq %rax, %rax
jle 0x9e175
imulq $0x160, %rax, %r12      # imm = 0x160
xorl %r13d, %r13d
movq 0x10(%r14), %rdi
addq %r13, %rdi
movq %rbx, %rsi
callq 0x9e0a2
addq $0x160, %r13            # imm = 0x160
cmpq %r13, %r12
jne 0x9e15a
testb $0x1, %r15b
movl $0x1, %eax
cmovnel %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9e1e7
testq %r12, %r12
je 0x9e275
movslq 0x4(%rsp), %r13
imulq $0x340, %r13, %rbp      # imm = 0x340
cmpl $0x2, %ebx
jne 0x9e21c
movq %r12, %rdi
movl 0x4(%rsp), %esi
callq 0x2e4b6
jmp 0x9e245
leaq 0x3464d(%rip), %rax     # 0xd2870
movq (%rax), %rax
cmpl $0x0, 0x30f08(%rax,%rbp)
movq (%r12), %rax
je 0x9e23c
movsd (%rax,%r13,8), %xmm0
jmp 0x9e245
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%r13,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x2eaca
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 0x9e209
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9e2f6
cmpl $0x0, 0x24(%rsp)
js 0x9e2f6
cmpl $0x0, 0x90(%rsp)
je 0x9e2f6
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 0x543f9
testl %eax, %eax
je 0x9e305
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 0x5442f
movq %rax, %rbp
testq %r13, %r13
je 0x9e3c9
movl 0x24(%rsp), %ecx
movq %rcx, 0x38(%rsp)
imulq $0x340, %rcx, %rax      # imm = 0x340
movq %rax, 0x40(%rsp)
cmpl $0x2, 0x34(%rsp)
jne 0x9e353
movq %r13, %rdi
movl 0x24(%rsp), %esi
callq 0x2e4b6
jmp 0x9e389
leaq 0x34516(%rip), %rax     # 0xd2870
movq (%rax), %rax
movq 0x40(%rsp), %rcx
cmpl $0x0, 0x30f08(%rax,%rcx)
movq (%r13), %rax
je 0x9e37c
movq 0x38(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
jmp 0x9e389
movq 0x38(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x28(%rsp)
movq %r13, %rdi
callq 0x2eaca
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 0x9e33e
movq %rbp, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/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 0x9e45d
movl %esi, %ebx
testl %esi, %esi
js 0x9e45d
cmpl $0x0, 0xa0(%rsp)
je 0x9e45d
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 0x543f9
testl %eax, %eax
je 0x9e46c
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 0x5442f
movq %rax, %rbp
testq %r13, %r13
je 0x9e52d
movl %ebx, %ebx
imulq $0x340, %rbx, %r15      # imm = 0x340
leaq 0x343d0(%rip), %rax     # 0xd2870
movq (%rax), %rax
cmpl $0x0, 0x30f08(%rax,%r15)
movq (%r13), %rax
je 0x9e4b9
movsd (%rax,%rbx,8), %xmm0
jmp 0x9e4c1
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%rbx,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r13, %rdi
callq 0x2eaca
cltq
cmpl $0x0, (%rbp,%rax,4)
movsd 0x20(%rsp), %xmm1
jne 0x9e4f8
ucomisd 0x50(%rsp), %xmm1
jb 0x9e4f8
movsd 0x48(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movq %r14, %rcx
movq %r12, %rax
jae 0x9e516
ucomisd 0x40(%rsp), %xmm1
jb 0x9e520
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rax
jb 0x9e520
incl (%rcx)
addsd (%rax), %xmm1
movsd %xmm1, (%rax)
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x9e499
movq %rbp, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/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 %rax, (%rcx)
testq %rdi, %rdi
je 0x9e5bf
movl %esi, %ebp
testl %esi, %esi
js 0x9e5bf
cmpl $0x0, 0xa0(%rsp)
je 0x9e5bf
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x90(%rsp), %r12
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
callq 0x543f9
testl %eax, %eax
je 0x9e5ce
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movupd (%r12), %xmm0
movupd %xmm0, (%rsp)
callq 0x5442f
movq %rax, %r12
testq %r15, %r15
je 0x9e69a
movl %ebp, %r13d
imulq $0x340, %r13, %rbp      # imm = 0x340
leaq 0x3426b(%rip), %rax     # 0xd2870
movq (%rax), %rax
cmpl $0x0, 0x30f08(%rax,%rbp)
movq (%r15), %rax
je 0x9e61d
movsd (%rax,%r13,8), %xmm0
jmp 0x9e626
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%r13,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r15, %rdi
callq 0x2eaca
cltq
cmpl $0x0, (%r12,%rax,4)
movsd 0x20(%rsp), %xmm1
jne 0x9e660
ucomisd 0x50(%rsp), %xmm1
jb 0x9e660
movsd 0x48(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movsd 0x40(%rsp), %xmm0
movq %r14, %rax
jae 0x9e67d
ucomisd 0x38(%rsp), %xmm1
jb 0x9e68d
movsd 0x30(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movsd 0x28(%rsp), %xmm0
movq %rbx, %rax
jb 0x9e68d
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
addsd (%rax), %xmm1
movsd %xmm1, (%rax)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x9e5fe
movq %r12, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/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 0x9e716
movl %esi, %ebp
testl %esi, %esi
js 0x9e716
cmpl $0x0, 0x90(%rsp)
je 0x9e716
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 0x543f9
testl %eax, %eax
je 0x9e725
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 0x5442f
movq %rax, %r13
testq %r12, %r12
je 0x9e7f3
movl %ebp, %ecx
movq %rcx, 0x28(%rsp)
imulq $0x340, %rcx, %rax      # imm = 0x340
movq %rax, 0x30(%rsp)
cmpl $0x2, %ebx
jne 0x9e76e
movq %r12, %rdi
movl %ebp, %esi
callq 0x2e4b6
jmp 0x9e7a4
leaq 0x340fb(%rip), %rax     # 0xd2870
movq (%rax), %rax
movq 0x30(%rsp), %rcx
cmpl $0x0, 0x30f08(%rax,%rcx)
movq (%r12), %rax
je 0x9e797
movq 0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
jmp 0x9e7a4
movq 0x28(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
callq 0x2eaca
cltq
cmpl $0x0, (%r13,%rax,4)
movsd 0x40(%rsp), %xmm0
je 0x9e7c8
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 0x9e75d
movq %r13, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/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 0x9ef99
movq %rdi, %r14
testq %rdi, %rdi
je 0x9ef99
cmpl $0x0, 0xa0(%rsp)
je 0x9ef99
movl %edx, %ebx
movl %esi, %ebp
leaq 0x90(%rsp), %r13
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movupd (%r13), %xmm0
movupd %xmm0, (%rsp)
callq 0x543f9
testl %eax, %eax
je 0x9efb0
movsd 0x3d4f(%rip), %xmm0     # 0xa2cf0
addq $0x58, %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)
movl %ebx, 0x18(%rsp)
leaq 0x40(%rsp), %rdx
leaq 0x38(%rsp), %rcx
leaq 0x24(%rsp), %r15
leaq 0x20(%rsp), %r9
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %r8
callq 0x9e284
movl (%r15), %r15d
testl %r15d, %r15d
jle 0x9ef99
cvtsi2sd %r15d, %xmm1
movsd 0x40(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movl 0x20(%rsp), %r12d
testl %r12d, %r12d
jle 0x9ef99
cvtsi2sd %r12d, %xmm2
movsd 0x38(%rsp), %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, 0x38(%rsp)
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movupd (%r13), %xmm2
movupd %xmm2, (%rsp)
leaq 0x28(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
movl %ebx, %r8d
callq 0x9e6b0
xorpd %xmm3, %xmm3
xorpd %xmm2, %xmm2
cmpl $0x1, %r15d
je 0x9f07f
leal -0x1(%r15), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x28(%rsp), %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x28(%rsp)
cmpl $0x1, %r12d
je 0x9f0a1
leal -0x1(%r12), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x30(%rsp), %xmm3
divsd %xmm0, %xmm3
movsd %xmm3, 0x30(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movl %r15d, %edi
movl %r12d, %esi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9e809
// File: /workspace/github_c_makefile_star2_O1/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 0x9ef42
movsd %xmm0, (%r14)
leaq 0xe8(%rsp), %rcx
leaq 0x20(%rsp), %r14
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %r8d
callq 0x9e1bf
movq %r14, %rdi
callq 0x1d7dc
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9e1bf
movq %r14, %rdi
callq 0x1d726
xorpd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x1d726
addsd 0x8(%rsp), %xmm0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x32daf(%rip), %r12     # 0xd2870
movl $0x1, %r13d
movl $0x0, 0x98(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c8e2
testl %eax, %eax
je 0x9fb79
movq 0x20(%r14), %rdi
leaq 0x28(%r14), %rsi
callq 0x9f595
movl %eax, 0x30(%r14)
movq %r14, %rdi
callq 0x9db4a
testl %eax, %eax
je 0x9fb79
movq (%r12), %rax
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %edx
testl %edx, %edx
je 0x9fb21
cmpl $0x2, %edx
jne 0x9fb3d
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x9faa6
movq 0x8(%r14), %r14
testb $0x1, %r15b
cmovel %r13d, %ebp
movb $0x1, %r15b
jmp 0x9fac7
cmpl $0x1, %edx
jne 0x9fb79
addq %rcx, %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq 0x18(%rax), %rax
testq %rax, %rax
jle 0x9fb79
imulq $0x160, %rax, %r12      # imm = 0x160
xorl %r13d, %r13d
movq 0x10(%r14), %rdi
addq %r13, %rdi
movq %rbx, %rsi
callq 0x9faa6
addq $0x160, %r13            # imm = 0x160
cmpq %r13, %r12
jne 0x9fb5e
testb $0x1, %r15b
movl $0x1, %eax
cmovnel %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf8e4(%rip), %r15      # 0xaf490
leaq 0xf8fd(%rip), %r12      # 0xaf4b0
xorpd %xmm1, %xmm1
movsd (%rbx,%r14), %xmm2
subsd (%r14,%r15), %xmm2
movsd (%r14,%r12), %xmm0
ucomisd %xmm1, %xmm0
jb 0x9fbd5
sqrtsd %xmm0, %xmm0
jmp 0x9fbea
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 0x9fbb7
movsd 0xf831(%rip), %xmm0     # 0xaf438
xorl %eax, %eax
leaq 0xf900(%rip), %rcx      # 0xaf510
movsd 0x8(%rcx,%rax,8), %xmm1
mulsd 0x10(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x3, %rax
jne 0x9fc10
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf883(%rip), %r15      # 0xaf4d0
leaq 0xf89c(%rip), %r12      # 0xaf4f0
xorpd %xmm1, %xmm1
movsd (%rbx,%r14), %xmm2
subsd (%r14,%r15), %xmm2
movsd (%r14,%r12), %xmm0
ucomisd %xmm1, %xmm0
jb 0x9fc76
sqrtsd %xmm0, %xmm0
jmp 0x9fc8b
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 0x9fc58
movsd 0xf798(%rip), %xmm0     # 0xaf440
xorl %eax, %eax
leaq 0xf87f(%rip), %rcx      # 0xaf530
movsd 0x8(%rcx,%rax,8), %xmm1
mulsd 0x10(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x3, %rax
jne 0x9fcb1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorpd %xmm0, %xmm0
movapd %xmm0, 0x70(%rsp)
movapd %xmm0, 0x80(%rsp)
movabsq $0x4082a60000000000, %rax # imm = 0x4082A60000000000
movq %rax, 0x70(%rsp)
movabsq $0x4043400000000000, %rax # imm = 0x4043400000000000
movq %rax, 0x78(%rsp)
movabsq $0x4055500000000000, %rax # imm = 0x4055500000000000
movq %rax, 0x80(%rsp)
movabsq $0x4016000000000000, %rax # imm = 0x4016000000000000
movq %rax, 0x88(%rsp)
movabsq $0x402f000000000000, %rax # imm = 0x402F000000000000
movq %rax, 0x90(%rsp)
movapd %xmm0, 0x40(%rsp)
movapd %xmm0, 0x50(%rsp)
movabsq $0x411b1611b05ff1d8, %rax # imm = 0x411B1611B05FF1D8
movq %rax, 0x40(%rsp)
movabsq $0x40907a42c83ec893, %rax # imm = 0x40907A42C83EC893
movq %rax, 0x48(%rsp)
movabsq $0x40b312a12d666a98, %rax # imm = 0x40B312A12D666A98
movq %rax, 0x50(%rsp)
movabsq $0x40208e2089e34331, %rax # imm = 0x40208E2089E34331
movq %rax, 0x58(%rsp)
movabsq $0x4052cab3cc4ac6ce, %rax # imm = 0x4052CAB3CC4AC6CE
movq %rax, 0x60(%rsp)
movapd %xmm0, 0x10(%rsp)
movapd %xmm0, 0x20(%rsp)
movapd %xmm0, 0x30(%rsp)
movabsq $0x40572225918a009f, %rax # imm = 0x40572225918A009F
movq %rax, 0x10(%rsp)
movabsq $0x3fff8cbd1244a622, %rax # imm = 0x3FFF8CBD1244A622
movq %rax, 0x18(%rsp)
movabsq $0x4029be09bb6aa4ba, %rax # imm = 0x4029BE09BB6AA4BA
movq %rax, 0x20(%rsp)
movabsq $0x404929eedcc20d56, %rax # imm = 0x404929EEDCC20D56
movq %rax, 0x28(%rsp)
movabsq $0x401b73cd141a6938, %rax # imm = 0x401B73CD141A6938
movq %rax, 0x30(%rsp)
movabsq $0x4013281450efdc9c, %rax # imm = 0x4013281450EFDC9C
movq %rax, 0x38(%rsp)
xorl %r14d, %r14d
xorpd %xmm1, %xmm1
movsd (%rbx,%r14,8), %xmm2
subsd 0x70(%rsp,%r14,8), %xmm2
movsd 0x40(%rsp,%r14,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x9fe34
sqrtsd %xmm0, %xmm0
jmp 0x9fe49
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 0x9fe14
movsd 0xf5e0(%rip), %xmm0     # 0xaf448
movl $0x1, %eax
movsd 0x10(%rsp,%rax,8), %xmm1
mulsd 0x98(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x6, %rax
jne 0x9fe6d
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9ff11
movq %rdi, %r14
cvtsi2sdl 0x1bc(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x38e99
ucomisd 0x8(%rsp), %xmm0
ja 0x9ff11
xorps %xmm0, %xmm0
cvtsi2sdl 0x1bc(%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x38e99
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
addsd 0x3142(%rip), %xmm1     # 0xa3040
movapd %xmm1, %xmm0
callq 0x38e99
mulsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9ff70
cmpl $0x1, %edx
je 0x9ff6a
movl $0x1, %eax
testl %edx, %edx
jne 0x9ff82
pushq %rax
incl %esi
cvtsi2sd %esi, %xmm0
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
callq 0x38e99
addsd 0x25cc(%rip), %xmm0     # 0xa2520
mulsd (%rsp), %xmm0
mulsd 0x2db7(%rip), %xmm0     # 0xa2d18
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_O1/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 0xa0039
pushq %rbx
subq $0x20, %rsp
movl 0x1bc(%rdi), %ebx
decl %ebx
movq %rsi, %rdi
callq 0x1c583
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xf49c(%rip), %xmm1     # 0xaf450
mulsd %xmm0, %xmm1
addsd 0xf498(%rip), %xmm1     # 0xaf458
movsd %xmm1, 0x8(%rsp)
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
movsd %xmm1, 0x10(%rsp)
callq 0x38e99
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x38e99
mulsd 0xf46d(%rip), %xmm0     # 0xaf460
movsd 0x18(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x38e99
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x38e99
mulsd 0xf43b(%rip), %xmm0     # 0xaf468
addsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
movsd 0x24df(%rip), %xmm0     # 0xa2520
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa00e4
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %r14d
movq %rsi, %rdi
callq 0x1c583
movl %eax, %ebx
leal -0x1(%r14), %ebp
movq 0x10(%r15), %rsi
movl %ebp, %edi
callq 0xa0042
movsd %xmm0, (%rsp)
movl $0x160, %esi            # imm = 0x160
addq 0x10(%r15), %rsi
movl %ebp, %edi
callq 0xa0042
addsd (%rsp), %xmm0
mulsd 0xf3dc(%rip), %xmm0     # 0xaf470
addsd 0xf3dc(%rip), %xmm0     # 0xaf478
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
callq 0x38e99
mulsd 0xf3ca(%rip), %xmm0     # 0xaf480
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
callq 0x38e99
mulsd 0xf3b4(%rip), %xmm0     # 0xaf488
addsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movsd 0x2434(%rip), %xmm0     # 0xa2520
retq
// File: /workspace/github_c_makefile_star2_O1/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
movslq 0x30(%rdx), %rax
cmpq $-0x1, %rax
je 0xa01c3
movq %rdi, %rbx
imulq $0x340, %rax, %rax      # imm = 0x340
movslq 0x30f20(%rdi,%rax), %rcx
testq %rcx, %rcx
jle 0xa015c
movq %rdx, %r10
movl %esi, %r14d
leaq 0x30f08(%rbx), %rbp
movq 0x10(%rdx), %rax
imulq $0x160, %rcx, %rdx      # imm = 0x160
movl $0x1, %ecx
xorl %r9d, %r9d
xorl %edi, %edi
cmpl $-0x1, 0x30(%rax,%rdi)
cmovnel %r9d, %ecx
addq $0x160, %rdi            # imm = 0x160
cmpq %rdi, %rdx
jne 0xa013f
testl %ecx, %ecx
je 0xa01f1
cmpl $0x0, 0x1bc(%rbx)
jle 0xa01cd
leaq 0x30f20(%rbx), %r14
movl $0x1, %ebp
xorl %r15d, %r15d
cmpl $0x3, -0x18(%r14)
je 0xa01a4
movl (%r14), %edi
decl %edi
movsd 0x2398(%rip), %xmm0     # 0xa2520
callq 0x4080
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
addsd 0x2c0c(%rip), %xmm0     # 0xa2da8
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %ebp
incq %r15
movslq 0x1bc(%rbx), %rax
addq $0x340, %r14            # imm = 0x340
cmpq %rax, %r15
jl 0xa0174
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
jmp 0xa01d5
movsd 0x2355(%rip), %xmm0     # 0xa2520
jmp 0xa01e2
movsd 0x234b(%rip), %xmm0     # 0xa2520
callq 0x38e99
addsd 0x233e(%rip), %xmm0     # 0xa2520
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq 0x30(%r10), %rax
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x0, 0x18(%rbp,%rax)
jle 0xa025f
decl %r14d
xorl %r12d, %r12d
xorl %r15d, %r15d
xorl %r13d, %r13d
movq %rbx, (%rsp)
movq 0x10(%r10), %rdx
addq %r12, %rdx
movq %rbx, %rdi
movl %r14d, %esi
movq %r10, %rbx
callq 0xa00ed
movq %rbx, %r10
movq (%rsp), %rbx
cvttsd2si %xmm0, %eax
addl %eax, %r13d
incq %r15
movslq 0x30(%r10), %rax
imulq $0x340, %rax, %rax      # imm = 0x340
movslq 0x18(%rbp,%rax), %rax
addq $0x160, %r12            # imm = 0x160
cmpq %rax, %r15
jl 0xa0213
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
jmp 0xa01e2
xorpd %xmm0, %xmm0
jmp 0xa01e2
// File: /workspace/github_c_makefile_star2_O1/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 0xa02ab
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
cmpl $-0x1, 0x30(%rsi)
jne 0xa028b
movq 0x8(%r14), %rax
cmpl $-0x1, 0x30(%rax)
je 0xa02bb
movq %rbx, %rdi
callq 0xa0268
movsd %xmm0, (%rsp)
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xa0268
addsd (%rsp), %xmm0
jmp 0xa02b3
movsd 0x226d(%rip), %xmm0     # 0xa2520
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x1bc(%rbx), %eax
decl %eax
cvtsi2sd %eax, %xmm0
callq 0x38e99
addsd 0x224c(%rip), %xmm0     # 0xa2520
jmp 0xa02b3
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_recursive
int decisiontree_vc_dimension_recursive(Datasetptr current_dataset, Decisionnodeptr root)
{
 if (number_of_symbolic_features(current_dataset->name) == current_dataset->featurecount - 1)
   return (int) decisiontree_vc_dimension_discrete_recursive(current_dataset, current_dataset->featurecount - 1, root);
 else
   if (number_of_numeric_features(current_dataset->name) == current_dataset->featurecount - 1)
     return decisiontree_vc_dimension_continuous_recursive(current_dataset, root);
   else
     return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x15038
movl 0x1bc(%r14), %esi
decl %esi
cmpl %esi, %eax
jne 0xa0303
movq %r14, %rdi
movq %rbx, %rdx
callq 0xa00ed
jmp 0xa032b
movq 0x8(%r14), %rdi
callq 0x15149
movl %eax, %ecx
movl 0x1bc(%r14), %edx
decl %edx
movl $0x1, %eax
cmpl %edx, %ecx
jne 0xa032f
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa0268
cvttsd2si %xmm0, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/vc.c
// Function: decisiontree_vc_dimension_wrt_nodetype
int decisiontree_vc_dimension_wrt_nodetype(Datasetptr d, int nodecount, MODEL_TYPE nodetype)
{
 /*Last Changed 01.10.2006*/
 double* testdata, logd, dimension, multiplier;
 int dim = d->multifeaturecount - 1, size;
 logd = log2(dim);
 switch (nodetype)
  {
   case MODEL_UNI:multiplier = logd;
                  size = 3;
                  break;
   case MODEL_LIN:multiplier = dim;
                  size = 3;
                  break;
   case MODEL_QUA:multiplier = dim;
                  size = 5;
                  break;
  }
 testdata = safemalloc(size * sizeof(double), "decisiontree_vc_dimension_wrt_nodetype", 10);
 testdata[size - 3] = multiplier * nodecount;
 testdata[size - 2] = multiplier;
 testdata[size - 1] = nodecount;
 switch (nodetype)
  {
   case MODEL_UNI:dimension = decisiontree_vc_dimension_univariate1(testdata);
                  break;
   case MODEL_LIN:dimension = decisiontree_vc_dimension_linear1(testdata);
                  break;
   case MODEL_QUA:testdata[0] = dim * dim * nodecount;
                  testdata[1] = dim * dim;
                  dimension = decisiontree_vc_dimension_quadratic1(testdata);
                  break;
  }
 safe_free(testdata);
 return ((int) dimension);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl 0x1c0(%rdi), %r12d
decl %r12d
cvtsi2sd %r12d, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x38e99
cmpl $0x2, %ebx
je 0xa0385
cmpl $0x1, %ebx
je 0xa037d
testl %ebx, %ebx
jne 0xa038d
movl $0x3, %r15d
movsd %xmm0, 0x8(%rsp)
jmp 0xa0390
movl $0x3, %r15d
jmp 0xa0390
movl $0x5, %r15d
jmp 0xa0390
xorl %r15d, %r15d
leaq 0xf1b9(%rip), %rsi      # 0xaf550
shll $0x3, %r15d
movq %r15, %rdi
movl $0xa, %edx
callq 0x390f5
movq %rax, %r14
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd 0x8(%rsp), %xmm2
movapd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rax,%r15)
movsd %xmm2, -0x10(%rax,%r15)
movsd %xmm0, -0x8(%rax,%r15)
cmpl $0x2, %ebx
je 0xa03f7
cmpl $0x1, %ebx
je 0xa03ed
testl %ebx, %ebx
jne 0xa0427
movq %r14, %rdi
callq 0x9fb94
jmp 0xa0421
movq %r14, %rdi
callq 0x9fc35
jmp 0xa0421
imull %r12d, %r12d
imull %r12d, %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%r14)
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
movsd %xmm0, 0x8(%r14)
movq %r14, %rdi
callq 0x9fcd6
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x39194
cvttsd2si 0x8(%rsp), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/vc.c
// Function: omnivariatetree_vc_dimension
int omnivariatetree_vc_dimension(Datasetptr d, Decisionnodeptr node)
{
 /*Last Changed 29.09.2006*/
 /*Last Changed 06.03.2006*/
 int uni, linear, quadratic, result = 0;
 uni = decisiontree_univariate_node_count(node);
 result += decisiontree_vc_dimension_wrt_nodetype(d, uni, MODEL_UNI);
 linear = decisiontree_multivariate_linear_node_count(node);
 result += decisiontree_vc_dimension_wrt_nodetype(d, linear, MODEL_LIN);
 quadratic = decisiontree_multivariate_quadratic_node_count(node);
 result += decisiontree_vc_dimension_wrt_nodetype(d, quadratic, MODEL_QUA);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x9cc04
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0xa0337
movl %eax, %ebp
movq %r14, %rdi
callq 0x4bac0
movq %rbx, %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0xa0337
movl %eax, %r15d
addl %ebp, %r15d
movq %r14, %rdi
callq 0x4bb0d
movq %rbx, %rdi
movl %eax, %esi
movl $0x2, %edx
callq 0xa0337
addl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/vc.c
// Function: ruleset_vc_dimension_discrete_recursive
int ruleset_vc_dimension_discrete_recursive(int* condition_counts, int k, int d)
{
 int i, j, max, current;
 int *left, *right;
 if (k == 1)
  {
   if (condition_counts[0] > -1)
     return (int) (log2(binomdouble(d, condition_counts[0]) + 1) + 1);
   else
     return 1;
  }
 max = 0;
 for (i = 1; i < k; i++)
  {
   left = safemalloc(i * sizeof(int), "ruleset_vc_dimension_discrete_recursive", 8);
   for (j = 0; j < i; j++)
     left[j] = condition_counts[i - 1] - 1;
   right = safemalloc((k - i) * sizeof(int), "ruleset_vc_dimension_discrete_recursive", 11);
   for (j = 0; j < k - i; j++)
     right[j] = condition_counts[i + j] - 1;
   current = ruleset_vc_dimension_discrete_recursive(left, i, d - 1) + ruleset_vc_dimension_discrete_recursive(right, k - i, d - 1);
   if (current > max)
     max = current;
   safe_free(left);
   safe_free(right);
  }
 return max;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, 0x4(%rsp)
movq %rdi, %r14
cmpl $0x1, %esi
jne 0xa04f3
movl (%r14), %esi
testl %esi, %esi
js 0xa05fe
movl 0x4(%rsp), %edi
callq 0x38f93
addsd 0x2043(%rip), %xmm0     # 0xa2520
callq 0x38e99
addsd 0x2036(%rip), %xmm0     # 0xa2520
cvttsd2si %xmm0, %eax
jmp 0xa0603
movl %esi, %r15d
movq $0x0, 0x8(%rsp)
cmpl $0x2, %esi
jl 0xa0608
decl 0x4(%rsp)
movl %r15d, %ebx
leaq 0x4(%r14), %r12
decl %r15d
movq $0x0, 0x8(%rsp)
movl $0x1, %r13d
movq %rbx, 0x20(%rsp)
movl %r15d, %r15d
leaq (,%r13,4), %rdi
leaq 0xf03b(%rip), %rsi      # 0xaf577
movl $0x8, %edx
callq 0x390f5
movq %rax, %rbp
xorl %eax, %eax
movl -0x4(%r14,%r13,4), %ecx
decl %ecx
movl %ecx, (%rbp,%rax,4)
incq %rax
cmpq %rax, %r13
jne 0xa054b
subq %r13, %rbx
movq %rbx, 0x18(%rsp)
leaq (,%rbx,4), %rdi
leaq 0xf002(%rip), %rsi      # 0xaf577
movl $0xb, %edx
callq 0x390f5
movq %rax, %rbx
cmpq $0x0, 0x18(%rsp)
jle 0xa059d
xorl %eax, %eax
movl (%r12,%rax,4), %ecx
decl %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0xa058c
movq %rbp, %rdi
movl %r13d, %esi
movl 0x4(%rsp), %edx
callq 0xa04a7
movl %eax, 0x14(%rsp)
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0xa04a7
addl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl %ecx, %eax
cmovgl %eax, %ecx
movq %rcx, 0x8(%rsp)
movq %rbp, %rdi
callq 0x39194
movq %rbx, %rdi
callq 0x39194
incq %r13
addq $0x4, %r12
decl %r15d
movq 0x20(%rsp), %rbx
cmpq %rbx, %r13
jne 0xa052a
jmp 0xa0608
movl $0x1, %eax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq