LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_leaf_count
int decisiontree_leaf_count(Decisionnodeptr node)
{
 /*!Last Changed 24.11.2004*/
 int fno, result = 0, i;
 if (node->featureno == LEAF_NODE)
   return 1;
 else
  {
   fno = node->featureno;
   if (fno >= 0 && (node->conditiontype != HYBRID_CONDITION) && current_dataset->features[fno].type == STRING)
     for (i = 0; i < current_dataset->features[fno].valuecount; i++)
       result += decisiontree_leaf_count(&(node->string[i]));
   else
    {
     result += decisiontree_leaf_count(node->left);
     result += decisiontree_leaf_count(node->right);
    }
   return result;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0xb302d(%rip), %rax     # 0xcd870
movl $0x30f08, %r15d         # imm = 0x30F08
addq (%rax), %r15
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
pushq $0x1
popq %rbp
movl 0x30(%rbx), %eax
cmpq %r12, %rax
je 0x1a8c2
testl %eax, %eax
js 0x1a87e
cmpl $0x2, 0x98(%rbx)
je 0x1a87e
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, (%r15,%rax)
je 0x1a88f
movq (%rbx), %rdi
callq 0x1a834
movq 0x8(%rbx), %rbx
addl %eax, %r14d
jmp 0x1a85b
movl 0x18(%r15,%rax), %eax
xorl %r15d, %r15d
testl %eax, %eax
cmovlel %r15d, %eax
imulq $0x160, %rax, %r12      # imm = 0x160
xorl %ebp, %ebp
cmpq %r15, %r12
je 0x1a8c2
movq 0x10(%rbx), %rdi
addq %r15, %rdi
callq 0x1a834
addl %eax, %ebp
addq $0x160, %r15            # imm = 0x160
jmp 0x1a8a6
addl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_node_count
int decisiontree_node_count(Decisionnodeptr node)
{
 /*!Last Changed 24.11.2004*/
 int fno, result = 1, i;
 if (node->featureno == LEAF_NODE)
   return 0;
 else
  {
   fno = node->featureno;
   if (fno >= 0 && (node->conditiontype != HYBRID_CONDITION) && current_dataset->features[fno].type == STRING)
     for (i = 0; i < current_dataset->features[fno].valuecount; i++)
      {
       result += decisiontree_node_count(&(node->string[i]));
      }
   else
    {
     result += decisiontree_node_count(node->left);
     result += decisiontree_node_count(node->right);
    }
   return result;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xb2f90(%rip), %rax     # 0xcd870
movl $0x30f08, %r12d         # imm = 0x30F08
addq (%rax), %r12
movq %rdi, %r14
xorl %ebx, %ebx
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
xorl %r15d, %r15d
movl 0x30(%r14), %eax
cmpq %r13, %rax
je 0x1a964
testl %eax, %eax
js 0x1a91c
cmpl $0x2, 0x98(%r14)
je 0x1a91c
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, (%r12,%rax)
je 0x1a930
movq (%r14), %rdi
callq 0x1a8d0
movq 0x8(%r14), %r14
addl %eax, %r15d
incl %r15d
jmp 0x1a8f7
movl 0x18(%r12,%rax), %eax
xorl %r12d, %r12d
testl %eax, %eax
cmovlel %r12d, %eax
imulq $0x160, %rax, %r13      # imm = 0x160
pushq $0x1
popq %rbx
cmpq %r12, %r13
je 0x1a964
movq 0x10(%r14), %rdi
addq %r12, %rdi
callq 0x1a8d0
addl %eax, %ebx
addq $0x160, %r12            # imm = 0x160
jmp 0x1a948
addl %r15d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_condition_count
int decisiontree_condition_count(Decisionnodeptr node)
{
 /*!Last Changed 23.09.2004 added hybridcondition*/
 /*!Last Changed 10.11.2003*/
 int result = 0, fno, i;
 if (node->featureno == LEAF_NODE)
   return node->conditioncount;
 else
  {
   fno = node->featureno;
   if (fno >= 0 && (node->conditiontype != HYBRID_CONDITION) && current_dataset->features[fno].type == STRING)
     for (i = 0; i < current_dataset->features[fno].valuecount; i++)
       result += decisiontree_condition_count(&(node->string[i]));
   else
    {
     result += decisiontree_condition_count(node->left);
     result += decisiontree_condition_count(node->right);
    }
   return result;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xb2eeb(%rip), %rax     # 0xcd870
movl $0x30f08, %r15d         # imm = 0x30F08
addq (%rax), %r15
xorl %r14d, %r14d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl 0x30(%rbx), %eax
cmpq %r12, %rax
je 0x1a9cb
testl %eax, %eax
js 0x1a9ba
cmpl $0x2, 0x98(%rbx)
je 0x1a9ba
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, (%r15,%rax)
je 0x1a9df
movq (%rbx), %rdi
callq 0x1a973
movq 0x8(%rbx), %rbx
addl %eax, %r14d
jmp 0x1a997
movl 0x80(%rbx), %ebp
addl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%r15,%rax), %eax
xorl %r15d, %r15d
testl %eax, %eax
cmovlel %r15d, %eax
imulq $0x160, %rax, %r12      # imm = 0x160
xorl %ebp, %ebp
cmpq %r15, %r12
je 0x1a9d1
movq 0x10(%rbx), %rdi
addq %r15, %rdi
callq 0x1a973
addl %eax, %ebp
addq $0x160, %r15            # imm = 0x160
jmp 0x1a9f6
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_rule_count
int decisiontree_rule_count(Decisionnodeptr node)
{
 /*!Last Changed 23.09.2004 added hybridcondition*/
 /*!Last Changed 10.11.2003*/
 int result = 0, fno, i;
 if (node->featureno == LEAF_NODE)
   return 1;
 else
  {
   fno = node->featureno;
   if (fno >= 0 && (node->conditiontype != HYBRID_CONDITION) && current_dataset->features[fno].type == STRING)
     for (i = 0; i < current_dataset->features[fno].valuecount; i++)
       result += decisiontree_rule_count(&(node->string[i]));
   else
   {
    result += decisiontree_rule_count(node->left);
    result += decisiontree_rule_count(node->right);
   }
   return result;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0xb2e4f(%rip), %rax     # 0xcd870
movl $0x30f08, %r15d         # imm = 0x30F08
addq (%rax), %r15
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
pushq $0x1
popq %rbp
movl 0x30(%rbx), %eax
cmpq %r12, %rax
je 0x1aaa0
testl %eax, %eax
js 0x1aa5c
cmpl $0x2, 0x98(%rbx)
je 0x1aa5c
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, (%r15,%rax)
je 0x1aa6d
movq (%rbx), %rdi
callq 0x1aa12
movq 0x8(%rbx), %rbx
addl %eax, %r14d
jmp 0x1aa39
movl 0x18(%r15,%rax), %eax
xorl %r15d, %r15d
testl %eax, %eax
cmovlel %r15d, %eax
imulq $0x160, %rax, %r12      # imm = 0x160
xorl %ebp, %ebp
cmpq %r15, %r12
je 0x1aaa0
movq 0x10(%rbx), %rdi
addq %r15, %rdi
callq 0x1aa12
addl %eax, %ebp
addq $0x160, %r15            # imm = 0x160
jmp 0x1aa84
addl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: accumulate_instances_tree
void accumulate_instances_tree(Instanceptr* data, Decisionnodeptr root)
{
 /*!Last Changed 28.05.2005 updated according to SVMTREE*/
 /*!Last Changed 24.11.2004 added hybridcondition*/
 /*!Last Changed 27.09.2004 updated to include multivariate nodes*/
 /*!Last Changed 27.10.2003*/
 int i, fno;
 if (root->featureno == LEAF_NODE)
   accumulate_instances_leaf(data, root);
 else
  {
   fno = root->featureno;
   if (fno < 0 || root->conditiontype == HYBRID_CONDITION)
    {
     accumulate_instances_tree(data, root->left);
     accumulate_instances_tree(data, root->right);
    }
   else
     switch (current_dataset->features[fno].type){
       case INTEGER:
       case REAL   :accumulate_instances_tree(data, root->left);
                    accumulate_instances_tree(data, root->right);
                    break;
       case STRING :for (i=0;i<current_dataset->features[fno].valuecount;i++)
                      accumulate_instances_tree(data, &(root->string[i]));
                    break; 
     }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
leaq 0xb2d7f(%rip), %r15     # 0xcd870
movl 0x30(%rbx), %ecx
cmpq %r13, %rcx
je 0x1ab32
testl %ecx, %ecx
js 0x1ab21
cmpl $0x2, 0x98(%rbx)
je 0x1ab21
movq (%r15), %rax
imulq $0x340, %rcx, %r12      # imm = 0x340
movl 0x30f08(%rax,%r12), %ecx
testl %ecx, %ecx
je 0x1ab21
cmpl $0x2, %ecx
jne 0x1ab4b
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1aad3
movq 0x8(%rbx), %rbx
jmp 0x1aaf1
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1aaae
cmpl $0x1, %ecx
jne 0x1ab80
xorl %r13d, %r13d
xorl %ebp, %ebp
movslq 0x30f20(%rax,%r12), %rax
cmpq %rax, %rbp
jge 0x1ab80
movq 0x10(%rbx), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x1aad3
incq %rbp
movq (%r15), %rax
addq $0x160, %r13            # imm = 0x160
jmp 0x1ab55
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/decisiontree.c
// Function: setup_node_properties
BOOLEAN setup_node_properties(Decisionnodeptr node)
{
 int maxcount, classno;
 node->counts = find_class_counts(node->instances);
 classno = all_in_one_class(node->instances, &maxcount);
 node->classno = classno / 10;
 node->covered = data_size(node->instances);
 node->falsepositives = node->covered - maxcount; 
 if (!(classno % 10))
   return BOOLEAN_FALSE;
 else
   return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x108c8
movq %rax, 0xa0(%rbx)
movq 0x20(%rbx), %rdi
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x10916
pushq $0xa
popq %rcx
cltd
idivl %ecx
movl %edx, %ebp
movl %eax, 0x34(%rbx)
movq 0x20(%rbx), %rdi
callq 0x2c3cc
movl %eax, 0x84(%rbx)
subl (%r14), %eax
movl %eax, 0x88(%rbx)
xorl %eax, %eax
testl %ebp, %ebp
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: can_be_divided
int can_be_divided(Decisionnodeptr node, C45_parameterptr p)
{
 /*!Last Changed 10.08.2005 parametre ile prunetype ile threshold kontrol ediliyor*/
 /*!Last Changed 12.04.2003 prepruning eklendi*/
 /*  node->classno = classno/10; satiri eklendi Last Changed 12.04.2003*/
 int size;
 if (!setup_node_properties(node))
  {
   make_leaf_node(node);
   return NO;
  }
 if (p && p->prunetype == PREPRUNING)
  {
   size = data_size(node->instances);
   if ((size + 0.0) / current_dataset->traincount < p->pruningthreshold)
    {
     make_leaf_node(node);
     return NO;
    }
  }
 return YES;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1ab8f
testl %eax, %eax
je 0x1ac3e
pushq $0x1
popq %rbp
testq %r14, %r14
je 0x1ac51
cmpl $0x0, (%r14)
jne 0x1ac51
movq 0x20(%rbx), %rdi
callq 0x2c3cc
cvtsi2sd %eax, %xmm0
leaq 0xb2c4d(%rip), %rax     # 0xcd870
movq (%rax), %rax
cvtsi2sdl 0x1407124(%rax), %xmm1
divsd %xmm1, %xmm0
movsd 0x8(%r14), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1ac51
orl $-0x1, 0x30(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: instance_value_equal_to_split
int instance_value_equal_to_split(Decisionnodeptr currentnode, Instanceptr tmp)
{
 /*!Last Changed 27.09.2004*/
 double value;
 if (currentnode->featureno >= 0)
   if (currentnode->conditiontype != HYBRID_CONDITION)
    {
     switch (current_dataset->features[currentnode->featureno].type)
      {
       case INTEGER:if (tmp->values[currentnode->featureno].intvalue == currentnode->split)
                      return YES;
                    else
                      return NO;
                    break;
       case    REAL:if (tmp->values[currentnode->featureno].floatvalue >= currentnode->split - 0.0001 && tmp->values[currentnode->featureno].floatvalue <= currentnode->split + 0.0001)
                      return YES;
                    else
                      return NO;
                    break;
      }
    }
   else
    {
     value = real_feature(tmp, currentnode->featureno);
     if (value >= currentnode->split - 0.0001 && value <= currentnode->split + 0.0001)
       return YES;
     else
       return NO;
    }
 else
  {
   value = multiply_with_matrix(tmp, currentnode->w);
   if (value >= currentnode->w0 - 0.0001 && value <= currentnode->w0 + 0.0001)
     return YES;
   else
     return NO;
  }
 return NO;
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movslq 0x30(%rdi), %rsi
testq %rsi, %rsi
js 0x1ae73
cmpl $0x2, 0x98(%rbx)
jne 0x1aeb6
movq %rax, %rdi
callq 0x2aea2
movsd 0x28(%rbx), %xmm1
jmp 0x1ae88
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
movq %rax, %rdi
callq 0x2b0c0
movsd 0x48(%rbx), %xmm1
movsd 0x7ca10(%rip), %xmm2    # 0x978a0
addsd %xmm1, %xmm2
addsd 0x7ca0c(%rip), %xmm1    # 0x978a8
cmplepd %xmm0, %xmm2
cmplepd %xmm1, %xmm0
andpd %xmm2, %xmm0
movd %xmm0, %eax
movzbl %al, %eax
andl $0x1, %eax
popq %rbx
retq
leaq 0xb29b3(%rip), %rcx     # 0xcd870
movq (%rcx), %rcx
imulq $0x340, %rsi, %rdx      # imm = 0x340
movl 0x30f08(%rcx,%rdx), %ecx
cmpl $0x2, %ecx
je 0x1aeef
testl %ecx, %ecx
jne 0x1af24
movq (%rax), %rax
cvtsi2sdl (%rax,%rsi,8), %xmm0
cmpeqsd 0x28(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x1aeae
movq (%rax), %rax
movsd 0x28(%rbx), %xmm0
movsd 0x7c9a1(%rip), %xmm1    # 0x978a0
addsd %xmm0, %xmm1
addsd 0x7c99d(%rip), %xmm0    # 0x978a8
movsd (%rax,%rsi,8), %xmm2
cmplepd %xmm2, %xmm1
cmplepd %xmm0, %xmm2
andpd %xmm1, %xmm2
movd %xmm2, %eax
jmp 0x1aeae
xorl %eax, %eax
jmp 0x1aeae
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: is_smaller_discrete_order
int is_smaller_discrete_order(Instanceptr inst, Korderingsplit ksplit)
{
 int i, j, fvalue, fno;
 for (i = 0; i < ksplit.featurecount; i++)
  {
   fno = ksplit.featurelist[i];
   fvalue = inst->values[fno].stringindex;
   if (fvalue == ksplit.sortorder[i][ksplit.discretesplit[i]])
     continue;
   for (j = 0; j < ksplit.discretesplit[i]; j++)
     if (fvalue == ksplit.sortorder[i][j])
       return YES;
   return NO;
  }
 return YES;
}

// Assembly:
pushq %rbx
movl 0x10(%rsp), %ecx
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %r10
xorl %ebx, %ebx
testl %ecx, %ecx
cmovlel %ebx, %ecx
movl $0x1, %eax
cmpq %rbx, %rcx
je 0x1af88
movslq (%rdx,%rbx,4), %rsi
movq (%rdi), %r9
movl (%r9,%rsi,8), %esi
movq (%r8,%rbx,8), %r9
movslq (%r10,%rbx,4), %r11
incq %rbx
cmpl (%r9,%r11,4), %esi
je 0x1af48
xorl %ecx, %ecx
testl %r11d, %r11d
cmovlel %ecx, %r11d
cmpq %rcx, %r11
je 0x1af86
leaq 0x1(%rcx), %rdx
cmpl (%r9,%rcx,4), %esi
movq %rdx, %rcx
jne 0x1af72
jmp 0x1af88
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: svm_split_value
double svm_split_value(Instanceptr inst, Svm_split s)
{
 /*!Last Changed 28.05.2005*/
 int i;
 double value = 0;
 Svm_nodeptr x;
 x = instance_to_svmnode(inst);
 for (i = 0; i < s.l; i++)
   value += s.sv_coef[i] * k_function(x, s.SV[i], s.param);
 value -= s.rho;
 safe_free(x);
 return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x90(%rsp), %rbx
callq 0x2add8
movq %rax, %r14
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
pushq $0xb
popq %r15
movslq 0x58(%rbx), %rax
cmpq %rax, %r12
jge 0x1b140
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
movsd (%rcx,%r12,8), %xmm1
movsd %xmm1, 0x60(%rsp)
movq (%rax,%r12,8), %rax
movq %r15, %rcx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rax, %rsi
movsd %xmm0, 0x58(%rsp)
callq 0x8591e
mulsd 0x60(%rsp), %xmm0
movsd 0x58(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x58(%rsp)
movsd 0x58(%rsp), %xmm0
incq %r12
jmp 0x1b0e1
subsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x58(%rsp)
movq %r14, %rdi
callq 0x34ff7
movsd 0x58(%rsp), %xmm0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: test_tree
int test_tree(Decisionnodeptr root, Instanceptr testingdata)
{
 /*!Last Changed 01.11.2005*/
 /*!Last Changed 26.09.2004*/
 /*!Last Changed 22.03.2002*/
 int i, performance = 0;
 Instanceptr test = testingdata;
 Decisionnodeptr currentnode;
 while (test)
  {
   currentnode = root;
   while (currentnode->featureno != LEAF_NODE)
     currentnode = next_node(currentnode, test); 
   i = give_classno(test);
   if (i == currentnode->classno)
     performance++;
   test = test->next;
  }
 return performance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x1b1ac
movq %r14, %r15
cmpl $-0x1, 0x30(%r15)
je 0x1b193
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1af8a
movq %rax, %r15
jmp 0x1b17c
movq %rbx, %rdi
callq 0x2b47e
xorl %ecx, %ecx
cmpl 0x34(%r15), %eax
sete %cl
addl %ecx, %ebp
movq 0x10(%rbx), %rbx
jmp 0x1b174
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: deallocate_tree_rule
void deallocate_tree_rule(Decisionnodeptr node)
{
 /*!Last Changed 29.11.2004*/
 int i;
 if (node->rule)
  {
   for (i = 0; i < node->conditioncount; i++)
			 {
     if (in_list(node->rule[i].featureindex, 2, LINEARRULE, QUADRATICRULE))
       matrix_free(node->rule[i].w);
					if (node->rule[i].featureindex == DISCRETEMIX)
						 deallocate_korderingsplit(node->rule[i].ksplit);
				}
   safe_free(node->rule);
  }
}

// Assembly:
cmpq $0x0, 0x58(%rdi)
je 0x1b263
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $0x50
popq %r12
pushq $0x2
popq %rbp
pushq $-0x2
popq %r14
pushq $-0x3
popq %r15
xorl %r13d, %r13d
movslq 0x80(%rbx), %rax
movq 0x58(%rbx), %rdi
cmpq %rax, %r13
jge 0x1b250
movl -0x50(%rdi,%r12), %edi
movl %ebp, %esi
movl %r14d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x1b222
movq 0x58(%rbx), %rax
movq -0x30(%rax,%r12), %rdi
movq -0x28(%rax,%r12), %rsi
callq 0x3929f
movq 0x58(%rbx), %rax
cmpl $-0x5, -0x50(%rax,%r12)
jne 0x1b247
movups (%rax,%r12), %xmm0
movups 0x10(%rax,%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1b264
incq %r13
addq $0x70, %r12
jmp 0x1b1e7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: deallocate_korderingsplit
void deallocate_korderingsplit(Korderingsplit ksplit)
{
	int i;
 safe_free(ksplit.featurelist);
 safe_free(ksplit.discretesplit);
 for (i = 0; i < ksplit.featurecount; i++)
   safe_free(ksplit.sortorder[i]);
 safe_free(ksplit.sortorder);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x28(%rsp), %rdi
callq 0x34ff7
movq 0x30(%rsp), %rdi
callq 0x34ff7
movslq 0x20(%rsp), %r14
movq 0x38(%rsp), %rbx
xorl %r15d, %r15d
cmpq %r14, %r15
jge 0x1b29d
movq (%rbx,%r15,8), %rdi
callq 0x34ff7
incq %r15
jmp 0x1b28a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: free_children
void free_children(Decisionnodeptr node)
{
 /*!Last Changed 20.04.2008*/
 /*!Last Changed 24.05.2006*/
 int i, fno = node->featureno;
 if (fno >= 0 && (node->conditiontype != HYBRID_CONDITION) && current_dataset->features[fno].type == STRING)
  {
   for (i = 0; i < current_dataset->features[fno].valuecount; i++)
     deallocate_tree(&(node->string[i]));
   safe_free(node->string);
   node->string = NULL;
  }
 else
  {
   deallocate_tree(node->left);
   safe_free(node->left);
   node->left = NULL;
   deallocate_tree(node->right);
   safe_free(node->right); 
   node->right = NULL;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x30(%rdi), %rcx
testq %rcx, %rcx
js 0x1b499
cmpl $0x2, 0x98(%rbx)
je 0x1b499
leaq 0xb241d(%rip), %r14     # 0xcd870
movq (%r14), %rax
imulq $0x340, %rcx, %r15      # imm = 0x340
cmpl $0x1, 0x30f08(%rax,%r15)
jne 0x1b499
addq $0x10, %rbx
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x30f20(%rax,%r15), %rax
movq (%rbx), %rdi
cmpq %rax, %r13
jge 0x1b4c1
addq %r12, %rdi
callq 0x1b2aa
incq %r13
movq (%r14), %rax
addq $0x160, %r12            # imm = 0x160
jmp 0x1b472
movq (%rbx), %rdi
callq 0x1b2aa
movq (%rbx), %rdi
callq 0x34ff7
andq $0x0, (%rbx)
leaq 0x8(%rbx), %r14
movq 0x8(%rbx), %rdi
callq 0x1b2aa
movq 0x8(%rbx), %rdi
movq %r14, %rbx
callq 0x34ff7
andq $0x0, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: entropy
double entropy(int* counts)
{
 double p, result = 0.0;
 int i, sum = 0;
 for (i = 0; i < current_dataset->classno; i++)
   sum += counts[i];
 for (i = 0; i < current_dataset->classno; i++)
   if (counts[i] > 0 && sum > 0)
    {
     p = counts[i] / (sum + 0.0);
     result -= p * log2(p);
    }
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xb21c8(%rip), %r14     # 0xcd870
movq (%r14), %rax
movl 0x10(%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
xorl %ebp, %ebp
cmpq %rcx, %rdx
je 0x1b6c9
addl (%rbx,%rcx,4), %ebp
incq %rcx
jmp 0x1b6bc
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0x1b730
movl (%rbx,%r15,4), %ecx
testl %ecx, %ecx
jle 0x1b72b
testl %ebp, %ebp
jle 0x1b72b
cvtsi2sd %ecx, %xmm1
divsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, (%rsp)
movapd %xmm1, %xmm0
callq 0x34d77
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
movq (%r14), %rax
movl 0x10(%rax), %eax
incq %r15
jmp 0x1b6da
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: information_gain_from_ratios
double information_gain_from_ratios(int ratio[MAXVALUES][MAXCLASSES])
{
/*!Last Changed 23.04.2003*/
 int i, j, howmany = 0;
 double totalover, totalunder, sum[MAXVALUES], res[MAXVALUES], p;
 totalover = 0;
 totalunder = 0;
 for (i = 0; i < MAXVALUES; i++)
  {
   sum[i] = 0;
   for (j = 0; j < current_dataset->classno; j++)
     sum[i] += ratio[i][j];
   res[i] = 0;
   if (sum[i] > 0)
    {
     for (j = 0; j < current_dataset->classno; j++)
       if (ratio[i][j] > 0)
        {
         p = ratio[i][j] / (sum[i] + 0.0);
         res[i] -= p * log2(p);
        }
     howmany++;
    }
   totalunder += sum[i];
   totalover += sum[i] * res[i];
  }
 if (totalunder == 0 || howmany == 1)
   return ISELL;
 else
   return totalover / totalunder;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r14d, %r14d
leaq 0xb2112(%rip), %r15     # 0xcd870
xorl %ebp, %ebp
xorpd %xmm3, %xmm3
cmpq $0x64, %r14
je 0x1b829
movq (%r15), %rax
movl 0x10(%rax), %eax
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
xorpd %xmm1, %xmm1
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x1b797
cvtsi2sdl (%rbx,%rdx,4), %xmm0
addsd %xmm0, %xmm1
incq %rdx
jmp 0x1b784
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x1b802
xorl %r12d, %r12d
movsd %xmm3, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x1b800
movl (%rbx,%r12,4), %ecx
testl %ecx, %ecx
jle 0x1b7fb
cvtsi2sd %ecx, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd %xmm2, 0x28(%rsp)
callq 0x34d77
movsd 0x28(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm3
mulsd 0x20(%rsp), %xmm0
subsd %xmm0, %xmm2
movq (%r15), %rax
movl 0x10(%rax), %eax
incq %r12
jmp 0x1b7b0
incl %ebp
addsd %xmm1, %xmm3
mulsd %xmm1, %xmm2
movsd 0x8(%rsp), %xmm0
addsd %xmm2, %xmm0
movsd %xmm0, 0x8(%rsp)
incq %r14
addq $0xc8, %rbx
jmp 0x1b764
xorpd %xmm1, %xmm1
cmpeqsd %xmm3, %xmm1
movsd 0x7a4be(%rip), %xmm0    # 0x95cf8
movapd %xmm0, %xmm2
cmpl $0x1, %ebp
je 0x1b84d
movsd 0x8(%rsp), %xmm2
divsd %xmm3, %xmm2
movapd %xmm1, %xmm3
andnpd %xmm2, %xmm3
andpd %xmm1, %xmm0
orpd %xmm3, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: find_subtree_class_counts
void find_subtree_class_counts(Decisionnodeptr subtree, int* counts)
{
 /*!Last Changed 10.02.2005*/
 int* classcounts, i;
 if (subtree->featureno == LEAF_NODE)
  {
   classcounts = find_class_counts(subtree->instances);
   for (i = 0; i < current_dataset->classno; i++)
     counts[i] += classcounts[i];
   safe_free(classcounts);
  }
 else
  {
   find_subtree_class_counts(subtree->left, counts);
   find_subtree_class_counts(subtree->right, counts);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $-0x1, 0x30(%r14)
je 0x1b88c
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1b86a
movq 0x8(%r14), %r14
jmp 0x1b874
movq 0x20(%r14), %rdi
callq 0x108c8
leaq 0xb1fd4(%rip), %rcx     # 0xcd870
movq (%rcx), %rcx
xorl %edx, %edx
movslq 0x10(%rcx), %rsi
cmpq %rsi, %rdx
jge 0x1b8b5
movl (%rax,%rdx,4), %esi
addl %esi, (%rbx,%rdx,4)
incq %rdx
jmp 0x1b8a1
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: subtree_covered_and_false_positives
void subtree_covered_and_false_positives(Decisionnodeptr root, int* C, int* fp)
{
 /*!Last Changed 10.02.2005*/
 if (root->featureno == LEAF_NODE)
  {
   *C += root->covered;
   *fp += root->falsepositives;
  }
 else
  {
   subtree_covered_and_false_positives(root->left, C, fp);
   subtree_covered_and_false_positives(root->right, C, fp);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $-0x1, 0x30(%r15)
je 0x1b8ed
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1b8c4
movq 0x8(%r15), %r15
jmp 0x1b8d2
movl 0x84(%r15), %eax
addl %eax, (%r14)
movl 0x88(%r15), %eax
addl %eax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_loglikelihood
double decisiontree_loglikelihood(Decisionnodeptr root)
{
 /*!Last Changed 10.02.2005*/
 int* classcounts;
 double loglikelihood;
 if (root->featureno == LEAF_NODE)
  {
   classcounts = find_class_counts(root->instances);
   loglikelihood = log_likelihood_for_classification(classcounts);
   safe_free(classcounts);
   return loglikelihood;
  }
 else
   return decisiontree_loglikelihood(root->left) + decisiontree_loglikelihood(root->right);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x30(%rdi)
je 0x1b933
movq (%rbx), %rdi
callq 0x1b906
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
callq 0x1b906
addsd 0x8(%rsp), %xmm0
jmp 0x1b95b
movq 0x20(%rbx), %rdi
callq 0x108c8
movq %rax, %rbx
movq %rax, %rdi
callq 0x1b961
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x34ff7
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: log_likelihood_for_classification
double log_likelihood_for_classification(int classcounts[])
{
 /*!Last Changed 22.11.2004*/
 int i, sum = 0;
 double result = 0, p;
 for (i = 0; i < current_dataset->classno; i++)
   sum += classcounts[i];
 for (i = 0; i < current_dataset->classno; i++)
   if (classcounts[i] != 0)
    {
     p = classcounts[i] / (sum + 0.0);
     result += classcounts[i] * log2(p);
    }
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0xb1efc(%rip), %r14     # 0xcd870
movq (%r14), %rax
movl 0x10(%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
xorl %esi, %esi
cmpq %rcx, %rdx
je 0x1b995
addl (%rbx,%rcx,4), %esi
incq %rcx
jmp 0x1b988
cvtsi2sd %esi, %xmm0
movsd %xmm0, 0x10(%rsp)
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0x1b9fc
movl (%rbx,%r15,4), %ecx
testl %ecx, %ecx
je 0x1b9f7
cvtsi2sd %ecx, %xmm1
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
divsd 0x10(%rsp), %xmm0
callq 0x34d77
mulsd 0x18(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq (%r14), %rax
movl 0x10(%rax), %eax
incq %r15
jmp 0x1b9a6
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: information_gain
double information_gain(int ratio[2][MAXCLASSES])
{
 int sum[2] = {0,0},i,j;
 double res[2] = {0,0},p;
 for (j = 0; j < 2; j++)
  {
   for (i = 0; i < current_dataset->classno; i++)
     sum[j] += ratio[j][i];
   if (sum[j] == 0)
     return ISELL;
   for (i = 0; i < current_dataset->classno; i++)
     if (ratio[j][i] > 0)
      {
       p = ratio[j][i] / (sum[j] + 0.0);
       res[j] -= p * log2(p);
      }
  }
 return (res[0] * sum[0] + res[1] * sum[1]) / (sum[0] + sum[1]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
xorl %r14d, %r14d
leaq 0xb1e44(%rip), %r15     # 0xcd870
movsd 0x7a2c4(%rip), %xmm0    # 0x95cf8
cmpq $0x2, %r14
je 0x1badb
movq (%r15), %rax
movl 0x10(%rax), %eax
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x1ba62
movl (%rbx,%rdx,4), %esi
addl %esi, 0x8(%rsp,%r14,4)
incq %rdx
jmp 0x1ba50
movl 0x8(%rsp,%r14,4), %ecx
testl %ecx, %ecx
je 0x1bb05
cvtsi2sd %ecx, %xmm1
movsd %xmm1, 0x28(%rsp)
xorl %r12d, %r12d
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x1bacc
movl (%rbx,%r12,4), %ecx
testl %ecx, %ecx
jle 0x1bac7
cvtsi2sd %ecx, %xmm0
divsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
callq 0x34d77
movsd 0x10(%rsp,%r14,8), %xmm1
mulsd 0x30(%rsp), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp,%r14,8)
movsd 0x7a237(%rip), %xmm0    # 0x95cf8
movq (%r15), %rax
movl 0x10(%rax), %eax
incq %r12
jmp 0x1ba7c
incq %r14
addq $0xc8, %rbx
jmp 0x1ba34
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
cvtsi2sd %eax, %xmm0
cvtsi2sd %ecx, %xmm1
mulsd 0x18(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm0
addl %eax, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: get_initial_partition
Partition get_initial_partition(Instanceptr instances)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 26.01.2003*/
 Partition result;
 int i, count;
 result.classes = get_classes(instances, &count);
 result.count = count;
 result.assignments = (int *)safemalloc(count*sizeof(int), "get_initial_partition", 5);
 if (count == 2)
  {
   result.assignments[0] = LEFT;
   result.assignments[1] = RIGHT;
  }
 else
   for (i = 0; i < count; i++)
     result.assignments[i] = myrand() % 2;
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x2d6e6
movq %rax, (%rbx)
movslq (%r15), %rdi
movl %edi, 0x10(%rbx)
shlq $0x2, %rdi
leaq 0x7bcf7(%rip), %rsi     # 0x978d2
pushq $0x5
popq %rdx
callq 0x34f59
movq %rax, %r14
movq %rax, 0x8(%rbx)
movl (%r15), %eax
cmpl $0x2, %eax
jne 0x1bc0d
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x2
popq %rbp
xorl %r15d, %r15d
cltq
cmpq %rax, %r15
jge 0x1bbff
xorl %eax, %eax
callq 0x35c7f
cltd
idivl %ebp
movl %edx, (%r14,%r15,4)
incq %r15
movl 0x4(%rsp), %eax
jmp 0x1bc13
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: get_start_partition
Partition get_start_partition(Instanceptr instances, int leftclass)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 29.12.2003*/
 /*!Last Changed 04.02.2003*/
 Partition result;
 int i, count;
 result.classes = get_classes(instances, &count);
 result.count = count;
 result.assignments = (int *)safemalloc(count*sizeof(int), "get_start_partition", 5);
 for (i = 0; i < count; i++)
   result.assignments[i] = RIGHT;
 for (i = 0; i < count; i++)
   if (result.classes[i] == leftclass)
    {
     result.assignments[i] = LEFT;
     break;
    }
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x4(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x2d6e6
movq %rax, %r14
movq %rax, (%rbx)
movslq (%r15), %rdi
movl %edi, 0x10(%rbx)
shlq $0x2, %rdi
leaq 0x7bc84(%rip), %rsi     # 0x978e8
pushq $0x5
popq %rdx
callq 0x34f59
movq %rax, 0x8(%rbx)
xorl %edx, %edx
movslq 0x4(%rsp), %rcx
cmpq %rcx, %rdx
jge 0x1bc88
movl $0x1, (%rax,%rdx,4)
incq %rdx
jmp 0x1bc72
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0x1bca6
leaq 0x1(%rdx), %rsi
cmpl %ebp, (%r14,%rdx,4)
movq %rsi, %rdx
jne 0x1bc8f
andl $0x0, -0x4(%rax,%rsi,4)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: soft_output_of_subdecisiontree
double soft_output_of_subdecisiontree(Decisionnodeptr subtree, double input1, double input2)
{
 double weight, output, multiplier;
 Decisionnodeptr tmpnode;
 if (subtree->featureno == LEAF_NODE)
  {
   if (subtree->leaftype == CONSTANTLEAF)
     output = subtree->w0;    
   else
     output = subtree->w.values[0][0] + subtree->w.values[1][0] * input1 + subtree->w.values[2][0] * input2; 
   multiplier = 1.0;
   tmpnode = subtree;
   while (tmpnode->parent)
    {
     weight = sigmoid(tmpnode->parent->w.values[0][0] + tmpnode->parent->w.values[1][0] * input1 + tmpnode->parent->w.values[2][0] * input2);
     if (tmpnode == tmpnode->parent->left)
       multiplier *= weight;
     else
       multiplier *= (1 - weight);
     tmpnode = tmpnode->parent;
    }
   return output * multiplier;   
  }
 else
   return soft_output_of_subdecisiontree(subtree->left, input1, input2) + soft_output_of_subdecisiontree(subtree->right, input1, input2);   
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x30(%rdi)
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
je 0x1bcfa
movq (%rbx), %rdi
callq 0x1bcb4
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x1bcb4
addsd (%rsp), %xmm0
jmp 0x1bdb9
cmpl $0x0, 0x60(%rbx)
je 0x1bd2f
movq 0x40(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movsd (%rdx), %xmm2
mulsd %xmm0, %xmm2
addsd (%rcx), %xmm2
movq 0x10(%rax), %rax
movsd (%rax), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x8(%rsp)
jmp 0x1bd3a
movsd 0x48(%rbx), %xmm2
movsd %xmm2, 0x8(%rsp)
movsd 0x797de(%rip), %xmm2    # 0x95520
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1bdaf
movsd %xmm2, (%rsp)
movq 0x40(%rax), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movsd (%rdx), %xmm2
mulsd %xmm0, %xmm2
addsd (%rcx), %xmm2
movq 0x10(%rax), %rax
movsd (%rax), %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
callq 0x4dd58
movq 0x18(%rbx), %rax
cmpq (%rax), %rbx
je 0x1bd95
movsd 0x79793(%rip), %xmm1    # 0x95520
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
movq %rax, %rbx
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
jmp 0x1bd42
movsd 0x8(%rsp), %xmm0
mulsd %xmm2, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: depth_of_tree
int depth_of_tree(Decisionnodeptr node)
{
 /*!Last Changed 12.07.2006*/
 int i, maxdepth, depth, leftdepth, rightdepth;
 if (node->featureno == LEAF_NODE)
   return 1;
 else
  {
   if (node->featureno >= 0 && current_dataset->features[node->featureno].type == STRING)
    {
     maxdepth = -1;
     for (i = 0; i < current_dataset->features[node->featureno].valuecount; i++)
      { 
       depth = depth_of_tree(&(node->string[i]));
       if (depth > maxdepth)
         maxdepth = depth;
      }
     return maxdepth + 1;
    }
   else
    {
     leftdepth = depth_of_tree(node->left);
     rightdepth = depth_of_tree(node->right);
     if (leftdepth >= rightdepth)
       return leftdepth + 1;
     else
       return rightdepth + 1;     
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x30(%rdi), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0x1be57
movq %rdi, %rbx
testl %eax, %eax
js 0x1be36
leaq 0xb1a8b(%rip), %rcx     # 0xcd870
movq (%rcx), %rcx
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rax)
jne 0x1be36
addq $0x30f08, %rcx          # imm = 0x30F08
movl 0x18(%rcx,%rax), %eax
xorl %r14d, %r14d
testl %eax, %eax
cmovlel %r14d, %eax
imulq $0x160, %rax, %r15      # imm = 0x160
pushq $-0x1
popq %rbp
cmpq %r14, %r15
je 0x1be53
movq 0x10(%rbx), %rdi
addq %r14, %rdi
callq 0x1bdbf
cmpl %ebp, %eax
cmovgl %eax, %ebp
addq $0x160, %r14            # imm = 0x160
jmp 0x1be17
movq (%rbx), %rdi
callq 0x1bdbf
movl %eax, %ebp
movq 0x8(%rbx), %rdi
callq 0x1bdbf
cmpl %eax, %ebp
jge 0x1be53
incl %eax
movl %eax, %ebp
jmp 0x1be5a
incl %ebp
jmp 0x1be5a
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: inorder_traversal_decision_tree
void inorder_traversal_decision_tree(Decisionnodeptr node, int* index)
{
 int i;
 if (node)
  {
   if (node->featureno >= 0 && current_dataset->features[node->featureno].type == STRING)
    {   
     for (i = 0; i < current_dataset->features[node->featureno].valuecount / 2; i++)
       inorder_traversal_decision_tree(&(node->string[i]), index);
     node->x = *index;
     (*index)++;     
     for (i = current_dataset->features[node->featureno].valuecount / 2; i < current_dataset->features[node->featureno].valuecount; i++)
       inorder_traversal_decision_tree(&(node->string[i]), index);
    }
   else
    {
     inorder_traversal_decision_tree(node->left, index);
     node->x = *index;
     (*index)++;
     inorder_traversal_decision_tree(node->right, index);        
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb19f1(%rip), %r15     # 0xcd870
testq %r14, %r14
je 0x1bf72
movslq 0x30(%r14), %rax
testq %rax, %rax
js 0x1bea5
movq (%r15), %rcx
imulq $0x340, %rax, %rdx      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rdx)
je 0x1bec3
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1be67
movl (%rbx), %eax
movl %eax, 0x134(%r14)
incl %eax
movl %eax, (%rbx)
movq 0x8(%r14), %r14
jmp 0x1be7f
xorl %r12d, %r12d
pushq $0x2
popq %rbp
xorl %r13d, %r13d
cltq
imulq $0x340, %rax, %rax      # imm = 0x340
movl 0x30f20(%rcx,%rax), %eax
cltd
idivl %ebp
cltq
cmpq %rax, %r13
jge 0x1bf08
movq 0x10(%r14), %rdi
addq %r12, %rdi
movq %rbx, %rsi
callq 0x1be67
incq %r13
movq (%r15), %rcx
movl 0x30(%r14), %eax
addq $0x160, %r12            # imm = 0x160
jmp 0x1becc
addq $0x30f08, %rcx          # imm = 0x30F08
movl (%rbx), %eax
movl %eax, 0x134(%r14)
incl %eax
movl %eax, (%rbx)
movslq 0x30(%r14), %rax
imulq $0x340, %rax, %rax      # imm = 0x340
movl 0x18(%rcx,%rax), %ecx
movl %ecx, %eax
cltd
idivl %ebp
movslq %eax, %r12
imulq $0x160, %r12, %r13      # imm = 0x160
movslq %ecx, %rax
cmpq %rax, %r12
jge 0x1bf72
movq 0x10(%r14), %rdi
addq %r13, %rdi
movq %rbx, %rsi
callq 0x1be67
incq %r12
movq (%r15), %rax
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f20(%rax,%rcx), %ecx
addq $0x160, %r13            # imm = 0x160
jmp 0x1bf3a
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/decisiontree.c
// Function: level_of_decision_tree
void level_of_decision_tree(Decisionnodeptr node)
{
 int i;
 if (node)
  {
   if (node->parent)
     node->y = node->parent->y + 1;
   else
     node->y = 0;
   if (node->featureno >= 0 && current_dataset->features[node->featureno].type == STRING)
     for (i = 0; i < current_dataset->features[node->featureno].valuecount; i++)
       level_of_decision_tree(&(node->string[i]));
   else
    {
     level_of_decision_tree(node->left);
     level_of_decision_tree(node->right);       
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb18dd(%rip), %r14     # 0xcd870
testq %rbx, %rbx
je 0x1c01c
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1bfaf
movl 0x138(%rax), %eax
incl %eax
jmp 0x1bfb1
xorl %eax, %eax
movl %eax, 0x138(%rbx)
movslq 0x30(%rbx), %rax
testq %rax, %rax
js 0x1bfd4
movq (%r14), %rcx
imulq $0x340, %rax, %rdx      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rdx)
je 0x1bfe2
movq (%rbx), %rdi
callq 0x1bf81
movq 0x8(%rbx), %rbx
jmp 0x1bf93
xorl %r15d, %r15d
xorl %r12d, %r12d
cltq
imulq $0x340, %rax, %rax      # imm = 0x340
movslq 0x30f20(%rcx,%rax), %rax
cmpq %rax, %r12
jge 0x1c01c
movq 0x10(%rbx), %rdi
addq %r15, %rdi
callq 0x1bf81
incq %r12
movq (%r14), %rcx
movl 0x30(%rbx), %eax
addq $0x160, %r15            # imm = 0x160
jmp 0x1bfe8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/decisiontree.c
// Function: leaf_distribution
void leaf_distribution(Decisionnodeptr rootnode, int* counts)
{
 /*!Last Changed 01.10.2006 added decisiontree with single leaf node*/
 /*!Last Changed 13.07.2006*/
 int level, index;
 if (rootnode->featureno == LEAF_NODE)
  {
   level = level_of_node(rootnode);
   if (level == 0)
     index = 1;
   else
     if (rootnode->parent->left == rootnode) 
       if (rootnode->parent->right->featureno == LEAF_NODE)
         index = 2 * level;
       else
         index = 2 * level + 1;
     else
       if (rootnode->parent->left->featureno == LEAF_NODE)
         index = 2 * level;
       else
         index = 2 * level + 1;
   counts[index - 1]++;
  }
 else
  {
   leaf_distribution(rootnode->left, counts);
   leaf_distribution(rootnode->right, counts);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $-0x1, 0x30(%r14)
je 0x1c059
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1c037
movq 0x8(%r14), %r14
jmp 0x1c041
movq %r14, %rdi
callq 0x1c028
testl %eax, %eax
je 0x1c085
movq 0x18(%r14), %rdx
movq (%rdx), %rcx
cmpq %r14, %rcx
jne 0x1c075
movq 0x8(%rdx), %rcx
xorl %edx, %edx
cmpl $-0x1, 0x30(%rcx)
setne %dl
leal (%rdx,%rax,2), %eax
cltq
jmp 0x1c088
pushq $0x1
popq %rax
incl -0x4(%rbx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dimreduction.c
// Function: dimension_reduction_pca
Instanceptr dimension_reduction_pca(Datasetptr d, Instanceptr traindata, void* parameters, Datasetptr* new_dataset, char* new_dataset_name)
{
 /*!Last Changed 16.01.2008*/
 int howmany = 0;
 matrix eigenvectors, cov;
 double *eigenvalues;
 Instance mean;
 Pca_parameterptr ppca = (Pca_parameterptr) parameters;
 Instanceptr newlist;
 mean = find_mean(traindata);
 cov = covariance(traindata, mean);
 safe_free(mean.values);
 switch (ppca->reduction_type)
  {
   case REDUCTION_TYPE_FEATURE :eigenvalues = find_eigenvalues_eigenvectors_symmetric(&eigenvectors, cov);
                                if (ppca->featurecount <= d->multifeaturecount - 1)
                                  howmany = ppca->featurecount;
                                break;
   case REDUCTION_TYPE_VARIANCE:eigenvalues = find_eigenvalues_eigenvectors(&eigenvectors, cov, &howmany, ppca->variance_explained);
                                break;
  }
 safe_free(eigenvalues);
 newlist = reduce_dimension_of_instancelist(traindata, howmany, eigenvectors);
 *new_dataset = dimension_reduced_dataset(d, howmany + 1, newlist, new_dataset_name);
 matrix_free(eigenvectors);
 matrix_free(cov);
 return newlist;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r15
andl $0x0, 0x34(%rsp)
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x116b6
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbp, %rdi
callq 0x106d9
movq %rax, %r12
movq %rdx, %r13
movq (%r14), %rdi
callq 0x34ff7
cmpl $0x0, 0x10(%rbx)
je 0x1c11e
movsd 0x8(%rbx), %xmm0
leaq 0x38(%rsp), %rdi
leaq 0x34(%rsp), %rcx
movq %r12, %rsi
movq %r13, %rdx
callq 0x3c5f6
jmp 0x1c13d
leaq 0x38(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3c5c1
movl (%rbx), %ecx
cmpl 0x1c0(%r15), %ecx
jge 0x1c13d
movl %ecx, 0x34(%rsp)
movq %rax, %rdi
callq 0x34ff7
movl 0x34(%rsp), %esi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq %rbp, %rdi
callq 0x1cc2b
movq %rax, %rbx
movl 0x34(%rsp), %esi
incl %esi
movq %r15, %rdi
movq %rax, %rdx
movq 0x48(%rsp), %rcx
callq 0x1414c
movq 0x50(%rsp), %rcx
movq %rax, (%rcx)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x3929f
movq %r12, %rdi
movq %r13, %rsi
callq 0x3929f
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/dimreduction.c
// Function: dimension_reduction_mds
Instanceptr dimension_reduction_mds(Datasetptr d, Instanceptr traindata, void* parameters, Datasetptr* new_dataset, char* new_dataset_name)
{
 /*!Last Changed 17.01.2008*/
 int howmany;
 matrix eigenvectors, distancematrix, b;
 double *eigenvalues;
 Pca_parameterptr ppca = (Pca_parameterptr) parameters;
 Instanceptr newlist;
 distancematrix = distance_matrix(traindata);
 b = multi_dimensional_scaling(distancematrix);
 matrix_free(distancematrix);
 switch (ppca->reduction_type)
  {
   case REDUCTION_TYPE_FEATURE :eigenvalues = find_eigenvalues_eigenvectors_symmetric(&eigenvectors, b);
                                howmany = ppca->featurecount;
                                break;
   case REDUCTION_TYPE_VARIANCE:eigenvalues = find_eigenvalues_eigenvectors(&eigenvectors, b, &howmany, ppca->variance_explained);
                                break;
  }
 matrix_free(b);
 newlist = reduce_dimension_of_instancelist_mds(traindata, howmany, eigenvectors, eigenvalues);
 *new_dataset = dimension_reduced_dataset(d, howmany + 1, newlist, new_dataset_name);
 return newlist;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movq %rsi, %rdi
callq 0xfdf0
movq %rax, %r14
movq %rdx, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x1cfbb
movq %rax, %r13
movq %rdx, %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x3929f
movl 0x10(%rbx), %eax
cmpl $0x1, %eax
je 0x1c39f
testl %eax, %eax
jne 0x1c3bc
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x3c5c1
movq %rax, %r14
movl (%rbx), %eax
movl %eax, 0xc(%rsp)
jmp 0x1c3bc
movsd 0x8(%rbx), %xmm0
leaq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rcx
movq %r13, %rsi
movq %rbp, %rdx
callq 0x3c5f6
movq %rax, %r14
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3929f
movl 0xc(%rsp), %esi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq %r12, %rdi
movq %r14, %r8
callq 0x1ce4f
movq %rax, %rbx
movl 0xc(%rsp), %esi
incl %esi
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movq 0x18(%rsp), %rcx
callq 0x1414c
movq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq