LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/datastructure.c
// Function: delete_min
void* delete_min(Heapptr h, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 22.01.2009*/
 void* item;
 if (heap_empty(h))
  {
   printf("Heap is empty\n");
   return NULL;
  }
 item = h->elements[1];
 h->elements[1] = h->elements[(h->count)--];
 percolate_down(h, 1, compare);
 return item;
}

// Assembly:
pushq %rbx
movslq 0x1f40(%rdi), %rax
testq %rax, %rax
je 0x1c551
movq %rsi, %rdx
movq 0x8(%rdi), %rbx
leal -0x1(%rax), %ecx
movl %ecx, 0x1f40(%rdi)
movq (%rdi,%rax,8), %rax
movq %rax, 0x8(%rdi)
movl $0x1, %esi
callq 0x1c564
jmp 0x1c55f
leaq 0x8b39e(%rip), %rdi     # 0xa78f6
callq 0x4090
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/datastructure.c
// Function: percolate_down
void percolate_down(Heapptr h, int hole, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 22.01.2009*/
 int child;
 void* tmp = h->elements[hole];
 for (; hole * 2 <= h->count; hole = child)
  {
   child = hole * 2;
   if (child != h->count && compare(h->elements[child + 1], h->elements[child]) < 0)
     child++;
   if (compare(h->elements[child], tmp) < 0)
     h->elements[hole] = h->elements[child];
   else
     break;
  }
 h->elements[hole] = tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
movq (%rdi,%r14,8), %rax
movq %rax, (%rsp)
leal (%r14,%r14), %r13d
movl 0x1f40(%rdi), %eax
cmpl %eax, %r13d
jg 0x1c5ec
movq %rdx, %r15
movl %esi, %ebp
movl %eax, %r12d
cmpl %eax, %r13d
je 0x1c5b8
movl %r13d, %r12d
orl $0x1, %r12d
movslq %r12d, %rax
movq (%rbx,%rax,8), %rdi
movslq %r13d, %rax
movq (%rbx,%rax,8), %rsi
callq *%r15
testl %eax, %eax
js 0x1c5b8
movl %r13d, %r12d
movslq %r12d, %r14
movq (%rbx,%r14,8), %rdi
movq (%rsp), %rsi
callq *%r15
testl %eax, %eax
jns 0x1c5e9
movq (%rbx,%r14,8), %rax
movslq %ebp, %rcx
movq %rax, (%rbx,%rcx,8)
leal (%r14,%r14), %r13d
movl 0x1f40(%rbx), %eax
movl %r12d, %ebp
cmpl %eax, %r13d
jle 0x1c591
jmp 0x1c5ec
movslq %ebp, %r14
movq (%rsp), %rax
movq %rax, (%rbx,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_falsepositive_count
int decisiontree_falsepositive_count(Decisionnodeptr node)
{
 /*!Last Changed 20.04.2008*/
 /*!Last Changed 30.09.2007*/
 int result = 0, i, fno;
 if (node->featureno == LEAF_NODE)
   return node->falsepositives;
 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_falsepositive_count(&(node->string[i]));
   else
    {
     result += decisiontree_falsepositive_count(node->left);
     result += decisiontree_falsepositive_count(node->right);
    }
   return result;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x30(%rdi), %ecx
cmpl $-0x1, %ecx
je 0x1cb23
leaq 0xb8d91(%rip), %rax     # 0xd5870
movl $0x30f08, %r15d         # imm = 0x30F08
addq (%rax), %r15
xorl %ebx, %ebx
testl %ecx, %ecx
js 0x1cb08
cmpl $0x2, 0x98(%r14)
je 0x1cb08
movl %ecx, %eax
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, (%r15,%rax)
je 0x1cb3d
movq (%r14), %rdi
callq 0x1cac6
movq 0x8(%r14), %r14
addl %ebx, %eax
movl 0x30(%r14), %ecx
movl %eax, %ebx
cmpl $-0x1, %ecx
jne 0x1caea
jmp 0x1cb25
xorl %eax, %eax
movl 0x88(%r14), %ebp
movl %eax, %ebx
addl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movslq 0x18(%r15,%rax), %r15
testq %r15, %r15
jle 0x1cb65
movq 0x10(%r14), %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1cac6
addl %eax, %ebp
addq $0x160, %r14            # imm = 0x160
decq %r15
jne 0x1cb4d
jmp 0x1cb2e
xorl %ebp, %ebp
jmp 0x1cb2e
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/decisiontree.c
// Function: decisiontree_complexity_count
int decisiontree_complexity_count(Decisionnodeptr node)
{
 /*!Last Changed 24.11.2004*/
 if (node->featureno == LEAF_NODE)
   if (node->leaftype == LINEARLEAF)
     return current_dataset->multifeaturecount - 1;
   else
     return 0;
 else
   if (node->featureno >= 0)
     return 2 + decisiontree_complexity_count(node->left) + decisiontree_complexity_count(node->right);
   else
     if (node->featureno == LINEAR)
       return node->lineard + 1 + decisiontree_complexity_count(node->left) + decisiontree_complexity_count(node->right);
     else
       if (node->featureno == QUADRATIC)
         return node->quadraticd + 1 + decisiontree_complexity_count(node->left) + decisiontree_complexity_count(node->right);
       else
         return current_dataset->multifeaturecount + decisiontree_complexity_count(node->left) + decisiontree_complexity_count(node->right);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movl 0x30(%rbx), %eax
xorl %r12d, %r12d
cmpl $-0x1, %eax
je 0x1cbc1
testl %eax, %eax
js 0x1cb9e
movq (%rbx), %rdi
callq 0x1cb69
movq 0x8(%rbx), %rbx
addl %eax, %r12d
addl $0x2, %r12d
movl 0x30(%rbx), %eax
jmp 0x1cb7d
cmpl $-0x2, %eax
jne 0x1cbea
movq (%rbx), %rdi
addl 0x90(%rbx), %r12d
callq 0x1cb69
movq 0x8(%rbx), %rbx
addl %r12d, %eax
addl %eax, %r15d
incl %r15d
jmp 0x1cb77
xorl %eax, %eax
cmpl $0x1, 0x60(%rbx)
jne 0x1cbdb
leaq 0xb8ca0(%rip), %rax     # 0xd5870
movq (%rax), %rax
movl 0x1c0(%rax), %eax
decl %eax
addl %r12d, %eax
addl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $-0x3, %eax
jne 0x1cc18
movq (%rbx), %rdi
addl 0x94(%rbx), %r12d
callq 0x1cb69
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x1cb69
addl %r12d, %r14d
addl %eax, %r14d
leal (%r15,%r14), %eax
incl %eax
jmp 0x1cbe1
leaq 0xb8c51(%rip), %rax     # 0xd5870
movq (%rax), %rax
movq (%rbx), %rdi
addl 0x1c0(%rax), %r12d
callq 0x1cb69
movl %eax, %ebp
movq 0x8(%rbx), %rdi
callq 0x1cb69
addl %ebp, %eax
addl %r15d, %eax
addl %r12d, %eax
jmp 0x1cbe1
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movl 0x30(%rdi), %ecx
movl $0x1, %ebp
cmpl $-0x1, %ecx
je 0x1ccaa
movq %rdi, %r14
leaq 0xb8c0c(%rip), %rax     # 0xd5870
movl $0x30f08, %r15d         # imm = 0x30F08
addq (%rax), %r15
xorl %eax, %eax
movl %eax, %ebx
testl %ecx, %ecx
js 0x1cc8f
cmpl $0x2, 0x98(%r14)
je 0x1cc8f
movl %ecx, %eax
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, (%r15,%rax)
je 0x1ccbb
movq (%r14), %rdi
callq 0x1cc46
movq 0x8(%r14), %r14
addl %ebx, %eax
movl 0x30(%r14), %ecx
cmpl $-0x1, %ecx
jne 0x1cc6f
movl %eax, %ebx
jmp 0x1ccac
xorl %ebx, %ebx
addl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movslq 0x18(%r15,%rax), %r15
testq %r15, %r15
jle 0x1cce3
movq 0x10(%r14), %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1cc46
addl %eax, %ebp
addq $0x160, %r14            # imm = 0x160
decq %r15
jne 0x1cccb
jmp 0x1ccac
xorl %ebp, %ebp
jmp 0x1ccac
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x30(%rdi), %eax
cmpl $-0x1, %eax
je 0x1cd44
movq %rdi, %r14
leaq 0xb8b70(%rip), %rcx     # 0xd5870
movl $0x30f08, %r15d         # imm = 0x30F08
addq (%rcx), %r15
xorl %ebx, %ebx
testl %eax, %eax
js 0x1cd29
cmpl $0x2, 0x98(%r14)
je 0x1cd29
movl %eax, %eax
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, (%r15,%rax)
je 0x1cd57
movq (%r14), %rdi
callq 0x1cce7
movq 0x8(%r14), %r14
addl %eax, %ebx
incl %ebx
movl 0x30(%r14), %eax
cmpl $-0x1, %eax
jne 0x1cd0b
jmp 0x1cd46
xorl %ebx, %ebx
xorl %ebp, %ebp
addl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movslq 0x18(%r15,%rax), %r15
testq %r15, %r15
jle 0x1cd82
movq 0x10(%r14), %r14
movl $0x1, %ebp
movq %r14, %rdi
callq 0x1cce7
addl %eax, %ebp
addq $0x160, %r14            # imm = 0x160
decq %r15
jne 0x1cd6a
jmp 0x1cd48
movl $0x1, %ebp
jmp 0x1cd48
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %r14
movl 0x30(%rdi), %ecx
cmpl $-0x1, %ecx
je 0x1cde6
leaq 0xb8ace(%rip), %rax     # 0xd5870
movl $0x30f08, %r15d         # imm = 0x30F08
addq (%rax), %r15
xorl %ebx, %ebx
testl %ecx, %ecx
js 0x1cdcb
cmpl $0x2, 0x98(%r14)
je 0x1cdcb
movl %ecx, %eax
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, (%r15,%rax)
je 0x1ce00
movq (%r14), %rdi
callq 0x1cd89
movq 0x8(%r14), %r14
addl %ebx, %eax
movl 0x30(%r14), %ecx
movl %eax, %ebx
cmpl $-0x1, %ecx
jne 0x1cdad
jmp 0x1cde8
xorl %eax, %eax
movl 0x80(%r14), %ebp
movl %eax, %ebx
addl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movslq 0x18(%r15,%rax), %r15
testq %r15, %r15
jle 0x1ce28
movq 0x10(%r14), %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1cd89
addl %eax, %ebp
addq $0x160, %r14            # imm = 0x160
decq %r15
jne 0x1ce10
jmp 0x1cdf1
xorl %ebp, %ebp
jmp 0x1cdf1
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movl 0x30(%rdi), %ecx
movl $0x1, %ebp
cmpl $-0x1, %ecx
je 0x1ce90
movq %rdi, %r14
leaq 0xb8a26(%rip), %rax     # 0xd5870
movl $0x30f08, %r15d         # imm = 0x30F08
addq (%rax), %r15
xorl %eax, %eax
movl %eax, %ebx
testl %ecx, %ecx
js 0x1ce75
cmpl $0x2, 0x98(%r14)
je 0x1ce75
movl %ecx, %eax
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, (%r15,%rax)
je 0x1cea1
movq (%r14), %rdi
callq 0x1ce2c
movq 0x8(%r14), %r14
addl %ebx, %eax
movl 0x30(%r14), %ecx
cmpl $-0x1, %ecx
jne 0x1ce55
movl %eax, %ebx
jmp 0x1ce92
xorl %ebx, %ebx
addl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movslq 0x18(%r15,%rax), %r15
testq %r15, %r15
jle 0x1cec9
movq 0x10(%r14), %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1ce2c
addl %eax, %ebp
addq $0x160, %r14            # imm = 0x160
decq %r15
jne 0x1ceb1
jmp 0x1ce92
xorl %ebp, %ebp
jmp 0x1ce92
// File: /workspace/github_c_makefile_star2_O3/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 0x30(%rsi), %eax
cmpl $-0x1, %eax
je 0x1cf56
leaq 0xb895b(%rip), %r15     # 0xd5870
testl %eax, %eax
js 0x1cf3f
cmpl $0x2, 0x98(%rbx)
je 0x1cf3f
movq (%r15), %rcx
movl %eax, %eax
imulq $0x340, %rax, %r12      # imm = 0x340
movl 0x30f08(%rcx,%r12), %eax
testl %eax, %eax
je 0x1cf3f
cmpl $0x2, %eax
jne 0x1cf8c
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1cef5
movq 0x8(%rbx), %rbx
movl 0x30(%rbx), %eax
cmpl $-0x1, %eax
jne 0x1cf15
movq (%r14), %rax
testq %rax, %rax
je 0x1cf6e
movq %rax, %r14
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x1cf5e
addq $0x10, %r14
movq 0x20(%rbx), %rax
movq %rax, (%r14)
movq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, %eax
jne 0x1cf7d
addq $0x30f08, %rcx          # imm = 0x30F08
cmpl $0x0, 0x18(%rcx,%r12)
jle 0x1cf7d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x10(%rbx), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x1cef5
incq %rbp
movq (%r15), %rax
movslq 0x30f20(%rax,%r12), %rax
addq $0x160, %r13            # imm = 0x160
cmpq %rax, %rbp
jl 0x1cfa5
jmp 0x1cf7d
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x115a6
movq %rax, 0xa0(%rbx)
movq 0x20(%rbx), %rdi
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x115f8
movslq %eax, %r15
imulq $0x66666667, %r15, %rax # imm = 0x66666667
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x22, %rax
addl %ecx, %eax
movl %eax, 0x34(%rbx)
movq 0x20(%rbx), %rdi
callq 0x30309
movl %eax, 0x84(%rbx)
subl (%r14), %eax
movl %eax, 0x88(%rbx)
imull $0xcccccccd, %r15d, %ecx # imm = 0xCCCCCCCD
addl $0x19999998, %ecx       # imm = 0x19999998
rorl %ecx
xorl %eax, %eax
cmpl $0x19999999, %ecx       # imm = 0x19999999
setae %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1cfd0
testl %eax, %eax
je 0x1d0a5
movl $0x1, %ebp
testq %r14, %r14
je 0x1d0be
cmpl $0x0, (%r14)
jne 0x1d0be
movq 0x20(%rbx), %rdi
callq 0x30309
cvtsi2sd %eax, %xmm0
leaq 0xb87e6(%rip), %rax     # 0xd5870
movq (%rax), %rax
cvtsi2sdl 0x1407124(%rax), %xmm1
divsd %xmm1, %xmm0
movsd 0x8(%r14), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1d0be
movl $0xffffffff, 0x30(%rbx) # imm = 0xFFFFFFFF
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1d2f6
cmpl $0x2, 0x98(%rbx)
jne 0x1d339
movq %rax, %rdi
callq 0x2ed6a
movsd 0x28(%rbx), %xmm1
jmp 0x1d30b
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
movq %rax, %rdi
callq 0x2efa4
movsd 0x48(%rbx), %xmm1
movsd 0x8a60d(%rip), %xmm2    # 0xa7920
addsd %xmm1, %xmm2
addsd 0x8a609(%rip), %xmm1    # 0xa7928
cmplepd %xmm0, %xmm2
cmplepd %xmm1, %xmm0
andpd %xmm2, %xmm0
movd %xmm0, %eax
movzbl %al, %eax
andl $0x1, %eax
popq %rbx
retq
leaq 0xb8530(%rip), %rcx     # 0xd5870
movq (%rcx), %rcx
imulq $0x340, %rsi, %rdx      # imm = 0x340
movl 0x30f08(%rcx,%rdx), %ecx
cmpl $0x2, %ecx
je 0x1d372
testl %ecx, %ecx
jne 0x1d3a7
movq (%rax), %rax
cvtsi2sdl (%rax,%rsi,8), %xmm0
cmpeqsd 0x28(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x1d331
movq (%rax), %rax
movsd 0x28(%rbx), %xmm0
movsd 0x8a59e(%rip), %xmm1    # 0xa7920
addsd %xmm0, %xmm1
addsd 0x8a59a(%rip), %xmm0    # 0xa7928
movsd (%rax,%rsi,8), %xmm2
cmplepd %xmm2, %xmm1
cmplepd %xmm0, %xmm2
andpd %xmm1, %xmm2
movd %xmm2, %eax
jmp 0x1d331
xorl %eax, %eax
jmp 0x1d331
// File: /workspace/github_c_makefile_star2_O3/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
movslq 0x10(%rsp), %rcx
movl $0x1, %eax
testq %rcx, %rcx
jle 0x1d405
leaq 0x10(%rsp), %rdx
movq 0x8(%rdx), %r8
movq 0x10(%rdx), %r9
movq (%rdi), %r10
movq 0x18(%rdx), %r11
xorl %ebx, %ebx
movslq (%r8,%rbx,4), %rdx
movl (%r10,%rdx,8), %edx
movq (%r11,%rbx,8), %rsi
movslq (%r9,%rbx,4), %rdi
cmpl (%rsi,%rdi,4), %edx
jne 0x1d3f0
incq %rbx
cmpq %rbx, %rcx
jne 0x1d3d1
jmp 0x1d405
testl %edi, %edi
jle 0x1d403
xorl %ecx, %ecx
cmpl (%rsi,%rcx,4), %edx
je 0x1d405
incq %rcx
cmpq %rcx, %rdi
jne 0x1d3f6
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x70, %rsp
leaq 0x90(%rsp), %rbx
callq 0x2ec9f
movq %rax, %r14
cmpl $0x0, 0x58(%rbx)
jle 0x1d5c5
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movsd %xmm0, 0x60(%rsp)
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
movsd (%rcx,%r15,8), %xmm0
movsd %xmm0, 0x68(%rsp)
movq (%rax,%r15,8), %rax
movl $0xb, %ecx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rax, %rsi
callq 0x93d00
mulsd 0x68(%rsp), %xmm0
movsd 0x60(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
incq %r15
movslq 0x58(%rbx), %rax
cmpq %rax, %r15
jl 0x1d564
jmp 0x1d5c9
xorpd %xmm0, %xmm0
subsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x60(%rsp)
movq %r14, %rdi
callq 0x3a180
movsd 0x60(%rsp), %xmm0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0x1d63f
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
cmpl $-0x1, 0x30(%r14)
movq %r14, %r15
je 0x1d621
movq %r14, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1d407
movq %rax, %r15
cmpl $-0x1, 0x30(%rax)
jne 0x1d60d
movq %rbx, %rdi
callq 0x2f33a
xorl %ecx, %ecx
cmpl 0x34(%r15), %eax
sete %cl
addl %ecx, %ebp
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d600
jmp 0x1d641
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
je 0x1d6f9
cmpl $0x0, 0x80(%rbx)
jle 0x1d6eb
movl $0x50, %r14d
xorl %r15d, %r15d
movq 0x58(%rbx), %rax
movl -0x50(%rax,%r14), %edi
movl $0x2, %esi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
je 0x1d6af
movq 0x58(%rbx), %rax
movq -0x30(%rax,%r14), %rdi
movq -0x28(%rax,%r14), %rsi
callq 0x3ed51
movq 0x58(%rbx), %rax
cmpl $-0x5, -0x50(%rax,%r14)
jne 0x1d6d4
movups (%rax,%r14), %xmm0
movups 0x10(%rax,%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1d703
incq %r15
movslq 0x80(%rbx), %rax
addq $0x70, %r14
cmpq %rax, %r15
jl 0x1d679
movq 0x58(%rbx), %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3a180
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3a180
movq 0x30(%rsp), %rdi
callq 0x3a180
movslq 0x20(%rsp), %r14
movq 0x38(%rsp), %rbx
testq %r14, %r14
jle 0x1d73f
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x3a180
incq %r15
cmpq %r15, %r14
jne 0x1d72e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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), %rax
testq %rax, %rax
js 0x1d95e
cmpl $0x2, 0x98(%rbx)
je 0x1d95e
leaq 0xb7f68(%rip), %r14     # 0xd5870
movq (%r14), %rcx
imulq $0x340, %rax, %r15      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%r15)
jne 0x1d95e
addq $0x30f08, %rcx          # imm = 0x30F08
cmpl $0x0, 0x18(%rcx,%r15)
jle 0x1d958
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %rdi
addq %r12, %rdi
callq 0x1d74c
incq %r13
movq (%r14), %rax
movslq 0x30f20(%rax,%r15), %rax
addq $0x160, %r12            # imm = 0x160
cmpq %rax, %r13
jl 0x1d932
addq $0x10, %rbx
jmp 0x1d982
movq (%rbx), %rdi
callq 0x1d74c
movq (%rbx), %rdi
callq 0x3a180
movq $0x0, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
callq 0x1d74c
movq (%rbx), %rdi
callq 0x3a180
movq $0x0, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0xb7cbf(%rip), %r14     # 0xd5870
movq (%r14), %rax
movslq 0x10(%rax), %rcx
xorpd %xmm0, %xmm0
testq %rcx, %rcx
jle 0x1dc40
movq %rdi, %rbx
xorl %edx, %edx
xorl %ebp, %ebp
addl (%rbx,%rdx,4), %ebp
incq %rdx
cmpq %rdx, %rcx
jne 0x1dbc8
testl %ecx, %ecx
jle 0x1dc40
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movl (%rbx,%r15,4), %ecx
testl %ecx, %ecx
jle 0x1dc34
testl %ebp, %ebp
jle 0x1dc34
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
divsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, (%rsp)
movapd %xmm1, %xmm0
callq 0x39bdc
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
movq (%r14), %rax
incq %r15
movslq 0x10(%rax), %rcx
cmpq %rcx, %r15
jl 0x1dbeb
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0xb7c0f(%rip), %r14     # 0xd5870
movq (%r14), %rax
xorl %r15d, %r15d
xorpd %xmm3, %xmm3
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %ebp, %ebp
movslq 0x10(%rax), %rcx
xorpd %xmm1, %xmm1
testq %rcx, %rcx
jle 0x1dd10
xorl %edx, %edx
xorps %xmm0, %xmm0
cvtsi2sdl (%rbx,%rdx,4), %xmm0
addsd %xmm0, %xmm1
incq %rdx
cmpq %rdx, %rcx
jne 0x1dc8a
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x1dd14
cmpl $0x0, 0x10(%rax)
jle 0x1dd0c
xorl %r12d, %r12d
movsd %xmm3, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movl (%rbx,%r12,4), %ecx
testl %ecx, %ecx
jle 0x1dd00
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd %xmm2, 0x28(%rsp)
callq 0x39bdc
movsd 0x28(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm3
mulsd 0x20(%rsp), %xmm0
subsd %xmm0, %xmm2
movq (%r14), %rax
incq %r12
movslq 0x10(%rax), %rcx
cmpq %rcx, %r12
jl 0x1dcbd
incl %ebp
jmp 0x1dd14
xorpd %xmm2, %xmm2
addsd %xmm1, %xmm3
mulsd %xmm1, %xmm2
movsd 0x8(%rsp), %xmm0
addsd %xmm2, %xmm0
movsd %xmm0, 0x8(%rsp)
incq %r15
addq $0xc8, %rbx
cmpq $0x64, %r15
jne 0x1dc77
xorpd %xmm1, %xmm1
cmpeqsd %xmm3, %xmm1
movsd 0x87f9f(%rip), %xmm0    # 0xa5cf0
movapd %xmm0, %xmm2
cmpl $0x1, %ebp
je 0x1dd64
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_O3/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(%rdi)
je 0x1dda7
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1dd81
movq 0x8(%r14), %r14
cmpl $-0x1, 0x30(%r14)
jne 0x1dd91
movq 0x20(%r14), %rdi
callq 0x115a6
leaq 0xb7ab9(%rip), %rcx     # 0xd5870
movq (%rcx), %rcx
cmpl $0x0, 0x10(%rcx)
jle 0x1ddd4
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
addl %esi, (%rbx,%rdx,4)
incq %rdx
movslq 0x10(%rcx), %rsi
cmpq %rsi, %rdx
jl 0x1ddc2
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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(%rdi)
je 0x1de10
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1dde3
movq 0x8(%r15), %r15
cmpl $-0x1, 0x30(%r15)
jne 0x1ddf7
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_O3/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 0x1de56
movq (%rbx), %rdi
callq 0x1de29
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
callq 0x1de29
addsd 0x8(%rsp), %xmm0
jmp 0x1de7e
movq 0x20(%rbx), %rdi
callq 0x115a6
movq %rax, %rbx
movq %rax, %rdi
callq 0x1de84
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x3a180
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0xb79dc(%rip), %r14     # 0xd5870
movq (%r14), %rax
movslq 0x10(%rax), %rcx
xorpd %xmm0, %xmm0
testq %rcx, %rcx
jle 0x1df23
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
addl (%rbx,%rsi,4), %edx
incq %rsi
cmpq %rsi, %rcx
jne 0x1deab
testl %ecx, %ecx
jle 0x1df23
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movsd %xmm0, 0x10(%rsp)
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movl (%rbx,%r15,4), %ecx
testl %ecx, %ecx
je 0x1df17
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
divsd 0x10(%rsp), %xmm0
callq 0x39bdc
mulsd 0x18(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq (%r14), %rax
incq %r15
movslq 0x10(%rax), %rcx
cmpq %rcx, %r15
jl 0x1dece
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorl %ecx, %ecx
leaq 0x10(%rsp), %rdx
movl %ecx, (%rdx)
leaq 0xc(%rsp), %rax
movl %ecx, (%rax)
leaq 0x20(%rsp), %r13
movq %rcx, (%r13)
leaq 0x18(%rsp), %rax
movq %rcx, (%rax)
leaq 0xb790a(%rip), %r12     # 0xd5870
movq (%r12), %rax
movb $0x1, %bpl
movsd 0x87d7b(%rip), %xmm0    # 0xa5cf0
movslq 0x10(%rax), %rdi
movl (%rdx), %esi
testq %rdi, %rdi
jle 0x1df9b
imulq $0xc8, %rcx, %r8
addq %rbx, %r8
xorl %r9d, %r9d
addl (%r8,%r9,4), %esi
incq %r9
cmpq %r9, %rdi
jne 0x1df8d
movl %esi, (%rdx)
testl %esi, %esi
je 0x1e062
cmpl $0x0, 0x10(%rax)
jle 0x1e011
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
movsd %xmm1, 0x28(%rsp)
imulq $0xc8, %rcx, %r14
addq %rbx, %r14
xorl %r15d, %r15d
movl (%r14,%r15,4), %ecx
testl %ecx, %ecx
jle 0x1e005
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
divsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
callq 0x39bdc
movsd (%r13), %xmm1
mulsd 0x30(%rsp), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%r13)
movsd 0x87cef(%rip), %xmm0    # 0xa5cf0
movq (%r12), %rax
incq %r15
movslq 0x10(%rax), %rcx
cmpq %rcx, %r15
jl 0x1dfc3
movl $0x1, %ecx
leaq 0x18(%rsp), %r13
leaq 0xc(%rsp), %rdx
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x1df75
movl 0x10(%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movl 0xc(%rsp), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
mulsd 0x18(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm0
addsd %xmm1, %xmm0
addl %eax, %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x317cf
movq %rax, (%rbx)
movslq (%r15), %rdi
movl %edi, 0x10(%rbx)
shlq $0x2, %rdi
leaq 0x89818(%rip), %rsi     # 0xa7952
movl $0x5, %edx
callq 0x3a0e1
movq %rax, %r14
movq %rax, 0x8(%rbx)
movl (%r15), %eax
cmpl $0x2, %eax
jne 0x1e162
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, (%r14)
jmp 0x1e18d
testl %eax, %eax
jle 0x1e18d
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x3af20
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
andl $-0x2, %ecx
subl %ecx, %eax
movl %eax, (%r14,%r15,4)
incq %r15
movslq 0xc(%rsp), %rax
cmpq %rax, %r15
jl 0x1e169
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x317cf
movq %rax, %r14
movq %rax, (%rbx)
movslq (%r15), %rdi
movl %edi, 0x10(%rbx)
shlq $0x2, %rdi
leaq 0x8979b(%rip), %rsi     # 0xa7968
movl $0x5, %edx
callq 0x3a0e1
movq %rax, 0x8(%rbx)
cmpl $0x0, (%r15)
jle 0x1e214
xorl %edx, %edx
movl $0x1, (%rax,%rdx,4)
incq %rdx
movslq 0x4(%rsp), %rcx
cmpq %rcx, %rdx
jl 0x1e1e3
testl %ecx, %ecx
jle 0x1e214
xorl %edx, %edx
cmpl %ebp, (%r14,%rdx,4)
je 0x1e20d
incq %rdx
cmpq %rdx, %rcx
jne 0x1e1fd
jmp 0x1e214
movl $0x0, (%rax,%rdx,4)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x30(%rdi)
je 0x1e26c
movq (%rbx), %rdi
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
callq 0x1e222
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x1e222
addsd 0x8(%rsp), %xmm0
jmp 0x1e340
cmpl $0x0, 0x60(%rbx)
je 0x1e2a1
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, 0x20(%rsp)
jmp 0x1e2ac
movsd 0x48(%rbx), %xmm2
movsd %xmm2, 0x20(%rsp)
movq 0x18(%rbx), %rax
movsd 0x87268(%rip), %xmm2    # 0xa5520
testq %rax, %rax
je 0x1e336
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
movq %rbx, %r14
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 0x55a80
movq 0x18(%rbx), %rbx
cmpq (%rbx), %r14
je 0x1e317
movsd 0x87211(%rip), %xmm1    # 0xa5520
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
movq 0x18(%rbx), %rax
testq %rax, %rax
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
jne 0x1e2c9
movsd 0x20(%rsp), %xmm0
mulsd %xmm2, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl 0x30(%rdi), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
je 0x1e3ce
movq %rdi, %r14
testl %eax, %eax
js 0x1e3b1
leaq 0xb7508(%rip), %rcx     # 0xd5870
movq (%rcx), %rcx
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rax)
jne 0x1e3b1
addq $0x30f08, %rcx          # imm = 0x30F08
movslq 0x18(%rcx,%rax), %r15
testq %r15, %r15
jle 0x1e3df
movq 0x10(%r14), %r14
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x1e348
cmpl %ebx, %eax
cmovgl %eax, %ebx
addq $0x160, %r14            # imm = 0x160
decq %r15
jne 0x1e396
jmp 0x1e3d5
movq (%r14), %rdi
callq 0x1e348
movl %eax, %ebx
movq 0x8(%r14), %rdi
callq 0x1e348
cmpl %eax, %ebx
jge 0x1e3d5
incl %eax
movl %eax, %ebx
jmp 0x1e3d7
movl $0x1, %ebx
jmp 0x1e3d7
incl %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %ebx, %ebx
jmp 0x1e3d7
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x1e504
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb746e(%rip), %r15     # 0xd5870
movslq 0x30(%r14), %rcx
testq %rcx, %rcx
js 0x1e41f
movq (%r15), %rax
imulq $0x340, %rcx, %rcx      # imm = 0x340
cmpl $0x1, 0x30f08(%rax,%rcx)
je 0x1e445
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1e3e3
movl (%rbx), %eax
movl %eax, 0x134(%r14)
incl %eax
movl %eax, (%rbx)
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x1e402
jmp 0x1e4fb
leaq 0x30f08(%rax), %rdx
cmpl $0x2, 0x18(%rdx,%rcx)
jl 0x1e498
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x10(%r14), %rdi
addq %r12, %rdi
movq %rbx, %rsi
callq 0x1e3e3
incq %r13
movq (%r15), %rax
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f20(%rax,%rcx), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
movslq %edx, %rcx
addq $0x160, %r12            # imm = 0x160
cmpq %rcx, %r13
jl 0x1e459
movl (%rbx), %ecx
movl %ecx, 0x134(%r14)
incl %ecx
movl %ecx, (%rbx)
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f20(%rax,%rcx), %r12d
testl %r12d, %r12d
jle 0x1e4fb
shrl %r12d
imulq $0x160, %r12, %r13      # imm = 0x160
movq 0x10(%r14), %rdi
addq %r13, %rdi
movq %rbx, %rsi
callq 0x1e3e3
incq %r12
movq (%r15), %rax
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movslq 0x30f20(%rax,%rcx), %rax
addq $0x160, %r13            # imm = 0x160
cmpq %rax, %r12
jl 0x1e4c7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x1e5ba
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb7350(%rip), %r14     # 0xd5870
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e533
movl 0x138(%rax), %eax
incl %eax
jmp 0x1e535
xorl %eax, %eax
movl %eax, 0x138(%rbx)
movslq 0x30(%rbx), %rcx
testq %rcx, %rcx
js 0x1e558
movq (%r14), %rax
imulq $0x340, %rcx, %rcx      # imm = 0x340
cmpl $0x1, 0x30f08(%rax,%rcx)
je 0x1e56b
movq (%rbx), %rdi
callq 0x1e505
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x1e520
jmp 0x1e5af
addq $0x30f08, %rax          # imm = 0x30F08
cmpl $0x0, 0x18(%rax,%rcx)
jle 0x1e5af
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rdi
addq %r15, %rdi
callq 0x1e505
incq %r12
movq (%r14), %rax
movslq 0x30(%rbx), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movslq 0x30f20(%rax,%rcx), %rax
addq $0x160, %r15            # imm = 0x160
cmpq %rax, %r12
jl 0x1e57e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq