LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/datastructure.c
// Function: free_link_list
void free_link_list(Linklistptr l, void (*free_node_contents) (void* a))
{
 /*!Last Changed 21.01.2009*/
 Listitemptr tmp = l->head, next = NULL;
 while (tmp != NULL)
  {
   next = tmp->next;
   free_node_contents(tmp->item);
   safe_free(tmp);
   tmp = next;
  }
 safe_free(l);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x1b7f4
movq %rsi, %r14
movq (%r15), %rdi
movq 0x8(%r15), %r12
callq *%r14
movq %r15, %rdi
callq 0x39194
movq %r12, %r15
testq %r12, %r12
jne 0x1b7da
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/datastructure.c
// Function: queue
Queueptr queue()
{
 /*!Last Changed 21.01.2009*/
 Queueptr q;
 q = safemalloc(sizeof(Queue), "queue", 2);
 q->first = 0;
 q->last = QUEUESIZE - 1;
 q->count = 0;
 return q; 
}

// Assembly:
pushq %rax
leaq 0x89081(%rip), %rsi     # 0xa4890
movl $0x1f58, %edi           # imm = 0x1F58
movl $0x2, %edx
callq 0x390f5
movabsq $0x3e700000000, %rcx    # imm = 0x3E700000000
movq %rcx, 0x1f48(%rax)
movl $0x0, 0x1f50(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/datastructure.c
// Function: dictionary_insert
void dictionary_insert(Dictionaryptr d, void* x, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 21.01.2009*/
 int i, j;
 if (d->count == DICTIONARYSIZE)
  {
   printf("Dictionary is full\n");
   return;
  }
 if (d->count == 0)
   d->elements[0] = x;
 else
   if (compare(x, d->elements[d->count - 1]) >= 0)
     d->elements[d->count] = x;
   else
    {
     i = 0;
     while (compare(x, d->elements[i]) < 0)
       i++;
     for (j = d->count - 1; j >= i; j--)
       d->elements[j + 1] = d->elements[j];
     d->elements[i] = x;
    }
 d->count++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x1f40(%rdi), %rax
movq %rdi, %r12
testq %rax, %rax
je 0x1b91a
cmpl $0x3e8, %eax            # imm = 0x3E8
jne 0x1b8a3
leaq 0x89006(%rip), %rdi     # 0xa4896
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
movq %rdx, %r15
movq -0x8(%rbx,%rax,8), %rsi
movq %r14, %rdi
callq *%rdx
testl %eax, %eax
js 0x1b8c1
movslq 0x1f40(%rbx), %rax
leaq (%rbx,%rax,8), %r12
jmp 0x1b91a
leaq -0x8(%rbx), %r12
movabsq $-0x100000000, %r13     # imm = 0xFFFFFFFF00000000
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r13
movq 0x8(%r12), %rsi
addq $0x8, %r12
movq %r14, %rdi
callq *%r15
incl %ebp
testl %eax, %eax
js 0x1b8d4
movslq 0x1f40(%rbx), %rax
cmpl %ebp, %eax
jle 0x1b91a
sarq $0x20, %r13
movq -0x8(%rbx,%rax,8), %rcx
movq %rcx, (%rbx,%rax,8)
leaq -0x1(%rax), %rcx
movq %rcx, %rax
cmpq %r13, %rcx
jg 0x1b905
movq %r14, (%r12)
incl 0x1f40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/datastructure.c
// Function: dictionary_delete
void dictionary_delete(Dictionaryptr d, void* x, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 21.01.2009*/
 int i, j;
 for (i = 0; i < d->count; i++)
   if (compare(x, d->elements[i]) == 0)
    {
     for (j = i; j < d->count - 1; j++)
       d->elements[j] = d->elements[j + 1];
     break;
    }
 d->count--;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x1f40(%rdi)
jle 0x1b96d
movq %rdx, %r14
movq %rsi, %r15
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r15, %rdi
callq *%r14
testl %eax, %eax
je 0x1b985
incq %r12
movslq 0x1f40(%rbx), %rax
cmpq %rax, %r12
jl 0x1b950
addq $0x1f40, %rbx           # imm = 0x1F40
movq %rbx, %rax
decl (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1f40(%rbx), %rax
movl 0x1f40(%rbx), %ecx
decl %ecx
cmpl %r12d, %ecx
jle 0x1b977
movl %ecx, %ecx
movq 0x8(%rbx,%r12,8), %rdx
movq %rdx, (%rbx,%r12,8)
leaq 0x1(%r12), %rdx
movq %rdx, %r12
cmpq %rdx, %rcx
jne 0x1b99b
jmp 0x1b977
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/datastructure.c
// Function: hash_table
Hashtableptr hash_table()
{
 /*!Last Changed 21.01.2009*/
 int i;
 Hashtableptr h;
 h = safemalloc(sizeof(Hashtable), "hash_table", 2);
 for (i = 0; i < HASHTABLESIZE; i++)
   h->elements[i] = link_list();
 return h;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x88e15(%rip), %rsi     # 0xa483d
movl $0x1f88, %edi           # imm = 0x1F88
movl $0x2, %edx
callq 0x390f5
movq %rax, %rbx
xorl %r15d, %r15d
leaq 0x88de4(%rip), %r14     # 0xa4828
movl $0x10, %edi
movq %r14, %rsi
movl $0x2, %edx
callq 0x390f5
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, (%rbx,%r15,8)
incq %r15
cmpq $0x3f1, %r15            # imm = 0x3F1
jne 0x1ba44
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/datastructure.c
// Function: hash_table_search
void* hash_table_search(Hashtableptr h, void* x, int (*hash_function)(const void *a, int tablesize), int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 21.01.2009*/
 int location;
 location = hash_function(x, HASHTABLESIZE);
 return link_list_search(h->elements[location], x, compare);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movl $0x3f1, %esi            # imm = 0x3F1
callq *%rdx
cltq
movq (%r15,%rax,8), %rax
movq (%rax), %r12
xorl %r15d, %r15d
testq %r12, %r12
je 0x1bb10
movq (%r12), %rsi
movq %r14, %rdi
callq *%rbx
testl %eax, %eax
je 0x1bb0c
movq 0x8(%r12), %r12
jmp 0x1baf3
movq (%r12), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/datastructure.c
// Function: tree_node
Treenodeptr tree_node(void* item)
{
 /*!Last Changed 22.01.2009*/
 Treenodeptr t;
 t = safemalloc(sizeof(Treenode), "tree_node", 2);
 t->item = item;
 t->left = NULL;
 t->right = NULL;
 return t;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x88ceb(%rip), %rsi     # 0xa4848
movl $0x18, %edi
movl $0x2, %edx
callq 0x390f5
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/datastructure.c
// Function: binary_tree_node_search
void* binary_tree_node_search(Treenodeptr t, void* x, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 22.01.2009*/
 if (t == NULL)
   return NULL;
 else
   if (compare(x, t->item) < 0)
     return binary_tree_node_search(t->left, x, compare);
   else
     if (compare(x, t->item) > 0)
       return binary_tree_node_search(t->right, x, compare);
     else
       return t->item;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorl %ebx, %ebx
testq %r15, %r15
je 0x1bbe1
movq (%r15), %rsi
movq %r12, %rdi
callq *%r14
testl %eax, %eax
js 0x1bbd8
movq (%r15), %rsi
movq %r12, %rdi
callq *%r14
testl %eax, %eax
jle 0x1bbde
movq 0x10(%r15), %r15
jmp 0x1bbb3
movq 0x8(%r15), %r15
jmp 0x1bbb3
movq (%r15), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/datastructure.c
// Function: find_max
Treenodeptr find_max(Treenodeptr t)
{
 /*!Last Changed 22.01.2009*/
 if (t != NULL)
   while (t->right != NULL)
     t = t->right;
 return t;
}

// Assembly:
testq %rdi, %rdi
je 0x1bc17
movq %rdi, %rax
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0x1bc0a
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/datastructure.c
// Function: binary_tree_node_insert
void binary_tree_node_insert(Treenodeptr* t, void* x, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 22.01.2009*/
 if (*t == NULL)
   *t = tree_node(x);
 else
   if (compare(x, (*t)->item) < 0)
     binary_tree_node_insert(&((*t)->left), x, compare);
   else
     if (compare(x, (*t)->item) > 0)
       binary_tree_node_insert(&((*t)->right), x, compare);
     else
       ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %rax
testq %rax, %rax
je 0x1bc64
movq (%rax), %rsi
movq %rbx, %rdi
callq *%r15
movq (%r14), %rcx
testl %eax, %eax
js 0x1bc5b
movq (%rcx), %rsi
movq %rbx, %rdi
callq *%r15
testl %eax, %eax
jle 0x1bc87
movq (%r14), %r14
addq $0x10, %r14
jmp 0x1bc2d
addq $0x8, %rcx
movq %rcx, %r14
jmp 0x1bc2d
leaq 0x88bdd(%rip), %rsi     # 0xa4848
movl $0x18, %edi
movl $0x2, %edx
callq 0x390f5
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, (%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/datastructure.c
// Function: binary_tree_node_remove
void binary_tree_node_remove(Treenodeptr* t, void* x, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 22.01.2009*/
 Treenodeptr oldnode;
 if (*t == NULL)
   return;
 if (compare(x, (*t)->item) < 0)
   binary_tree_node_remove(&((*t)->left), x, compare);
 else
   if (compare(x, (*t)->item) > 0)
     binary_tree_node_remove(&((*t)->right), x, compare);
   else
     if ((*t)->left != NULL && (*t)->right != NULL)
      {
       (*t)->item = find_min((*t)->right)->item;
       binary_tree_node_remove(&((*t)->right), x, compare);
      }
     else
      {
       oldnode = *t;
       *t = ((*t)->left != NULL) ? (*t)->left : (*t)->right;
       safe_free(oldnode);
      }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rbx), %rax
testq %rax, %rax
je 0x1bd06
movq (%rax), %rsi
movq %r15, %rdi
callq *%r14
movq (%rbx), %rcx
testl %eax, %eax
js 0x1bcd4
movq (%rcx), %rsi
movq %r15, %rdi
callq *%r14
movq (%rbx), %r12
testl %eax, %eax
jle 0x1bcdd
addq $0x10, %r12
movq %r12, %rbx
jmp 0x1bca3
addq $0x8, %rcx
movq %rcx, %rbx
jmp 0x1bca3
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x1bd17
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x1bd12
callq 0x1bbf0
movq (%rax), %rax
movq %rax, (%r12)
movq (%rbx), %rbx
addq $0x10, %rbx
jmp 0x1bca3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %rax, %rax
jne 0x1bd1c
movq 0x10(%r12), %rax
movq %rax, (%rbx)
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/datastructure.c
// Function: free_binary_tree_node
void free_binary_tree_node(Treenodeptr t)
{
 /*!Last Changed 22.01.2009*/
 if (t != NULL)
  {
   free_binary_tree_node(t->left);
   free_binary_tree_node(t->right);
   safe_free(t);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1bd6b
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1bd47
movq 0x10(%rbx), %rdi
callq 0x1bd47
movq %rbx, %rdi
popq %rbx
jmp 0x39194
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/datastructure.c
// Function: heap_insert
void heap_insert(Heapptr h, void* x, int (*compare)(const void *a, const void *b))
{
 /*!Last Changed 22.01.2009*/
 int hole;
 if (heap_full(h))
  {
   printf("Heap is full\n");
   return;
  }
 hole = ++(h->count);
 for (; hole > 1 && compare(x, h->elements[hole / 2]) < 0; hole /= 2)
   h->elements[hole] = h->elements[hole / 2];
 h->elements[hole] = x;
}

// Assembly:
movl 0x1f40(%rdi), %eax
cmpl $0x3e7, %eax            # imm = 0x3E7
jne 0x1bdca
leaq 0x88ae4(%rip), %rdi     # 0xa48a9
jmp 0x4090
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leal 0x1(%rax), %ebp
movl %ebp, 0x1f40(%rdi)
testl %eax, %eax
jle 0x1be10
movq %rdx, %r15
movl %ebp, %r12d
shrl %r12d
movq (%r14,%r12,8), %rsi
movq %rbx, %rdi
callq *%r15
testl %eax, %eax
jns 0x1be10
movq (%r14,%r12,8), %rax
movl %ebp, %ecx
movq %rax, (%r14,%rcx,8)
cmpl $0x3, %ebp
movl %r12d, %ebp
ja 0x1bdeb
jmp 0x1be13
movl %ebp, %r12d
movslq %r12d, %rax
movq %rbx, (%r14,%rax,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1be54
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 0x1be67
jmp 0x1be62
leaq 0x88a5b(%rip), %rdi     # 0xa48b6
callq 0x4090
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r12
movq (%rdi,%r12,8), %r14
addl %r12d, %r12d
movl 0x1f40(%rdi), %eax
cmpl %eax, %r12d
jle 0x1be91
movl %ebp, %r13d
jmp 0x1bee5
movq %rdx, %r15
cmpl %eax, %r12d
je 0x1beb5
movl %r12d, %r13d
orl $0x1, %r13d
movslq %r13d, %rax
movq (%rbx,%rax,8), %rdi
movslq %r12d, %rax
movq (%rbx,%rax,8), %rsi
callq *%r15
testl %eax, %eax
js 0x1beb8
movl %r12d, %r13d
movslq %r13d, %r12
movq (%rbx,%r12,8), %rdi
movq %r14, %rsi
callq *%r15
testl %eax, %eax
jns 0x1be8c
movq (%rbx,%r12,8), %rax
movslq %ebp, %rcx
movq %rax, (%rbx,%rcx,8)
addl %r12d, %r12d
movl 0x1f40(%rbx), %eax
movl %r13d, %ebp
cmpl %eax, %r12d
jle 0x1be94
movslq %r13d, %rax
movq %r14, (%rbx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/decisionforest.c
// Function: create_randomforestchildren
int create_randomforestchildren(Decisionnodeptr node, Randomforest_parameterptr p)
{
 int count, i, t, fno;
 int* array;
 double bestgain = +INT_MAX;
 node->conditiontype = UNIVARIATE_CONDITION;
 if (!(setup_node_properties(node)))
  {
   make_leaf_node(node);
   return 1;
  }
 i = 0;
 t = 0;
 array = random_array(current_dataset->featurecount);
 while (i < p->featuresize)
  {
   fno = array[t];
   if (current_dataset->features[fno].type != CLASSDEF)
    {
     if (find_best_split_for_feature_i(node->instances, fno, &(node->split), &bestgain))
       node->featureno = fno;
     i++;
    }
   t++;
  }
 safe_free(array);
 if (bestgain == ISELL)
   node->featureno = -1;
 if (!(make_children(node)))
   return 1;
 switch (current_dataset->features[node->featureno].type)
  {
   case INTEGER:
   case REAL   :create_randomforestchildren(node->left, p);
                create_randomforestchildren(node->right, p);
                break;
   case STRING :count = current_dataset->features[node->featureno].valuecount;
                for (i = 0; i < count; i++)
                  create_randomforestchildren(&(node->string[i]), p);
                break;
  }
 return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x41dfffffffc00000, %rax # imm = 0x41DFFFFFFFC00000
movq %rax, 0x10(%rsp)
movl $0x0, 0x98(%rdi)
callq 0x1c85f
testl %eax, %eax
je 0x1c346
leaq 0xb6608(%rip), %rax     # 0xd2870
movq (%rax), %rax
movl 0x1bc(%rax), %edi
callq 0x39fdc
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x4(%rbx)
jle 0x1c2d3
leaq 0x28(%r14), %r12
xorl %r13d, %r13d
movq 0x8(%rsp), %r15
movslq (%r15), %rbp
leaq 0xb65d9(%rip), %rax     # 0xd2870
movq (%rax), %rax
imulq $0x340, %rbp, %rcx      # imm = 0x340
cmpl $0x3, 0x30f08(%rax,%rcx)
je 0x1c2c9
movq 0x20(%r14), %rdi
movl %ebp, %esi
movq %r12, %rdx
leaq 0x10(%rsp), %rcx
callq 0x9d85b
testl %eax, %eax
je 0x1c2c6
movl %ebp, 0x30(%r14)
incl %r13d
addq $0x4, %r15
cmpl 0x4(%rbx), %r13d
jl 0x1c28d
movq 0x8(%rsp), %rdi
callq 0x39194
movsd 0x10(%rsp), %xmm0
ucomisd 0x86a05(%rip), %xmm0    # 0xa2cf0
jne 0x1c2f7
jp 0x1c2f7
movl $0xffffffff, 0x30(%r14) # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x9db4a
testl %eax, %eax
je 0x1c34e
leaq 0xb6566(%rip), %rax     # 0xd2870
movq (%rax), %rax
movslq 0x30(%r14), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %edx
cmpl $0x2, %edx
je 0x1c32d
cmpl $0x1, %edx
je 0x1c362
testl %edx, %edx
jne 0x1c34e
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1c227
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x1c227
jmp 0x1c34e
movq %r14, %rdi
callq 0x1c39c
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %rcx, %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq 0x18(%rax), %rax
testq %rax, %rax
jle 0x1c34e
imulq $0x160, %rax, %r15      # imm = 0x160
xorl %r12d, %r12d
movq 0x10(%r14), %rdi
addq %r12, %rdi
movq %rbx, %rsi
callq 0x1c227
addq $0x160, %r12            # imm = 0x160
cmpq %r12, %r15
jne 0x1c37e
jmp 0x1c34e
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
leaq 0xb64a4(%rip), %r12     # 0xd2870
movl 0x30(%r14), %eax
cmpq %r15, %rax
je 0x1c408
testl %eax, %eax
js 0x1c3f8
cmpl $0x2, 0x98(%r14)
je 0x1c3f8
movq (%r12), %rcx
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rax)
je 0x1c41c
movq (%r14), %rdi
callq 0x1c3b2
movq 0x8(%r14), %r14
addl %eax, %ebx
jmp 0x1c3cc
movl 0x88(%r14), %ebp
addl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0x30f08, %rcx          # imm = 0x30F08
movslq 0x18(%rcx,%rax), %r15
testq %r15, %r15
jle 0x1c44b
movq 0x10(%r14), %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1c3b2
addl %eax, %ebp
addq $0x160, %r14            # imm = 0x160
decq %r15
jne 0x1c433
jmp 0x1c40f
xorl %ebp, %ebp
jmp 0x1c40f
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %r14
xorl %r15d, %r15d
movl 0x30(%r14), %ebp
cmpl $-0x1, %ebp
je 0x1c480
movq (%r14), %rdi
callq 0x1c44f
movl %eax, %ebx
testl %ebp, %ebp
js 0x1c49d
movq 0x8(%r14), %r14
addl %ebx, %r15d
addl $0x2, %r15d
jmp 0x1c45c
xorl %ebx, %ebx
cmpl $0x1, 0x60(%r14)
jne 0x1c4d8
leaq 0xb63e0(%rip), %rax     # 0xd2870
movq (%rax), %rax
movl 0x1c0(%rax), %ebx
decl %ebx
jmp 0x1c4d8
movq 0x8(%r14), %rdi
callq 0x1c44f
cmpl $-0x3, %ebp
je 0x1c4b9
cmpl $-0x2, %ebp
jne 0x1c4c6
addl 0x90(%r14), %ebx
jmp 0x1c4c0
addl 0x94(%r14), %ebx
addl %eax, %ebx
incl %ebx
jmp 0x1c4d8
leaq 0xb63a3(%rip), %rcx     # 0xd2870
movq (%rcx), %rcx
addl 0x1c0(%rcx), %ebx
addl %eax, %ebx
addl %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %r14
xorl %ebx, %ebx
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
leaq 0xb636e(%rip), %r12     # 0xd2870
movl 0x30(%r14), %eax
cmpq %r15, %rax
je 0x1c53e
testl %eax, %eax
js 0x1c52e
cmpl $0x2, 0x98(%r14)
je 0x1c52e
movq (%r12), %rcx
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rax)
je 0x1c550
movq (%r14), %rdi
callq 0x1c4e8
movq 0x8(%r14), %r14
addl %eax, %ebx
jmp 0x1c502
movl $0x1, %ebp
addl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0x30f08, %rcx          # imm = 0x30F08
movslq 0x18(%rcx,%rax), %r15
testq %r15, %r15
jle 0x1c57f
movq 0x10(%r14), %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1c4e8
addl %eax, %ebp
addq $0x160, %r14            # imm = 0x160
decq %r15
jne 0x1c567
jmp 0x1c543
xorl %ebp, %ebp
jmp 0x1c543
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %r14
xorl %ebx, %ebx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
leaq 0xb62d2(%rip), %r13     # 0xd2870
xorl %r15d, %r15d
movl 0x30(%r14), %eax
cmpq %r12, %rax
je 0x1c618
testl %eax, %eax
js 0x1c5cd
cmpl $0x2, 0x98(%r14)
je 0x1c5cd
movq (%r13), %rcx
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rax)
je 0x1c5e1
movq (%r14), %rdi
callq 0x1c583
movq 0x8(%r14), %r14
addl %eax, %r15d
incl %r15d
jmp 0x1c5a1
addq $0x30f08, %rcx          # imm = 0x30F08
movslq 0x18(%rcx,%rax), %r12
testq %r12, %r12
jle 0x1c613
movq 0x10(%r14), %r14
movl $0x1, %ebx
movq %r14, %rdi
callq 0x1c583
addl %eax, %ebx
addq $0x160, %r14            # imm = 0x160
decq %r12
jne 0x1c5fb
jmp 0x1c618
movl $0x1, %ebx
addl %r15d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
xorl %ebx, %ebx
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
leaq 0xb622f(%rip), %r12     # 0xd2870
movl 0x30(%r14), %eax
cmpq %r15, %rax
je 0x1c67d
testl %eax, %eax
js 0x1c66d
cmpl $0x2, 0x98(%r14)
je 0x1c66d
movq (%r12), %rcx
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rax)
je 0x1c691
movq (%r14), %rdi
callq 0x1c627
movq 0x8(%r14), %r14
addl %eax, %ebx
jmp 0x1c641
movl 0x80(%r14), %ebp
addl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0x30f08, %rcx          # imm = 0x30F08
movslq 0x18(%rcx,%rax), %r15
testq %r15, %r15
jle 0x1c6c0
movq 0x10(%r14), %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1c627
addl %eax, %ebp
addq $0x160, %r14            # imm = 0x160
decq %r15
jne 0x1c6a8
jmp 0x1c684
xorl %ebp, %ebp
jmp 0x1c684
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %r14
xorl %ebx, %ebx
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
leaq 0xb6192(%rip), %r12     # 0xd2870
movl 0x30(%r14), %eax
cmpq %r15, %rax
je 0x1c71a
testl %eax, %eax
js 0x1c70a
cmpl $0x2, 0x98(%r14)
je 0x1c70a
movq (%r12), %rcx
imulq $0x340, %rax, %rax      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rax)
je 0x1c72c
movq (%r14), %rdi
callq 0x1c6c4
movq 0x8(%r14), %r14
addl %eax, %ebx
jmp 0x1c6de
movl $0x1, %ebp
addl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0x30f08, %rcx          # imm = 0x30F08
movslq 0x18(%rcx,%rax), %r15
testq %r15, %r15
jle 0x1c75b
movq 0x10(%r14), %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1c6c4
addl %eax, %ebp
addq $0x160, %r14            # imm = 0x160
decq %r15
jne 0x1c743
jmp 0x1c71f
xorl %ebp, %ebp
jmp 0x1c71f
// File: /workspace/github_c_makefile_star2_O1/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, %r12d      # imm = 0xFFFFFFFF
leaq 0xb60cb(%rip), %r15     # 0xd2870
movl 0x30(%rbx), %eax
cmpq %r12, %rax
je 0x1c7e6
testl %eax, %eax
js 0x1c7d5
cmpl $0x2, 0x98(%rbx)
je 0x1c7d5
movq (%r15), %rcx
imulq $0x340, %rax, %r13      # imm = 0x340
movl 0x30f08(%rcx,%r13), %eax
testl %eax, %eax
je 0x1c7d5
cmpl $0x2, %eax
jne 0x1c81c
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1c787
movq 0x8(%rbx), %rbx
jmp 0x1c7a5
movq (%r14), %rax
testq %rax, %rax
je 0x1c7fe
movq %rax, %r14
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x1c7ee
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 0x1c80d
movq (%r15), %rax
cmpl $0x0, 0x30f20(%rax,%r13)
jle 0x1c80d
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x10(%rbx), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x1c787
incq %rbp
movq (%r15), %rax
movslq 0x30f20(%rax,%r13), %rax
addq $0x160, %r12            # imm = 0x160
cmpq %rax, %rbp
jl 0x1c834
jmp 0x1c80d
// File: /workspace/github_c_makefile_star2_O1/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 0x115e1
movq %rax, 0xa0(%rbx)
movq 0x20(%rbx), %rdi
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x11633
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 0x2fa14
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_O1/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 0x1c85f
testl %eax, %eax
je 0x1c934
movl $0x1, %ebp
testq %r14, %r14
je 0x1c94d
cmpl $0x0, (%r14)
jne 0x1c94d
movq 0x20(%rbx), %rdi
callq 0x2fa14
cvtsi2sd %eax, %xmm0
leaq 0xb5f57(%rip), %rax     # 0xd2870
movq (%rax), %rax
cvtsi2sdl 0x1407124(%rax), %xmm1
divsd %xmm1, %xmm0
movsd 0x8(%r14), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1c94d
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_O1/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 0x1cb7c
cmpl $0x2, 0x98(%rbx)
jne 0x1cbbf
movq %rax, %rdi
callq 0x2e4b6
movsd 0x28(%rbx), %xmm1
jmp 0x1cb91
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
movq %rax, %rdi
callq 0x2e700
movsd 0x48(%rbx), %xmm1
movsd 0x87d47(%rip), %xmm2    # 0xa48e0
addsd %xmm1, %xmm2
addsd 0x87d43(%rip), %xmm1    # 0xa48e8
cmplepd %xmm0, %xmm2
cmplepd %xmm1, %xmm0
andpd %xmm2, %xmm0
movd %xmm0, %eax
movzbl %al, %eax
andl $0x1, %eax
popq %rbx
retq
leaq 0xb5caa(%rip), %rcx     # 0xd2870
movq (%rcx), %rcx
imulq $0x340, %rsi, %rdx      # imm = 0x340
movl 0x30f08(%rcx,%rdx), %ecx
cmpl $0x2, %ecx
je 0x1cbf8
testl %ecx, %ecx
jne 0x1cc2d
movq (%rax), %rax
cvtsi2sdl (%rax,%rsi,8), %xmm0
cmpeqsd 0x28(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x1cbb7
movq (%rax), %rax
movsd 0x28(%rbx), %xmm0
movsd 0x87cd8(%rip), %xmm1    # 0xa48e0
addsd %xmm0, %xmm1
addsd 0x87cd4(%rip), %xmm0    # 0xa48e8
movsd (%rax,%rsi,8), %xmm2
cmplepd %xmm2, %xmm1
cmplepd %xmm0, %xmm2
andpd %xmm1, %xmm2
movd %xmm2, %eax
jmp 0x1cbb7
xorl %eax, %eax
jmp 0x1cbb7
// File: /workspace/github_c_makefile_star2_O1/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 0x1cc8b
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 0x1cc76
incq %rbx
cmpq %rbx, %rcx
jne 0x1cc57
jmp 0x1cc8b
testl %edi, %edi
jle 0x1cc89
xorl %ecx, %ecx
cmpl (%rsi,%rcx,4), %edx
je 0x1cc8b
incq %rcx
cmpq %rcx, %rdi
jne 0x1cc7c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2e3eb
movq %rax, %r14
cmpl $0x0, 0x58(%rbx)
jle 0x1ce4b
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 0x912a1
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 0x1cdea
jmp 0x1ce4f
xorpd %xmm0, %xmm0
subsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x60(%rsp)
movq %r14, %rdi
callq 0x39194
movsd 0x60(%rsp), %xmm0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1cec5
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
cmpl $-0x1, 0x30(%r14)
movq %r14, %r15
je 0x1cea7
movq %r14, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1cc8d
movq %rax, %r15
cmpl $-0x1, 0x30(%rax)
jne 0x1ce93
movq %rbx, %rdi
callq 0x2eaca
xorl %ecx, %ecx
cmpl 0x34(%r15), %eax
sete %cl
addl %ecx, %ebp
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x1ce86
jmp 0x1cec7
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1cf7d
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x80(%rdi)
jle 0x1cf6b
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 0x39a80
testl %eax, %eax
je 0x1cf33
movq 0x58(%rbx), %rax
movq -0x30(%rax,%r14), %rdi
movq -0x28(%rax,%r14), %rsi
callq 0x3dbad
movq 0x58(%rbx), %rax
cmpl $-0x5, -0x50(%rax,%r14)
jne 0x1cf58
movups (%rax,%r14), %xmm0
movups 0x10(%rax,%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1cf7e
incq %r15
movslq 0x80(%rbx), %rax
addq $0x70, %r14
cmpq %rax, %r15
jl 0x1cefd
movq 0x58(%rbx), %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x39194
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
leaq 0x30(%rsp), %rbx
movq 0x8(%rbx), %rdi
callq 0x39194
movq 0x10(%rbx), %rdi
callq 0x39194
movslq (%rbx), %r14
testq %r14, %r14
jle 0x1cfbd
movq 0x18(%rbx), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x39194
incq %r12
cmpq %r12, %r14
jne 0x1cfac
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/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 0x1d1ed
cmpl $0x2, 0x98(%rbx)
je 0x1d1ed
leaq 0xb56d8(%rip), %r14     # 0xd2870
movq (%r14), %rcx
imulq $0x340, %rax, %r15      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%r15)
jne 0x1d1ed
movq (%r14), %rax
cmpl $0x0, 0x30f20(%rax,%r15)
jle 0x1d1e7
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %rdi
addq %r12, %rdi
callq 0x1cfd1
incq %r13
movq (%r14), %rax
movslq 0x30f20(%rax,%r15), %rax
addq $0x160, %r12            # imm = 0x160
cmpq %rax, %r13
jl 0x1d1c1
addq $0x10, %rbx
jmp 0x1d211
movq (%rbx), %rdi
callq 0x1cfd1
movq (%rbx), %rdi
callq 0x39194
movq $0x0, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
callq 0x1cfd1
movq (%rbx), %rdi
callq 0x39194
movq $0x0, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb544b(%rip), %r14     # 0xd2870
movq (%r14), %rax
movslq 0x10(%rax), %rax
testq %rax, %rax
jle 0x1d442
xorl %ecx, %ecx
xorl %ebp, %ebp
addl (%rbx,%rcx,4), %ebp
incq %rcx
cmpq %rcx, %rax
jne 0x1d435
jmp 0x1d444
xorl %ebp, %ebp
movq (%r14), %rax
cmpl $0x0, 0x10(%rax)
jle 0x1d4b5
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movl (%rbx,%r15,4), %eax
testl %eax, %eax
jle 0x1d4a4
testl %ebp, %ebp
jle 0x1d4a4
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, (%rsp)
movapd %xmm1, %xmm0
callq 0x38e99
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r15
movq (%r14), %rax
movslq 0x10(%rax), %rax
cmpq %rax, %r15
jl 0x1d45e
jmp 0x1d4b9
xorpd %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x660, %rsp            # imm = 0x660
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0xb5390(%rip), %r15     # 0xd2870
xorpd %xmm3, %xmm3
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %ebp, %ebp
movq $0x0, 0x340(%rsp,%r14,8)
movq (%r15), %rax
movslq 0x10(%rax), %rax
testq %rax, %rax
jle 0x1d531
movsd 0x340(%rsp,%r14,8), %xmm0
xorl %ecx, %ecx
xorps %xmm1, %xmm1
cvtsi2sdl (%rbx,%rcx,4), %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x1d513
movsd %xmm0, 0x340(%rsp,%r14,8)
movq $0x0, 0x20(%rsp,%r14,8)
movsd 0x340(%rsp,%r14,8), %xmm0
movsd %xmm0, 0x8(%rsp)
ucomisd 0x857b6(%rip), %xmm0    # 0xa2d08
jbe 0x1d5b5
movq (%r15), %rax
cmpl $0x0, 0x10(%rax)
jle 0x1d5b3
xorl %r12d, %r12d
movsd %xmm3, 0x10(%rsp)
movl (%rbx,%r12,4), %eax
testl %eax, %eax
jle 0x1d5a4
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
callq 0x38e99
movsd 0x10(%rsp), %xmm3
movsd 0x20(%rsp,%r14,8), %xmm1
mulsd 0x18(%rsp), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rsp,%r14,8)
incq %r12
movq (%r15), %rax
movslq 0x10(%rax), %rax
cmpq %rax, %r12
jl 0x1d566
incl %ebp
movsd 0x8(%rsp), %xmm1
addsd %xmm1, %xmm3
mulsd 0x20(%rsp,%r14,8), %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
incq %r14
addq $0xc8, %rbx
cmpq $0x64, %r14
jne 0x1d4ef
xorpd %xmm1, %xmm1
cmpeqsd %xmm3, %xmm1
movsd 0x856f7(%rip), %xmm0    # 0xa2cf0
movapd %xmm0, %xmm2
cmpl $0x1, %ebp
je 0x1d60b
movsd (%rsp), %xmm2
divsd %xmm3, %xmm2
movapd %xmm1, %xmm3
andnpd %xmm2, %xmm3
andpd %xmm1, %xmm0
orpd %xmm3, %xmm0
addq $0x660, %rsp            # imm = 0x660
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d64d
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1d62b
movq 0x8(%r14), %r14
jmp 0x1d635
movq 0x20(%r14), %rdi
callq 0x115e1
leaq 0xb5213(%rip), %rcx     # 0xd2870
movq (%rcx), %rcx
cmpl $0x0, 0x10(%rcx)
jle 0x1d67a
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
addl %esi, (%rbx,%rdx,4)
incq %rdx
movslq 0x10(%rcx), %rsi
cmpq %rsi, %rdx
jl 0x1d668
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/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 0x1d6b2
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1d689
movq 0x8(%r15), %r15
jmp 0x1d697
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_O1/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 0x1d6f8
movq (%rbx), %rdi
callq 0x1d6cb
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
callq 0x1d6cb
addsd 0x8(%rsp), %xmm0
jmp 0x1d720
movq 0x20(%rbx), %rdi
callq 0x115e1
movq %rax, %rbx
movq %rax, %rdi
callq 0x1d726
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x39194
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq