LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: sort_independence
double **sort_independence(bayesiangraphptr mygraph)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 21.01.2001*/
 int total=(mygraph->nodecount)*(mygraph->nodecount-1)/2,i,j,k;
 double **result;
 result = (double **)safemalloc_2d(sizeof(double *), sizeof(double), total, 3, "sort_independence", 3);
 k=0;
 for (i=0;i<mygraph->nodecount;i++)
   for (j=i+1;j<mygraph->nodecount;j++)
    {
     result[k][0]=i;
     result[k][1]=j;
     result[k][2]=mygraph->independence[i][j];
     k++;
    }
 qsort_independence(result,0,total-1);
 return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
leal -0x1(%rcx), %eax
imull %ecx, %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, %ebp
leaq 0x52c57(%rip), %r8      # 0x9a68c
pushq $0x8
popq %rdi
pushq $0x3
popq %rcx
movq %rdi, %rsi
movl %eax, %edx
movl %ecx, %r9d
callq 0x351c3
movq %rax, %r14
movl 0x10(%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
xorl %esi, %esi
cmpq %rdx, %rcx
je 0x47aaa
cvtsi2sd %ecx, %xmm0
movslq %esi, %rsi
movq %rcx, %rdi
leaq 0x1(%rdi), %r8
cmpl %r8d, %eax
jle 0x47aa5
movq (%r14,%rsi,8), %r9
cvtsi2sd %r8d, %xmm1
movsd %xmm0, (%r9)
movsd %xmm1, 0x8(%r9)
movq 0x30(%rbx), %r10
movq (%r10,%rcx,8), %r10
movsd 0x8(%r10,%rdi,8), %xmm1
movsd %xmm1, 0x10(%r9)
incq %rsi
movq %r8, %rdi
jmp 0x47a6b
incq %rcx
jmp 0x47a5c
decl %ebp
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x47970
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: cycle_now
int cycle_now(bayesiangraphptr mygraph,int from,int to)
{
/*!Last Changed 25.02.2001*/
/*Daha onceden fromdan toya bir arc vard. Bu arc yon degistirince cycle oluyor mu?*/
 int pos;
 pos=mygraph->nodes[to].pointer;
 while (pos!=-1)
  {
   if (from==mygraph->dest[pos])
     return 1;
   if (cycle_now(mygraph,from,mygraph->dest[pos]))
     return 1;
   pos=mygraph->arcs[pos].pointer;
  }
 return 0; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq 0x8(%rdi), %rax
movslq %edx, %rcx
imulq $0x48, %rcx, %rcx
leaq (%rax,%rcx), %r15
addq $0x30, %r15
pushq $0x1
popq %rbx
movslq (%r15), %r15
cmpq $-0x1, %r15
je 0x47b0f
movq 0x28(%r14), %rax
movl (%rax,%r15,4), %edx
cmpl %ebp, %edx
je 0x47b11
movq %r14, %rdi
movl %ebp, %esi
callq 0x47ac0
testl %eax, %eax
jne 0x47b11
shlq $0x2, %r15
addq 0x18(%r14), %r15
jmp 0x47ae2
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: add_arcs_according_to_ordering
void add_arcs_according_to_ordering(bayesiangraphptr mygraph,double **edges,int edgecount)
{
/*!Last Changed 13.03.2001*/
 int i,j,k;
 for (i = 0; i < edgecount; i++)
  {
   j = (int) edges[i][0];
   k = (int) edges[i][1];
   add_one_arc(mygraph);
   if (mygraph->ordering[j]>mygraph->ordering[k])
    {
     add_one_pointer(mygraph,&mygraph->nodes[j],k);
     add_parent_counts(mygraph,&mygraph->nodes[j],k);
    }
   else
    {
     add_one_pointer(mygraph,&mygraph->nodes[k],j);
     add_parent_counts(mygraph,&mygraph->nodes[k],j);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
testl %edx, %edx
cmovlel %r13d, %ebx
cmpq %r13, %rbx
je 0x48174
movq (%r14,%r13,8), %rax
cvttsd2si (%rax), %r12d
cvttsd2si 0x8(%rax), %ebp
movq %r15, %rdi
callq 0x47603
movq 0x40(%r15), %rdx
movslq %r12d, %rax
movl (%rdx,%rax,4), %esi
movslq %ebp, %rcx
cmpl (%rdx,%rcx,4), %esi
jg 0x48149
movq %rcx, %rax
movl %r12d, %ebp
imulq $0x48, %rax, %r12
movq 0x8(%r15), %rsi
addq %r12, %rsi
movq %r15, %rdi
movl %ebp, %edx
callq 0x47654
addq 0x8(%r15), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x476d6
incq %r13
jmp 0x48116
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: load_network
void load_network(char *filename)
{
 int i = net_extension(filename);
 bayesiangraphptr newnetwork = NULL;
 switch (i)
  {
   case NET_FILE  :newnetwork = (bayesiangraphptr)read_network_net(filename);
                   break;
   case XML_FILE  :newnetwork = (bayesiangraphptr)read_network_xml(filename);
                   break;
   case HUGIN_FILE:newnetwork = (bayesiangraphptr)read_network_hugin(filename);
                   break;
   case BIF_FILE  :newnetwork = (bayesiangraphptr)read_network_bif(filename);
                   break;
 };
 if (newnetwork==NULL)
  {
   printf(m1044);
   return;
  }
 add_network(newnetwork);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x342ac
cmpl $0x3, %eax
ja 0x4869c
movl %eax, %eax
leaq 0x51fed(%rip), %rcx     # 0x9a64c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x68374
jmp 0x4868e
movq %rbx, %rdi
callq 0x6797a
jmp 0x4868e
movq %rbx, %rdi
callq 0x674c0
jmp 0x4868e
movq %rbx, %rdi
callq 0x67c63
testq %rax, %rax
je 0x4869c
movq %rax, %rdi
popq %rbx
jmp 0x48607
leaq 0x52047(%rip), %rdi     # 0x9a6ea
popq %rbx
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: print_independences
void print_independences(void (*print)(bayesiangraphptr mygraph), char* networkname)
{
 bayesiangraphptr G;
 if (networkname)
  {
   G = find_network(networkname);
   if (G)
     print(G);
   else
     printf(m1273, networkname);
  }
 else
   printf(m1020);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x486d4
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x486ff
testq %rax, %rax
je 0x486e7
movq %rax, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x52029(%rip), %rdi     # 0x9a704
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4090
leaq 0x51fd6(%rip), %rdi     # 0x9a6c4
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4030
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: find_network
bayesiangraphptr find_network(char *name)
{
 int i;
 for (i=0;i<graphcount;i++)
   if (strcmp(Graphs[i]->name,name)==0)
     return Graphs[i];
 return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x84dee(%rip), %rax     # 0xcd500
movslq (%rax), %r15
leaq 0x2e774c(%rip), %rax    # 0x32fe68
movq (%rax), %r12
xorl %r13d, %r13d
cmpq %r15, %r13
jge 0x4873f
movq (%r12,%r13,8), %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x4260
incq %r13
testl %eax, %eax
jne 0x48722
jmp 0x48742
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/network.c
// Function: learn_network
void learn_network(char *graph_name, char *train_file, char *cv_file, char *test_file, int algorithm)
{
 bayesiangraphptr newnetwork;
 switch (algorithm){
   case 0:newnetwork = (bayesiangraphptr)simulated_annealing_bn(graph_name, train_file, cv_file, test_file, get_parameter_l("ordering"), get_parameter_f("infthreshold"));
          break;
   case 1:newnetwork = (bayesiangraphptr)k2_bn(graph_name, train_file, cv_file, test_file, get_parameter_l("ordering"), 2);
          break;
 }
 if (newnetwork)
   add_network(newnetwork);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r13d
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x522ba(%rip), %rdi     # 0x9aa2a
callq 0x4cf11
movl %eax, %ebp
testl %r13d, %r13d
je 0x48796
pushq $0x2
popq %r9
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x826c9
jmp 0x487b6
leaq 0x51f40(%rip), %rdi     # 0x9a6dd
callq 0x4cdcf
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x825d0
testq %rax, %rax
je 0x487d1
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x48607
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/nodeboundedtree.c
// Function: prune_node_bounded_tree_nodes
void prune_node_bounded_tree_nodes(Decisionnodeptr root, Decisionnodeptr toberemoved, Nodeboundedtree_parameterptr param, Decisionnodeptr* nodes, double* generalizationerror, int* index, int datasize)
{
 /*!Last Changed 30.09.2007*/
 int tmp, h;
 double error;
 if (toberemoved->featureno == LEAF_NODE)
   return;
 (*index)++;
 nodes[*index] = toberemoved;
 tmp = toberemoved->featureno;
 toberemoved->featureno = LEAF_NODE;
 error = decisiontree_falsepositive_count(root) / (datasize + 0.0);
 h = decisiontree_vc_dimension_wrt_nodetype(current_dataset, decisiontree_node_count(root), param->model - 5);
 generalizationerror[*index] = srm_classification(error, h, datasize, param->a1, param->a2);
 toberemoved->featureno = tmp;
 prune_node_bounded_tree_nodes(root, toberemoved->left, param, nodes, generalizationerror, index, datasize);
 prune_node_bounded_tree_nodes(root, toberemoved->right, param, nodes, generalizationerror, index, datasize);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %r8, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
cvtsi2sdl 0x70(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %r15
cmpl $-0x1, 0x30(%r13)
je 0x488d2
movslq (%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%rbx)
movq %r13, 0x8(%r15,%rax,8)
movl 0x30(%r13), %eax
movl %eax, 0x14(%rsp)
orl $-0x1, 0x30(%r13)
movq %rbp, %rdi
callq 0x1a6bc
cvtsi2sd %eax, %xmm0
divsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0x85016(%rip), %rax     # 0xcd870
movq (%rax), %r14
movq %rbp, %rdi
callq 0x1a8d0
movl 0x8(%r12), %edx
addl $-0x5, %edx
movq %r14, %rdi
movl %eax, %esi
callq 0x93ba7
movsd 0x18(%r12), %xmm1
movsd 0x20(%r12), %xmm2
movsd 0x30(%rsp), %xmm0
movl %eax, %edi
movl 0x70(%rsp), %r14d
movl %r14d, %esi
callq 0x41c3e
movslq (%rbx), %rax
movq 0x28(%rsp), %r8
movsd %xmm0, (%r8,%rax,8)
movl 0x14(%rsp), %eax
movl %eax, 0x30(%r13)
movq (%r13), %rsi
movl %r14d, (%rsp)
movq %rbp, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r9
callq 0x487e0
movq 0x8(%r13), %r13
jmp 0x48815
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/nodeboundedtree.c
// Function: prune_node_bounded_tree
void prune_node_bounded_tree(Decisionnodeptr root, Nodeboundedtree_parameterptr param, int datasize)
{
 /*!Last Changed 30.09.2007*/
 int finished = NO, count, h, index, best;
 double *generalizationerror, error;
 Decisionnodeptr *nodes, toberemoved;
 while (!finished)
  {
   count = decisiontree_node_count(root) + 1;
   nodes = safemalloc(count * sizeof(Decisionnodeptr), "prune_node_bounded_tree", 7);
   generalizationerror = safemalloc(count * sizeof(double), "prune_node_bounded_tree", 8);
   error = decisiontree_falsepositive_count(root) / (datasize + 0.0);
   h = decisiontree_vc_dimension_wrt_nodetype(current_dataset, count - 1, param->model - 5);
   generalizationerror[0] = srm_classification(error, h, datasize, param->a1, param->a2);
   index = 0;
   prune_node_bounded_tree_nodes(root, root, param, nodes, generalizationerror, &index, datasize);
   best = find_min_in_list_double(generalizationerror, count);
   finished = YES;
   if (best != 0)
    {
     toberemoved = nodes[best];
     finished = NO;
     if (in_list(toberemoved->featureno, 2, LINEAR, QUADRATIC))
       matrix_free(toberemoved->w);
     accumulate_instances_tree(&(toberemoved->instances), toberemoved);
     toberemoved->featureno = LEAF_NODE;
     free_children(toberemoved);
    }
   safe_free(nodes);
   safe_free(generalizationerror);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl %edx, 0xc(%rsp)
cvtsi2sd %edx, %xmm0
movsd %xmm0, 0x18(%rsp)
xorl %ebx, %ebx
testl %ebx, %ebx
jne 0x48a31
movq %r15, %rdi
callq 0x1a8d0
movslq %eax, %rbx
incl %eax
movl %eax, 0x10(%rsp)
leaq 0x8(,%rbx,8), %rbp
movq %rbp, %rdi
leaq 0x51dfc(%rip), %r12     # 0x9a72c
movq %r12, %rsi
pushq $0x7
popq %rdx
callq 0x34f59
movq %rax, %r13
movq %rbp, %rdi
movq %r12, %rsi
pushq $0x8
popq %rdx
callq 0x34f59
movq %rax, %rbp
movq %r15, %rdi
callq 0x1a6bc
cvtsi2sd %eax, %xmm0
divsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
leaq 0x84f02(%rip), %rax     # 0xcd870
movq (%rax), %rdi
movl 0x8(%r14), %edx
addl $-0x5, %edx
movl %ebx, %esi
callq 0x93ba7
movsd 0x18(%r14), %xmm1
movsd 0x20(%r14), %xmm2
movsd 0x20(%rsp), %xmm0
movl %eax, %edi
movl 0xc(%rsp), %ebx
movl %ebx, %esi
callq 0x41c3e
movsd %xmm0, (%rbp)
andl $0x0, 0x14(%rsp)
movl %ebx, (%rsp)
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %rbp, %r8
leaq 0x14(%rsp), %r9
callq 0x487e0
movq %rbp, %rdi
movl 0x10(%rsp), %esi
callq 0x338cc
pushq $0x1
popq %rbx
testl %eax, %eax
je 0x48a1c
cltq
movq (%r13,%rax,8), %rbx
movl 0x30(%rbx), %edi
pushq $0x2
popq %rsi
pushq $-0x2
popq %rdx
pushq $-0x3
popq %rcx
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x48a02
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
callq 0x3929f
leaq 0x20(%rbx), %rdi
movq %rbx, %rsi
callq 0x1aad3
orl $-0x1, 0x30(%rbx)
movq %rbx, %rdi
callq 0x1b42e
xorl %ebx, %ebx
movq %r13, %rdi
callq 0x34ff7
movq %rbp, %rdi
callq 0x34ff7
jmp 0x48905
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/nodeboundedtree.c
// Function: add_node_to_heap
void add_node_to_heap(Decisionnodeptr node, Node_expandedptr* list, int nodeindex)
{
 /*!Last Changed 11.07.2006*/
 Node_expandedptr newexpanded, tmp, tmpbefore = NULL;
 newexpanded = safemalloc(sizeof(Node_expanded), "add_node_to_expanded_list", 8);
 newexpanded->next = NULL;
 newexpanded->node = node;
 if (nodeindex == -1)
   newexpanded->value = -log_likelihood_for_classification(node->counts);
 else
   if (nodeindex == -2)
     newexpanded->value = -entropy(node->counts);
   else
     newexpanded->value = -nodeindex;
 if (!(*list))
   *list = newexpanded;
 else
  {
   tmp = *list;
   while (tmp && tmp->value > newexpanded->value)
    {
     tmpbefore = tmp;
     tmp = tmp->next;
    }
   if (tmpbefore)
    {
     newexpanded->next = tmpbefore->next;
     tmpbefore->next = newexpanded;
    }
   else
    {
     newexpanded->next = *list;
     *list = newexpanded;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x51cee(%rip), %rsi     # 0x9a744
pushq $0x18
popq %rdi
pushq $0x8
popq %rdx
callq 0x34f59
movq %rax, %r14
andq $0x0, 0x10(%rax)
movq %r15, (%rax)
cmpl $-0x2, %ebp
je 0x48a84
cmpl $-0x1, %ebp
jne 0x48a9a
movq 0xa0(%r15), %rdi
callq 0x1b961
jmp 0x48a90
movq 0xa0(%r15), %rdi
callq 0x1b694
xorpd 0x4d738(%rip), %xmm0    # 0x961d0
jmp 0x48aa0
negl %ebp
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x8(%r14)
movq (%rbx), %rax
testq %rax, %rax
je 0x48ae3
xorl %ecx, %ecx
movq %rax, %rsi
testq %rsi, %rsi
je 0x48acf
movq %rsi, %rdx
movsd 0x8(%rsi), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x48acf
movq 0x10(%rdx), %rsi
movq %rdx, %rcx
jmp 0x48ab3
testq %rcx, %rcx
je 0x48adf
movq 0x10(%rcx), %rax
addq $0x10, %rcx
movq %rcx, %rbx
movq %rax, 0x10(%r14)
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/nodeboundedtree.c
// Function: add_node_to_expanded_list
int add_node_to_expanded_list(Decisionnodeptr node, Node_expandedptr* list, int nodeindex, int usediscrete)
{
 /*!Last Changed 01.07.2006 added nodeindex*/
 /*!Last Changed 19.03.2006*/
 if (!usediscrete)
   node->conditiontype = HYBRID_CONDITION;
 else
   node->conditiontype = UNIVARIATE_CONDITION;
 if (!can_be_divided(node, NULL))
  {
   make_leaf_node(node);
   return 0;
  }
 add_node_to_heap(node, list, nodeindex);
 return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
xorl %eax, %eax
testl %ecx, %ecx
sete %al
addl %eax, %eax
movl %eax, 0x98(%rdi)
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x1abee
movq %r14, %rdi
testl %eax, %eax
je 0x48b31
movq %r15, %rsi
movl %ebx, %edx
callq 0x48a40
pushq $0x1
popq %r12
jmp 0x48b36
callq 0x1a6ac
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/nodeboundedtree.c
// Function: empty_heap
void empty_heap(Node_expandedptr header)
{
 /*!Last Changed 01.07.2006*/
 Node_expandedptr nextexpanded;
 while (header)
  {
   nextexpanded = header->next;
   make_leaf_node(header->node);
   safe_free(header);
   header = nextexpanded;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rbx, %rbx
je 0x48b6a
movq (%rbx), %rdi
movq 0x10(%rbx), %r14
callq 0x1a6ac
movq %rbx, %rdi
callq 0x34ff7
movq %r14, %rbx
jmp 0x48b4c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/nodeboundedtree.c
// Function: create_binary_tree_according_model_string
Decisionnodeptr create_binary_tree_according_model_string(char* model)
{
 /*!Last Changed 11.07.2006*/
 Node_expandedptr header = NULL, nextexpanded;
 int nodeindex = 0;
 char ch;
 Decisionnodeptr rootnode, expanded_node, leftnode, rightnode;
 rootnode = createnewnode(NULL, 1);
 add_node_to_heap(rootnode, &header, nodeindex);
 nodeindex++;
 while (header)
  {
   nextexpanded = header->next;
   expanded_node = header->node;
   ch = model[-2 * (int) (header->value) + 1];
   safe_free(header);
   header = nextexpanded;
   expanded_node->featureno = DUMMY_MODEL;
   leftnode = createnewnode(expanded_node, 1);
   expanded_node->left = leftnode;
   rightnode = createnewnode(expanded_node, 1);
   expanded_node->right = rightnode; 
   switch (ch)
    {
     case '1':add_node_to_heap(leftnode, &header, nodeindex);
              nodeindex++;
              break;
     case '2':add_node_to_heap(leftnode, &header, nodeindex);
              nodeindex++;
              add_node_to_heap(rightnode, &header, nodeindex);
              nodeindex++;
              break;
    }
  }
 return rootnode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
pushq $0x1
popq %rbp
xorl %edi, %edi
movl %ebp, %esi
callq 0x1ac98
movq %rax, 0x18(%rsp)
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x48a40
movl %ebp, %eax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x48c77
movq (%rdi), %r15
movq 0x10(%rdi), %r12
cvttsd2si 0x8(%rdi), %eax
addl %eax, %eax
negl %eax
cltq
movq 0x20(%rsp), %rcx
movzbl 0x1(%rcx,%rax), %ebx
callq 0x34ff7
movl $0xfffffc18, 0x30(%r15) # imm = 0xFFFFFC18
movq %r15, %rdi
movl %ebp, %esi
callq 0x1ac98
movq %rax, %r13
movq %rax, (%r15)
movq %r15, %rdi
movl %ebp, %esi
callq 0x1ac98
movq %rax, 0x8(%r15)
cmpl $0x32, %ebx
je 0x48c3a
movq %r12, %rdi
cmpl $0x31, %ebx
jne 0x48bb8
movq %r12, 0x8(%rsp)
movq %r13, %rdi
leaq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rbx
movl %ebx, %edx
callq 0x48a40
incl %ebx
movq %rbx, 0x10(%rsp)
jmp 0x48bb3
movq %rax, %r14
movq %r12, 0x8(%rsp)
movq %r13, %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
movq 0x10(%rsp), %r15
movl %r15d, %edx
callq 0x48a40
leal 0x1(%r15), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x48a40
addl $0x2, %r15d
movq %r15, 0x10(%rsp)
jmp 0x48bb3
movq 0x18(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/omnivariaterule.c
// Function: write_nodetypes_rule
void write_nodetypes_rule(Ruleset r, char* st)
{
 /*!Last Changed 19.02.2005*/
 /*!Last Changed 24.01.2004*/
 Decisionruleptr tmprule;
 Decisionconditionptr tmpcondition;
 sprintf(st, "%s", "");
 tmprule = r.start;
 while (tmprule)
  {
   tmpcondition = tmprule->start;
   while (tmpcondition)
    {     
     if (tmpcondition->featureindex == LINEAR)
       sprintf(st, "%sL", st);
     else
       if (tmpcondition->featureindex == QUADRATIC)
         sprintf(st, "%sQ", st);
       else 
         if (tmpcondition->featureindex == UNIVARIATE)
           sprintf(st, "%sU", st);
         else
           if (tmpcondition->featureindex == DISCRETEMIX)
             sprintf(st, "%s%c", st, 'A' + tmpcondition->ksplit.featurecount - 1);
           else
             sprintf(st, "%sU", st);
     tmpcondition = tmpcondition->next;
    }
   sprintf(st, "%s-%d;", st, tmprule->classno);
   tmprule = tmprule->next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movb $0x0, (%rdi)
leaq 0x51597(%rip), %r15     # 0x9a7e4
leaq 0x51570(%rip), %r12     # 0x9a7c4
leaq 0x51581(%rip), %rbp     # 0x9a7dc
movq (%r14), %r14
testq %r14, %r14
je 0x492f0
leaq 0x18(%r14), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x492d0
movl (%r13), %eax
addl $0x5, %eax
cmpl $0x5, %eax
ja 0x49289
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x492c0
movq %rbx, %rdi
leaq 0x51545(%rip), %rsi     # 0x9a7e0
jmp 0x492c0
movl 0x50(%r13), %ecx
addl $0x40, %ecx
movq %rbx, %rdi
leaq 0x4d302(%rip), %rsi     # 0x965b0
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41b0
jmp 0x492ca
movq %rbx, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41b0
addq $0x48, %r13
jmp 0x4926b
movl (%r14), %ecx
movq %rbx, %rdi
leaq 0x5150b(%rip), %rsi     # 0x9a7e8
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41b0
addq $0x30, %r14
jmp 0x4925b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/omnivariaterule.c
// Function: write_datasizes_and_nodetypes_rule
void write_datasizes_and_nodetypes_rule(Ruleset r, char* st)
{
 /*!Last Changed 19.02.2005*/
 /*!Last Changed 24.01.2004*/
 Decisionruleptr tmprule;
 Decisionconditionptr tmpcondition;
 sprintf(st, "%s", "");
 tmprule = r.start;
 while (tmprule)
  {
   tmpcondition = tmprule->start;
   while (tmpcondition)
    {
     sprintf(st,"%s-%d,",st,tmpcondition->datasize);
     if (tmpcondition->featureindex == LINEAR)
       sprintf(st,"%sL",st);
     else 
       if (tmpcondition->featureindex == QUADRATIC)         
         sprintf(st,"%sQ",st);
       else
         sprintf(st,"%sU",st);
     tmpcondition = tmpcondition->next;
    }
   sprintf(st,"%s;",st);
   tmprule = tmprule->next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40(%rsp), %rax
movb $0x0, (%rdi)
leaq 0x514d3(%rip), %r15     # 0x9a7ef
leaq 0x514bd(%rip), %r13     # 0x9a7e0
leaq 0x514ba(%rip), %rbp     # 0x9a7e4
leaq 0x514ab(%rip), %r14     # 0x9a7dc
movq (%rax), %rax
testq %rax, %rax
je 0x493a5
movq %rax, (%rsp)
leaq 0x18(%rax), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x49387
movl 0x38(%r12), %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41b0
movl (%r12), %eax
cmpl $-0x3, %eax
movq %rbp, %rsi
cmoveq %r13, %rsi
cmpl $-0x2, %eax
cmoveq %r14, %rsi
movq %rbx, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41b0
addq $0x48, %r12
jmp 0x49341
movq %rbx, %rdi
leaq 0x51465(%rip), %rsi     # 0x9a7f6
movq %rbx, %rdx
xorl %eax, %eax
callq 0x41b0
movq (%rsp), %rax
addq $0x30, %rax
jmp 0x49331
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/omnivariaterule.c
// Function: log_likelihood_for_rule_induction
double log_likelihood_for_rule_induction(int poscount, int negcount)
{
 /*!Last Changed 20.02.2005*/
 int sum;
 double ratio;
 sum = poscount + negcount;
 if (sum * poscount * negcount == 0)
   return 0;
 ratio = poscount / (sum + 0.0);
 return poscount * log2(ratio);
}

// Assembly:
leal (%rsi,%rdi), %eax
imull %edi, %esi
imull %eax, %esi
testl %esi, %esi
je 0x493e2
pushq %rax
cvtsi2sd %edi, %xmm0
movsd %xmm0, (%rsp)
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
callq 0x34d77
mulsd (%rsp), %xmm0
addq $0x8, %rsp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/omnivariaterule.c
// Function: log_likelihood_of_condition
double log_likelihood_of_condition(Decisionconditionptr c, Instanceptr list, int positive, int* covered)
{
 /*!Last Changed 19.02.2005*/
 int poscovered = 0, negcovered = 0, posuncovered = 0, neguncovered = 0, classno;
 Instanceptr tmp;
 tmp = list;
 while (tmp)
  {
   classno = give_classno(tmp);
   if (condition_cover_instance(tmp, c))
     if (classno == positive)
       poscovered++;
     else
       negcovered++;
   else
     if (classno == positive)
       posuncovered++;
     else
       neguncovered++;
   tmp = tmp->next;
  }
 *covered = poscovered + posuncovered;
 return log_likelihood_for_rule_induction(poscovered, negcovered) + log_likelihood_for_rule_induction(posuncovered, neguncovered);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
xorl %ebp, %ebp
movq $0x0, 0x10(%rsp)
movl $0x0, 0x4(%rsp)
xorl %r13d, %r13d
testq %r15, %r15
je 0x49462
movq %r15, %rdi
callq 0x2b47e
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7099c
testl %eax, %eax
je 0x49441
cmpl %r12d, %r14d
jne 0x49454
incl %r13d
jmp 0x4945c
cmpl %r12d, %r14d
jne 0x49458
movq 0x10(%rsp), %rax
incl %eax
movq %rax, 0x10(%rsp)
jmp 0x4945c
incl %ebp
jmp 0x4945c
incl 0x4(%rsp)
movq 0x10(%r15), %r15
jmp 0x49418
movq 0x10(%rsp), %rbx
leal (%rbx,%r13), %eax
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movl %r13d, %edi
movl %ebp, %esi
callq 0x493b4
movsd %xmm0, 0x8(%rsp)
movl %ebx, %edi
movl 0x4(%rsp), %esi
callq 0x493b4
addsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/omnivariaterule.c
// Function: log_likelihood_of_rule
double log_likelihood_of_rule(Decisionruleptr c, Instanceptr list, int* covered)
{
 /*!Last Changed 19.02.2005*/
 int poscovered = 0, negcovered = 0, posuncovered = 0, neguncovered = 0, classno;
 Instanceptr tmp;
 tmp = list;
 while (tmp)
  {
   classno = give_classno(tmp);
   if (rule_cover_instance(tmp, *c))
     if (classno == c->classno)
       poscovered++;
     else
       negcovered++;
   else
     if (classno == c->classno)
       posuncovered++;
     else
       neguncovered++;
   tmp = tmp->next;
  }
 *covered = poscovered + posuncovered;
 return log_likelihood_for_rule_induction(poscovered, negcovered) + log_likelihood_for_rule_induction(posuncovered, neguncovered);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x40(%rsp)
movq %rsi, %r13
movq %rdi, %r15
xorl %ebp, %ebp
xorl %r14d, %r14d
movl $0x0, 0x3c(%rsp)
xorl %r12d, %r12d
testq %r13, %r13
je 0x49530
movq %r13, %rdi
callq 0x2b47e
movl %eax, %ebx
movq 0x30(%r15), %rax
movq %rax, 0x30(%rsp)
movupd (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq %r13, %rdi
callq 0x71406
movl (%r15), %ecx
testl %eax, %eax
je 0x49519
cmpl %ecx, %ebx
jne 0x49522
incl %r12d
jmp 0x4952a
cmpl %ecx, %ebx
jne 0x49526
incl %r14d
jmp 0x4952a
incl %ebp
jmp 0x4952a
incl 0x3c(%rsp)
movq 0x10(%r13), %r13
jmp 0x494cb
leal (%r12,%r14), %eax
movq 0x40(%rsp), %rcx
movl %eax, (%rcx)
movl %r12d, %edi
movl %ebp, %esi
callq 0x493b4
movsd %xmm0, 0x40(%rsp)
movl %r14d, %edi
movl 0x3c(%rsp), %esi
callq 0x493b4
addsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/omnivariaterule.c
// Function: generalization_error_after_pruning
double generalization_error_after_pruning(Ruleset r, Instanceptr data, int positive, int modelselectionmethod)
{
 /*!Last Changed 19.02.2005*/
 int *deleted, rulecount, i;
 double result, tmp;
 Decisionruleptr rule;
 deleted = safecalloc(r.rulecount, sizeof(int), "generalization_error_after_pruning", 4);
 result = generalization_error_of_ruleset_with_deleted_rules(r, data, deleted, positive, modelselectionmethod);
 rule = r.start;
 rulecount = 0;
 while (rule && rule->classno != positive)
  {
   rule = rule->next;
   rulecount++;
  }
 for (i = r.rulecount - 1; i >= rulecount; i--)
  {
   deleted[i] = 1;
   tmp = generalization_error_of_ruleset_with_deleted_rules(r, data, deleted, positive, modelselectionmethod);
   if (tmp > result)
     deleted[i] = 0;
   else
     result = tmp;
  }
 safe_free(deleted);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x70(%rsp), %r13
movslq 0x10(%r13), %r15
leaq 0x50eec(%rip), %rdx     # 0x9a847
pushq $0x4
popq %rsi
pushq $0x4
popq %rcx
movq %r15, %rdi
callq 0x35067
movq %rax, %r12
movq 0x20(%r13), %rax
movq %rax, 0x20(%rsp)
movapd (%r13), %xmm0
movaps 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq %r14, 0x30(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %ebx, %r14d
movl %ebx, %ecx
callq 0x4970c
movsd %xmm0, 0x28(%rsp)
xorl %ebx, %ebx
movq %r13, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x49a0e
cmpl %ebp, (%rax)
je 0x49a0e
addq $0x30, %rax
incq %rbx
jmp 0x499ac
movl $0x1, (%r12,%r15,4)
movq 0x20(%r13), %rax
movq %rax, 0x20(%rsp)
movupd (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %r14d, %ecx
callq 0x4970c
ucomisd 0x28(%rsp), %xmm0
jbe 0x49a08
andl $0x0, (%r12,%r15,4)
jmp 0x49a0e
movsd %xmm0, 0x28(%rsp)
decq %r15
leaq 0x1(%r15), %rax
cmpq %rbx, %rax
jg 0x499c1
movq %r12, %rdi
callq 0x34ff7
movsd 0x28(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/omnivariaterule.c
// Function: growrule_omnivariate
Decisionruleptr growrule_omnivariate(Instanceptr* growset, int positive, Ripper_parameterptr param)
{
 /*!Last Changed 21.01.2004*/
 /*!Last Changed 29.12.2003*/
 /*!Last Changed 02.12.2003*/
 /*!Last Changed 10.05.2003*/
 Decisionruleptr result;
 Decisionconditionptr newcondition = NULL;
 Instanceptr obey, notobey = NULL;
 int n, pnew, nnew;
 result = empty_rule(positive);
 obey = (*growset);
 if (rule_cover_negative(obey, *result))
   n = 1;
 else
   n = 0;
 while (n > 0)
  {
   newcondition = find_best_hybrid_condition(&obey, positive, param);
   if (newcondition && newcondition->featureindex != -1)
    {
     count_examples_for_condition(newcondition, &pnew, &nnew, positive, obey);
     if (result->decisioncount == 0 || nnew != n)
       n = nnew;
     else
      {
       free_condition(*newcondition);
       safe_free(newcondition);
       break;
      }
     send_exceptions(newcondition, &obey, &notobey);
     add_condition(result, newcondition);
    }
   else
    {
     if (newcondition && newcondition->featureindex == -1)
      {
       free_condition(*newcondition);
       safe_free(newcondition);
      }
     break;
    }
  }
 if (notobey)
  {
   merge_instancelist(&notobey, obey);
   (*growset) = notobey;
  }
 else
   (*growset) = obey;
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, 0x98(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x78(%rsp), %rax
andq $0x0, (%rax)
movl %esi, %edi
callq 0x719a4
movq %rax, %r15
movq %rbx, 0x90(%rsp)
movq (%rbx), %rdi
leaq 0x88(%rsp), %r12
movq %rdi, (%r12)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x71f54
xorl %r13d, %r13d
testl %eax, %eax
setne %r13b
testl %r13d, %r13d
jle 0x4a0c4
movq %r12, %rdi
movl %ebp, %esi
movq 0x98(%rsp), %rdx
callq 0x4a8c1
testq %rax, %rax
je 0x4a0c4
movq %rax, %rbx
cmpl $-0x1, (%rax)
je 0x4a0ab
movq 0x88(%rsp), %r8
movq %rbx, %rdi
leaq 0xa4(%rsp), %rsi
leaq 0x84(%rsp), %rdx
movl %ebp, %ecx
callq 0x70ba5
cmpl $0x0, 0x28(%r15)
movl 0x84(%rsp), %r14d
je 0x4a08b
cmpl %r13d, %r14d
je 0x4a0ab
movq %rbx, %rdi
movq %r12, %rsi
leaq 0x78(%rsp), %rdx
callq 0x8ffc1
movq %r15, %rdi
movq %rbx, %rsi
callq 0x719fe
movl %r14d, %r13d
jmp 0x4a02d
pushq $0xe
popq %rcx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x71b91
movq %rbx, %rdi
callq 0x34ff7
cmpq $0x0, 0x78(%rsp)
je 0x4a0e1
movq 0x88(%rsp), %rsi
leaq 0x78(%rsp), %r12
movq %r12, %rdi
callq 0x2c6e4
movq (%r12), %rax
movq 0x90(%rsp), %rcx
movq %rax, (%rcx)
movq %r15, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/omnivariatetree.c
// Function: decisiontree_node_types
void decisiontree_node_types(Decisionnodeptr node, char st[READLINELENGTH], int level)
{
 int i;
 if (node->featureno != LEAF_NODE)
  {
   if (node->featureno >= 0)
     sprintf(st, "%s%d-U-%d;", st, level, node->covered);
   else
     if (node->featureno == LINEAR)
       sprintf(st, "%s%d-L-%d;", st, level, node->covered);
     else
       if (node->featureno == QUADRATIC) 
         sprintf(st, "%s%d-Q-%d;", st, level, node->covered);
       else
         if (node->featureno == DISCRETEMIX)
           sprintf(st, "%s%d-%d;", st, level, node->ksplit.featurecount);
   if (node->featureno >= 0 && current_dataset->features[node->featureno].type == STRING)
    {
     for (i = 0; i < current_dataset->features[node->featureno].valuecount; i++)
       decisiontree_node_types(&(node->string[i]), st, level + 1);
    }
   else
    {
     decisiontree_node_types(node->left, st, level + 1);
     decisiontree_node_types(node->right, st, level + 1);    
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4f85a(%rip), %r12     # 0x9a90c
leaq 0x827b7(%rip), %rbp     # 0xcd870
leaq 0x4f857(%rip), %r13     # 0x9a917
movl 0x30(%r15), %eax
cmpl $-0x1, %eax
je 0x4b1a7
testl %eax, %eax
js 0x4b11d
movl 0x84(%r15), %r8d
movq %r14, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x41b0
movslq 0x30(%r15), %rax
testq %rax, %rax
js 0x4b108
movq (%rbp), %rcx
imulq $0x340, %rax, %rdx      # imm = 0x340
cmpl $0x1, 0x30f08(%rcx,%rdx)
je 0x4b164
movq (%r15), %rdi
incl %ebx
movq %r14, %rsi
movl %ebx, %edx
callq 0x4b098
movq 0x8(%r15), %r15
jmp 0x4b0c0
cmpl $-0x5, %eax
je 0x4b14e
cmpl $-0x3, %eax
je 0x4b13b
cmpl $-0x2, %eax
jne 0x4b108
movl 0x84(%r15), %r8d
movq %r14, %rdi
movq %r13, %rsi
jmp 0x4b0de
movl 0x84(%r15), %r8d
movq %r14, %rdi
leaq 0x4f7d6(%rip), %rsi     # 0x9a922
jmp 0x4b0de
movl 0x140(%r15), %r8d
movq %r14, %rdi
leaq 0x4f7ce(%rip), %rsi     # 0x9a92d
jmp 0x4b0de
incl %ebx
xorl %r12d, %r12d
xorl %r13d, %r13d
cltq
imulq $0x340, %rax, %rax      # imm = 0x340
movslq 0x30f20(%rcx,%rax), %rax
cmpq %rax, %r13
jge 0x4b1a7
movq 0x10(%r15), %rdi
addq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x4b098
incq %r13
movq (%rbp), %rcx
movl 0x30(%r15), %eax
addq $0x160, %r12            # imm = 0x160
jmp 0x4b16c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/omnivariatetree.c
// Function: find_uni_and_multi_splits
void find_uni_and_multi_splits(Decisionnodeptr node, matrix* qw, double* qw0, double points[3], double variance_explained, int hybridspace)
{
 /*!Last Changed 22.11.2004*/
 node->featureno = find_best_ldt_feature_for_realized(node->instances, &(node->split));
 points[0] = node->featureno;
 node->lineard = find_best_multi_ldt_split(&(node->instances), &(node->w), &(node->w0), MULTIVARIATE_LINEAR, variance_explained);
 points[1] = node->lineard - 1;
 if (points[1] == -1)
   matrix_free(node->w);
 points[2] = -1;
 if (hybridspace == 3)
  {
   node->quadraticd = find_best_multi_ldt_split(&(node->instances), qw, qw0, MULTIVARIATE_QUADRATIC, variance_explained);
   points[2] = node->quadraticd - 1;
   if (points[2] == -1)
     matrix_free(*qw);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movsd %xmm0, (%rsp)
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x20(%rdi), %r13
movq 0x20(%rdi), %rdi
leaq 0x28(%r15), %rsi
callq 0x92b17
cvtsi2sd %eax, %xmm0
movl %eax, 0x30(%r15)
movsd %xmm0, (%r14)
leaq 0x38(%r15), %rsi
leaq 0x48(%r15), %rdx
pushq $-0x2
popq %rcx
movq %r13, %rdi
movsd (%rsp), %xmm0
callq 0x46e18
movl %eax, 0x90(%r15)
subl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%r14)
jae 0x4b7f2
movq 0x38(%r15), %rdi
movq 0x40(%r15), %rsi
callq 0x3929f
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x10(%r14)
cmpl $0x3, %ebp
jne 0x4b84b
pushq $-0x3
popq %rcx
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movsd (%rsp), %xmm0
callq 0x46e18
movl %eax, 0x94(%r15)
subl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%r14)
jae 0x4b84b
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3929f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/omnivariatetree.c
// Function: calculate_counts_for_ldt_splits
void calculate_counts_for_ldt_splits(int univariate, Decisionnodeptr node, int *C, int *U, int *fp, int *fn)
{
 /*!Last Changed 22.11.2004*/
 int counts[2][MAXCLASSES], i, leftclass, rightclass;
 if (univariate)
   find_counts_for_split(node->instances, node->featureno, node->split, counts[0], counts[1], node->conditiontype);
 else
   find_counts_for_multivariate_split(node->instances, node->w, node->w0, counts[0], counts[1]);
 leftclass = find_max_in_list(counts[0], MAXCLASSES);
 rightclass = find_max_in_list(counts[1], MAXCLASSES);
 *C = 0;
 *U = 0;
 *fp = 0;
 *fn = 0;
 for (i = 0; i < current_dataset->classno; i++)
  {
   *C += counts[0][i];
   *U += counts[1][i];
   if (i != leftclass)
     *fp += counts[0][i];
   if (i != rightclass)
     *fn += counts[1][i];
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movl %edi, %eax
movq 0x20(%rsi), %rdi
testl %eax, %eax
je 0x4b8a4
movl 0x30(%rsi), %eax
movsd 0x28(%rsi), %xmm0
leaq 0xc8(%rsp), %rcx
movl 0x98(%rsi), %r8d
movq %rsp, %rdx
movl %eax, %esi
callq 0x91c39
jmp 0x4b8c4
movsd 0x48(%rsi), %xmm0
leaq 0xc8(%rsp), %r8
movq 0x38(%rsi), %rax
movq 0x40(%rsi), %rdx
movq %rsp, %rcx
movq %rax, %rsi
callq 0x46bb8
movq %rsp, %rdi
pushq $0x32
popq %rbp
movl %ebp, %esi
callq 0x336b5
movl %eax, %r13d
leaq 0xc8(%rsp), %rdi
movl %ebp, %esi
callq 0x336b5
andl $0x0, (%r12)
andl $0x0, (%r15)
andl $0x0, (%r14)
andl $0x0, (%rbx)
leaq 0x81f76(%rip), %rcx     # 0xcd870
movq (%rcx), %rcx
movl %eax, %eax
movl %r13d, %edx
xorl %esi, %esi
movslq 0x10(%rcx), %rdi
cmpq %rdi, %rsi
jge 0x4b933
movl (%rsp,%rsi,4), %r8d
addl %r8d, (%r12)
movl 0xc8(%rsp,%rsi,4), %edi
addl %edi, (%r15)
cmpq %rsi, %rdx
je 0x4b927
addl %r8d, (%r14)
cmpq %rsi, %rax
je 0x4b92e
addl %edi, (%rbx)
incq %rsi
jmp 0x4b904
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/omnivariatetree.c
// Function: set_best_hybrid_split
int set_best_hybrid_split(double results[3], Decisionnodeptr node, matrix qw, double qw0, int hybridspace)
{
 /*!Last Changed 01.02.2005*/
 int bestmodel;
 bestmodel = find_min_in_list_double(results, hybridspace);
 if (bestmodel == -1)
  {
   node->featureno = LEAF_NODE;
   return 0;
  }
 switch (bestmodel)
  {
   case MODEL_UNI:if (results[1] != -1)
                    matrix_free(node->w);
                  if (results[2] != -1 && hybridspace == 3)
                    matrix_free(qw);
                  break;
   case MODEL_LIN:node->featureno = LINEAR;
                  if (results[2] != -1 && hybridspace == 3)
                    matrix_free(qw);
                  break;
   case MODEL_QUA:node->featureno = QUADRATIC;
                  if (results[1] != -1)
                    matrix_free(node->w);
                  node->w = qw;
                  node->w0 = qw0;
                  break;
  }
 return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movsd %xmm0, (%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl %r8d, %esi
callq 0x338cc
pushq $0x1
popq %rbx
incl %eax
cmpl $0x3, %eax
ja 0x4ba27
leaq 0x4ef4f(%rip), %rcx     # 0x9a8d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
orl $-0x1, 0x30(%r12)
xorl %ebx, %ebx
jmp 0x4ba27
movl $0xfffffffe, 0x30(%r12) # imm = 0xFFFFFFFE
jmp 0x4ba05
movl $0xfffffffd, 0x30(%r12) # imm = 0xFFFFFFFD
movsd 0x8(%r13), %xmm0
ucomisd 0x4a3f7(%rip), %xmm0    # 0x95db0
jne 0x4b9bd
jnp 0x4b9cc
movq 0x38(%r12), %rdi
movq 0x40(%r12), %rsi
callq 0x3929f
movq %r15, 0x38(%r12)
movq %r14, 0x40(%r12)
movsd (%rsp), %xmm0
movsd %xmm0, 0x48(%r12)
jmp 0x4ba27
movsd 0x8(%r13), %xmm0
ucomisd 0x4a3be(%rip), %xmm0    # 0x95db0
jne 0x4b9f6
jnp 0x4ba05
movq 0x38(%r12), %rdi
movq 0x40(%r12), %rsi
callq 0x3929f
cmpl $0x3, %ebp
jne 0x4ba27
movsd 0x10(%r13), %xmm0
ucomisd 0x4a398(%rip), %xmm0    # 0x95db0
jne 0x4ba1c
jnp 0x4ba27
movq %r15, %rdi
movq %r14, %rsi
callq 0x3929f
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/omnivariatetree.c
// Function: find_best_hybrid_ldt_split_single_model
int find_best_hybrid_ldt_split_single_model(Decisionnodeptr node, NODE_TYPE model, double variance_explained)
{
 /*!Last Changed 13.02.2005*/
 switch (model)
  {
   case UNIVARIATE:node->featureno = find_best_ldt_feature_for_realized(node->instances, &(node->split));
                   if (node->featureno == -1)
                     return 0;
                   break;
   case     LINEAR:node->lineard = find_best_multi_ldt_split(&(node->instances), &(node->w), &(node->w0), MULTIVARIATE_LINEAR, variance_explained);
                   if (node->lineard == 0)
                    {
                     matrix_free(node->w);
                     node->featureno = LEAF_NODE;
                     return 0;
                    }
                   else
                     node->featureno = LINEAR;
                   break;
   case  QUADRATIC:node->quadraticd = find_best_multi_ldt_split(&(node->instances), &(node->w), &(node->w0), MULTIVARIATE_QUADRATIC, variance_explained);
                   if (node->quadraticd == 0)
                    {
                     matrix_free(node->w);
                     node->featureno = LEAF_NODE;
                     return 0;
                    }
                   else
                     node->featureno = QUADRATIC;
                   break;
   default        :node->featureno = LEAF_NODE;
                   printf("This node type is not supported\n");
                   break;
  }
 return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $-0x3, %esi
je 0x4ba88
cmpl $-0x2, %esi
je 0x4ba61
testl %esi, %esi
jne 0x4baaf
movq 0x20(%rbx), %rdi
leaq 0x28(%rbx), %rsi
callq 0x92b17
movl %eax, 0x30(%rbx)
cmpl $-0x1, %eax
jne 0x4babf
jmp 0x4bad5
leaq 0x20(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x48(%rbx), %rdx
pushq $-0x2
popq %rcx
callq 0x46e18
movl %eax, 0x90(%rbx)
testl %eax, %eax
je 0x4bac4
movl $0xfffffffe, 0x30(%rbx) # imm = 0xFFFFFFFE
jmp 0x4babf
leaq 0x20(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x48(%rbx), %rdx
pushq $-0x3
popq %rcx
callq 0x46e18
movl %eax, 0x94(%rbx)
testl %eax, %eax
je 0x4bac4
movl $0xfffffffd, 0x30(%rbx) # imm = 0xFFFFFFFD
jmp 0x4babf
orl $-0x1, 0x30(%rbx)
leaq 0x4eeab(%rip), %rdi     # 0x9a965
callq 0x4090
pushq $0x1
popq %rax
jmp 0x4bad7
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
callq 0x3929f
orl $-0x1, 0x30(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/omnivariatetree.c
// Function: find_best_hybrid_ldt_split_aic
int find_best_hybrid_ldt_split_aic(Decisionnodeptr node, Multildt_parameterptr param)
{
 /*!Last Changed 01.02.2005*/
 /*!Last Changed 22.11.2004*/
 int hybridspace = get_parameter_i("hybridspace");
 matrix qw;
 int d, i;
 double qw0, results[3], loglikelihood;
 find_uni_and_multi_splits(node, &qw, &qw0, results, param->variance_explained, hybridspace);
 for (i = 0; i < hybridspace; i++)
   if (results[i] != -1)
    {
     switch (i)
      {
       case 0:loglikelihood = log_likelihood_for_uni_ldt_splits(node->instances, node->featureno, node->split, param->conditiontype);
              d = 2;
              break;
       case 1:loglikelihood = log_likelihood_for_multi_ldt_splits(node->instances, node->w, node->w0);
              d = node->lineard + 1;
              break;
       case 2:loglikelihood = log_likelihood_for_multi_ldt_splits(node->instances, qw, qw0);
              d = node->quadraticd + 1;
              break;
       default:loglikelihood = 0.0;
               d = 0;
               break;
      }
     results[i] = aic_loglikelihood(loglikelihood, d);
    }
 return set_best_hybrid_split(results, node, qw, qw0, hybridspace);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4d124(%rip), %rdi     # 0x98c18
callq 0x4cd35
movl %eax, %ebp
movsd 0x20(%r14), %xmm0
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbx, %rdi
movl %eax, %r8d
callq 0x4b77a
xorl %r15d, %r15d
testl %ebp, %ebp
movl %ebp, %r12d
cmovlel %r15d, %r12d
pushq $0x2
popq %r13
cmpq %r15, %r12
je 0x4bbd5
movsd 0x20(%rsp,%r15,8), %xmm0
ucomisd 0x4a26d(%rip), %xmm0    # 0x95db0
jne 0x4bb4b
jnp 0x4bbcd
cmpl $0x2, %r15d
je 0x4bb94
cmpl $0x1, %r15d
je 0x4bb76
testl %r15d, %r15d
jne 0x4bbb7
movq 0x20(%rbx), %rdi
movl 0x30(%rbx), %esi
movsd 0x28(%rbx), %xmm0
movl 0x2c(%r14), %edx
callq 0x933e6
movl %r13d, %eax
jmp 0x4bbbd
movsd 0x48(%rbx), %xmm0
movq 0x20(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
callq 0x46dc7
movl 0x90(%rbx), %eax
jmp 0x4bbb3
movq 0x20(%rbx), %rdi
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x46dc7
movl 0x94(%rbx), %eax
incl %eax
jmp 0x4bbbd
xorpd %xmm0, %xmm0
xorl %eax, %eax
cvtsi2sd %eax, %xmm1
callq 0x40bcb
movsd %xmm0, 0x20(%rsp,%r15,8)
incq %r15
jmp 0x4bb2b
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %r8d
callq 0x4b945
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq