LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: test_randomforest
Prediction test_randomforest(Instanceptr data, void* model, void* parameters, double* posterior)
{
 int i;
 double* votes;
 Randomforest_parameterptr p;
 Decisionnodeptr* forest;
 Prediction predicted, predictedc45;
 forest = (Decisionnodeptr*) model;
 p = (Randomforest_parameterptr) parameters;
 votes = safecalloc(current_dataset->classno, sizeof(double), "test_randomforest", 5);
 for (i = 0; i < p->forestsize; i++) 
  {
   predictedc45 = test_c45(data, forest[i], parameters, posterior);
   votes[predictedc45.classno]++;
  }
 normalize_array_of_doubles(votes, current_dataset->classno);
 memcpy(posterior, votes, current_dataset->classno * sizeof(double));
 safe_free(votes);
 predicted.classno = findMaxOutput(posterior, current_dataset->classno);
 return predicted;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, 0x8(%rsp)
leaq 0xc4aa7(%rip), %rax     # 0xcd870
movq (%rax), %rax
movslq 0x10(%rax), %rdi
leaq 0x8d0da(%rip), %rdx     # 0x95eb1
pushq $0x8
popq %rsi
pushq $0x5
popq %rcx
callq 0x35067
movq %rax, %r15
xorl %ebx, %ebx
movslq (%r12), %rax
cmpq %rax, %rbx
jge 0x8e23
movq (%r13,%rbx,8), %rdx
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %r14, %r8
callq 0x8e7e
movslq 0x18(%rsp), %rax
movsd (%r15,%rax,8), %xmm0
addsd 0x8c708(%rip), %xmm0    # 0x95520
movsd %xmm0, (%r15,%rax,8)
incq %rbx
jmp 0x8de7
leaq 0xc4a46(%rip), %rbx     # 0xcd870
movq (%rbx), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x33c59
movq (%rbx), %rax
movslq 0x10(%rax), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4310
movq %r15, %rdi
callq 0x34ff7
movq (%rbx), %rax
movl 0x10(%rax), %esi
movq %r14, %rdi
callq 0x339b7
movq 0x8(%rsp), %rcx
movl %eax, 0x8(%rcx)
movq %rcx, %rax
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/classification.c
// Function: test_c45
Prediction test_c45(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 11.07.2006 if there is no data at the node the posteriors will be same and 1 / classno*/
 /*!Last Changed 01.11.2005 added posteriors*/
 Decisionnodeptr currentnode, root = (Decisionnodeptr) model;
 Prediction predicted;
 currentnode = root;
 while (currentnode->featureno != LEAF_NODE)
   currentnode = next_node(currentnode, data);
 if (get_parameter_o("laplaceestimate") == ON)
   normalize_array_laplace(currentnode->counts, posterior, current_dataset->classno);
	else
   normalize_array(currentnode->counts, posterior, current_dataset->classno);
 predicted.classno = currentnode->classno;
 return predicted;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
cmpl $-0x1, 0x30(%r14)
je 0x8ea9
movq %r14, %rdi
movq %r12, %rsi
callq 0x1af8a
movq %rax, %r14
jmp 0x8e92
leaq 0x8d013(%rip), %rdi     # 0x95ec3
callq 0x4cff1
movq 0xa0(%r14), %rdi
leaq 0xc49ad(%rip), %rcx     # 0xcd870
movq (%rcx), %rcx
movl 0x10(%rcx), %edx
movq %r15, %rsi
cmpl $0x1, %eax
jne 0x8ed8
callq 0x33bf9
jmp 0x8edd
callq 0x33b8f
movl 0x34(%r14), %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_kforest
void* train_kforest(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 int i;
 Kforest_parameterptr p;
 Decisionnodeptr* forest;
 Decisionnodeptr rootnode;
 Instanceptr data;
 p = (Kforest_parameterptr) parameters;
 forest = safemalloc(p->forestsize * sizeof(Decisionnodeptr), "train_randomforest", 4);
 for (i = 0; i < p->forestsize; i++)
  {
   rootnode = createnewnode(NULL, 1);
   rootnode->instances = bootstrap_sample_without_stratification(*trdata);
   create_kforestchildren(rootnode, p);
   data = NULL;
   accumulate_instances_tree(&data, rootnode);
   deallocate(data);
   forest[i] = rootnode;
  }
 return forest;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movslq (%rdx), %rdi
shlq $0x3, %rdi
leaq 0x8cf8c(%rip), %rsi     # 0x95e9e
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r15
xorl %ebp, %ebp
movq %rsp, %r12
movslq (%rbx), %rax
cmpq %rax, %rbp
jge 0x8f70
xorl %edi, %edi
pushq $0x1
popq %rsi
callq 0x1ac98
movq %rax, %r13
movq (%r14), %rdi
callq 0x2c859
movq %rax, 0x20(%r13)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x1a258
andq $0x0, (%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x1aad3
movq (%rsp), %rdi
callq 0x2c010
movq %r13, (%r15,%rbp,8)
incq %rbp
jmp 0x8f22
movq %r15, %rax
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/classification.c
// Function: test_kforest
Prediction test_kforest(Instanceptr data, void* model, void* parameters, double* posterior)
{
 int i;
 double* votes;
 Kforest_parameterptr p;
 Decisionnodeptr* forest;
 Prediction predicted, predictedc45;
 forest = (Decisionnodeptr*) model;
 p = (Kforest_parameterptr) parameters;
 votes = safecalloc(current_dataset->classno, sizeof(double), "test_randomforest", 5);
 for (i = 0; i < p->forestsize; i++)
  {
   predictedc45 = test_c45(data, forest[i], parameters, posterior);
   votes[predictedc45.classno]++;
  }
 normalize_array_of_doubles(votes, current_dataset->classno);
 memcpy(posterior, votes, current_dataset->classno * sizeof(double));
 safe_free(votes);
 predicted.classno = findMaxOutput(posterior, current_dataset->classno);
 return predicted;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, 0x8(%rsp)
leaq 0xc48c8(%rip), %rax     # 0xcd870
movq (%rax), %rax
movslq 0x10(%rax), %rdi
leaq 0x8cefb(%rip), %rdx     # 0x95eb1
pushq $0x8
popq %rsi
pushq $0x5
popq %rcx
callq 0x35067
movq %rax, %r15
xorl %ebx, %ebx
movslq (%r12), %rax
cmpq %rax, %rbx
jge 0x9002
movq (%r13,%rbx,8), %rdx
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %r14, %r8
callq 0x8e7e
movslq 0x18(%rsp), %rax
movsd (%r15,%rax,8), %xmm0
addsd 0x8c529(%rip), %xmm0    # 0x95520
movsd %xmm0, (%r15,%rax,8)
incq %rbx
jmp 0x8fc6
leaq 0xc4867(%rip), %rbx     # 0xcd870
movq (%rbx), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x33c59
movq (%rbx), %rax
movslq 0x10(%rax), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4310
movq %r15, %rdi
callq 0x34ff7
movq (%rbx), %rax
movl 0x10(%rax), %esi
movq %r14, %rdi
callq 0x339b7
movq 0x8(%rsp), %rcx
movl %eax, 0x8(%rcx)
movq %rcx, %rax
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/classification.c
// Function: make_tree_stump
void make_tree_stump(Decisionnodeptr rootnode)
{
 int count, i;
 if (!make_children(rootnode))
  {
   setup_node_properties(rootnode);
   make_leaf_node(rootnode);
   return;
  }
 switch (current_dataset->features[rootnode->featureno].type)
  {
   case INTEGER:
   case REAL   :setup_node_properties(rootnode->left);
                make_leaf_node(rootnode->left);
                setup_node_properties(rootnode->right);
                make_leaf_node(rootnode->right);
                break;
   case STRING :count = current_dataset->features[rootnode->featureno].valuecount;
                for (i = 0; i < count; i++)
                 {
                  setup_node_properties(&(rootnode->string[i]));
                  make_leaf_node(&(rootnode->string[i]));
                 }
                break;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x91657
testl %eax, %eax
je 0x90b7
leaq 0xc47fb(%rip), %rax     # 0xcd870
movq (%rax), %rax
movslq 0x30(%rbx), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %edx
cmpl $0x2, %edx
je 0x9098
cmpl $0x1, %edx
je 0x90cc
testl %edx, %edx
jne 0x910e
movq (%rbx), %rdi
callq 0x1ab8f
movq (%rbx), %rdi
callq 0x1a6ac
movq 0x8(%rbx), %rdi
callq 0x1ab8f
movq 0x8(%rbx), %rbx
jmp 0x90bf
movq %rbx, %rdi
callq 0x1ab8f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1a6ac
addq %rcx, %rax
addq $0x30f08, %rax          # imm = 0x30F08
movl 0x18(%rax), %eax
xorl %r14d, %r14d
testl %eax, %eax
cmovlel %r14d, %eax
imulq $0x160, %rax, %r15      # imm = 0x160
cmpq %r14, %r15
je 0x910e
movq 0x10(%rbx), %rdi
addq %r14, %rdi
callq 0x1ab8f
movq 0x10(%rbx), %rdi
addq %r14, %rdi
callq 0x1a6ac
addq $0x160, %r14            # imm = 0x160
jmp 0x90e8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_c45stump
void* train_c45stump(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 Decisionnodeptr rootnode;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 rootnode->conditiontype = UNIVARIATE_CONDITION;
 rootnode->featureno = find_best_feature(rootnode->instances, &(rootnode->split));
 make_tree_stump(rootnode);
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x1ac98
movq %rax, %r14
movq (%rbx), %rdi
movq %rdi, 0x20(%rax)
andl $0x0, 0x98(%rax)
leaq 0x28(%rax), %rsi
callq 0x915cb
movl %eax, 0x30(%r14)
movq %r14, %rdi
callq 0x905d
andq $0x0, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: test_c45stump
Prediction test_c45stump(Instanceptr data, void* model, void* parameters, double* posterior)
{
 Decisionnodeptr currentnode, root = (Decisionnodeptr) model;
 Prediction predicted;
 currentnode = root;
 while (currentnode->featureno != LEAF_NODE)
   currentnode = next_node(currentnode, data);
 normalize_array(currentnode->counts, posterior, current_dataset->classno);
 predicted.classno = currentnode->classno;
 return predicted;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
cmpl $-0x1, 0x30(%r15)
je 0x9185
movq %r15, %rdi
movq %r12, %rsi
callq 0x1af8a
movq %rax, %r15
jmp 0x916e
movq 0xa0(%r15), %rdi
leaq 0xc46dd(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x10(%rax), %edx
movq %r14, %rsi
callq 0x33b8f
movl 0x34(%r15), %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_ldtstump
void* train_ldtstump(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 Decisionnodeptr rootnode;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 rootnode->conditiontype = UNIVARIATE_CONDITION;
 rootnode->featureno = find_best_ldt_feature(rootnode->instances, &(rootnode->split));
 make_tree_stump(rootnode);
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x1ac98
movq %rax, %r14
movq (%rbx), %rdi
movq %rdi, 0x20(%rax)
andl $0x0, 0x98(%rax)
leaq 0x28(%rax), %rsi
callq 0x92f52
movl %eax, 0x30(%r14)
movq %r14, %rdi
callq 0x905d
andq $0x0, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_multildtstump
void* train_multildtstump(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 Decisionnodeptr rootnode;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 rootnode->conditiontype = MULTIVARIATE_CONDITION;
 rootnode->lineard = find_best_multi_ldt_split(&(rootnode->instances), &(rootnode->w), &(rootnode->w0), MULTIVARIATE_LINEAR, 0.99);
 if (!(rootnode->lineard))
  {
   matrix_free(rootnode->w);
   setup_node_properties(rootnode);
   make_leaf_node(rootnode);
  }
 else
  {
   rootnode->featureno = LINEAR;
   make_multivariate_children(rootnode);
   setup_node_properties(rootnode->left);
   make_leaf_node(rootnode->left);
   setup_node_properties(rootnode->right);
   make_leaf_node(rootnode->right);
  }
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x1ac98
movq %rax, %r14
movq (%rbx), %rax
leaq 0x20(%r14), %rdi
movq %rax, 0x20(%r14)
movl $0x1, 0x98(%r14)
leaq 0x38(%r14), %rsi
leaq 0x48(%r14), %rdx
pushq $-0x2
popq %rcx
movsd 0x8cb70(%rip), %xmm0    # 0x95db8
callq 0x46e18
movl %eax, 0x90(%r14)
testl %eax, %eax
je 0x9287
movl $0xfffffffe, 0x30(%r14) # imm = 0xFFFFFFFE
movq %r14, %rdi
callq 0x4692e
movq (%r14), %rdi
callq 0x1ab8f
movq (%r14), %rdi
callq 0x1a6ac
movq 0x8(%r14), %rdi
callq 0x1ab8f
movq 0x8(%r14), %rdi
jmp 0x929f
movq 0x38(%r14), %rdi
movq 0x40(%r14), %rsi
callq 0x3929f
movq %r14, %rdi
callq 0x1ab8f
movq %r14, %rdi
callq 0x1a6ac
andq $0x0, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_softstump
void* train_softstump(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	Decisionnodeptr treenode;
	Softregtree_parameterptr p;
	p = (Softregtree_parameterptr) parameters;
 treenode = createnewnode(NULL, 1);
 treenode->weight = 1.0;
 treenode->instances = *trdata;
 treenode->leaftype = p->leaftype;
 if (p->leaftype == CONSTANTLEAF)
   treenode->w0 = produce_random_value(-0.01, +0.01);
 else
   treenode->w = random_matrix(current_dataset->multifeaturecount, 1, -0.01, +0.01);
 find_best_soft_tree_split(treenode, treenode, *trdata, p);
 if (treenode->left != NULL)
  {
   make_leaf_node(treenode->left);
   make_leaf_node(treenode->right);
  }
 else
   make_leaf_node(treenode);
	*trdata = NULL;
	return treenode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x1ac98
movq %rax, %r14
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%r14)
movq (%rbx), %rax
movq %rax, 0x20(%r14)
movl (%r15), %eax
movl %eax, 0x60(%r14)
testl %eax, %eax
je 0x932b
leaq 0xc4570(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x1c0(%rax), %edi
pushq $0x1
popq %rsi
movsd 0x8caac(%rip), %xmm0    # 0x95dc0
movsd 0x8caac(%rip), %xmm1    # 0x95dc8
callq 0x393f5
movq %rax, 0x38(%r14)
movq %rdx, 0x40(%r14)
jmp 0x9346
movsd 0x8ca8d(%rip), %xmm0    # 0x95dc0
movsd 0x8ca8d(%rip), %xmm1    # 0x95dc8
callq 0x35cae
movsd %xmm0, 0x48(%r14)
movq (%rbx), %rdx
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x7eb34
movq (%r14), %rdi
testq %rdi, %rdi
je 0x936a
callq 0x1a6ac
movq 0x8(%r14), %rdi
jmp 0x936d
movq %r14, %rdi
callq 0x1a6ac
andq $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_c45
void* train_c45(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 Decisionnodeptr rootnode;
 C45_parameterptr p;
 p = (C45_parameterptr) parameters;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 create_c45children(rootnode, p);
 if (in_list(p->prunetype, 2, MODELSELECTIONPRUNING, VALIDATIONPRUNING))
  prune_tree(rootnode, rootnode, *cvdata);
 else
  if (p->prunetype == SRMPRUNING)
   {
   if (p->prunemodel == LOCAL)
    prune_tree_according_to_model_selection_method(rootnode, MODEL_SELECTION_SRM);
   else
    prune_tree_global(rootnode, rootnode, MODEL_SELECTION_SRM);
   }
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x1
popq %rbp
xorl %edi, %edi
movl %ebp, %esi
callq 0x1ac98
movq %rax, %r14
movq (%rbx), %rax
movq %rax, 0x20(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x91b41
movl (%r15), %edi
pushq $0x2
popq %rdx
movl %edx, %esi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x941b
movq (%r12), %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x1b4d4
jmp 0x9443
cmpl $0x4, (%r15)
jne 0x9443
cmpl $0x0, 0x4(%r15)
je 0x9438
pushq $0x3
popq %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x4b1b6
jmp 0x9443
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x4b3a0
andq $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_ktree
void* train_ktree(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 Decisionnodeptr rootnode;
 C45_parameterptr p;
 p = (C45_parameterptr) parameters;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 create_ktreechildren(rootnode, p);
 if (in_list(p->prunetype, 2, MODELSELECTIONPRUNING, VALIDATIONPRUNING))
   prune_tree(rootnode, rootnode, *cvdata);
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rbp
xorl %edi, %edi
movl %ebp, %esi
callq 0x1ac98
movq %rax, %r15
movq (%rbx), %rax
movq %rax, 0x20(%r15)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2f0d6
movl (%r12), %edi
pushq $0x2
popq %rdx
movl %edx, %esi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x94a9
movq (%r14), %rdx
movq %r15, %rdi
movq %r15, %rsi
callq 0x1b4d4
andq $0x0, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_nearestmean
void* train_nearestmean(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 22.03.2005*/
 int *counts;
 Instanceptr classmeans;
 counts = find_class_counts(*trdata);
 classmeans = find_class_means(*trdata, counts);
 safe_free(counts);
 return classmeans;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x108c8
movq %rax, %r14
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x10bb9
movq %rax, %rbx
movq %r14, %rdi
callq 0x34ff7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: test_nearestmean
Prediction test_nearestmean(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 22.03.2005*/
 Instanceptr classmeans;
 int j;
 Prediction predicted;
 classmeans = (Instanceptr) model;
 find_nearest_mean(classmeans, data, &(predicted.classno));
 j = give_classno(data);
 posterior[j] = 1.0;
 return predicted;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rdx
movq %rax, %rdi
callq 0xc470
movq %r14, %rdi
callq 0x2b47e
cltq
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rbx,%rax,8)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_gaussian
void* train_gaussian(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 19.12.2005*/
 Model_gaussianptr m;
 int* counts, datacount = data_size(*trdata), i;
 m = safemalloc(sizeof(Model_gaussian), "train_gaussian", 3);
 counts = find_class_counts(*trdata);
 m->mean = find_class_means(*trdata, counts);
 m->variance = find_class_variance(*trdata, m->mean, counts);
 m->priors = safemalloc(current_dataset->classno * sizeof(double), "train_gaussian", 7);
 for (i = 0; i < current_dataset->classno; i++)
   m->priors[i] = counts[i] / (datacount + 0.0);
 safe_free(counts);
 return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x2c3cc
movl %eax, %ebp
leaq 0x8c97f(%rip), %r15     # 0x95ed3
pushq $0x18
popq %rdi
pushq $0x3
popq %rdx
movq %r15, %rsi
callq 0x34f59
movq %rax, %rbx
movq (%r12), %rdi
callq 0x108c8
movq %rax, %r14
movq (%r12), %rdi
movq %rax, %rsi
callq 0x10bb9
movq %rax, (%rbx)
movq (%r12), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x10e7d
movq %rax, 0x8(%rbx)
leaq 0xc42d6(%rip), %r12     # 0xcd870
movq (%r12), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
pushq $0x7
popq %rdx
movq %r15, %rsi
callq 0x34f59
movq %rax, 0x10(%rbx)
movq (%r12), %rcx
movslq 0x10(%rcx), %rcx
cvtsi2sd %ebp, %xmm0
xorl %edx, %edx
cmpq %rcx, %rdx
jge 0x95dc
cvtsi2sdl (%r14,%rdx,4), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdx,8)
incq %rdx
jmp 0x95c3
movq %r14, %rdi
callq 0x34ff7
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: test_gaussian
Prediction test_gaussian(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 19.12.2005*/
 Model_gaussianptr m;
 Instanceptr m_i;
 int i;
 double sum;
 Prediction predicted;
 m = (Model_gaussianptr)model;
 m_i = m->mean;
 sum = 0;
 for (i = 0; i < current_dataset->classno; i++)
  {
   posterior[i] = m->priors[i] * gaussian_vector(data, m_i, sqrt(m->variance[i]));
   sum += posterior[i];
   m_i = m_i->next;
  }
 for (i = 0; i < current_dataset->classno; i++)
   posterior[i] /= sum;
 predicted.classno = findMaxOutput(posterior, current_dataset->classno);
 return predicted;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, (%rsp)
xorl %ebp, %ebp
leaq 0xc425c(%rip), %rbx     # 0xcd870
movq %rdx, %r13
xorpd %xmm1, %xmm1
movq (%rbx), %rax
movslq 0x10(%rax), %rsi
cmpq %rsi, %rbp
jge 0x968c
movsd %xmm1, 0x10(%rsp)
movq (%r13), %r13
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movsd (%rcx,%rbp,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rax,%rbp,8), %xmm0
ucomisd 0x8c6c7(%rip), %xmm0    # 0x95d18
jb 0x9659
sqrtsd %xmm0, %xmm0
jmp 0x965e
callq 0x4300
movq %r12, %rdi
movq %r13, %rsi
callq 0x801a8
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, (%r14,%rbp,8)
movsd 0x10(%rsp), %xmm1
addsd %xmm2, %xmm1
addq $0x10, %r13
incq %rbp
jmp 0x961b
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
cmpq %rax, %rcx
je 0x96b2
movsd (%r14,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
jmp 0x9698
movq %r14, %rdi
callq 0x339b7
movq (%rsp), %rcx
movl %eax, 0x8(%rcx)
movq %rcx, %rax
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/classification.c
// Function: train_ldt
void* train_ldt(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 04.10.2004 added writerules*/
 /*!Last Changed 02.02.2004*/
 /*!Last Changed 09.02.2003*/
 Decisionnodeptr rootnode;
 C45_parameterptr p;
 p = (C45_parameterptr) parameters;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 create_ldtchildren(rootnode, p);
 if (in_list(p->prunetype, 2, MODELSELECTIONPRUNING, VALIDATIONPRUNING))
   prune_tree(rootnode, rootnode, *cvdata);
 else
  {
   if (p->prunemodel == LOCAL)
     prune_tree_according_to_model_selection_method(rootnode, MODEL_SELECTION_SRM);
   else
     prune_tree_global(rootnode, rootnode, MODEL_SELECTION_SRM);
  }
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x1
popq %rbp
xorl %edi, %edi
movl %ebp, %esi
callq 0x1ac98
movq %rax, %r14
movq (%rbx), %rax
movq %rax, 0x20(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x9343a
movl (%r15), %edi
pushq $0x2
popq %rdx
movl %edx, %esi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0xa5e5
movq (%r12), %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x1b4d4
jmp 0xa607
cmpl $0x0, 0x4(%r15)
je 0xa5fc
pushq $0x3
popq %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x4b1b6
jmp 0xa607
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x4b3a0
andq $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_irep
void* train_irep(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 10.11.2003 Rulecount, decisioncount and mdl added*/
 /*!Last Changed 21.05.2003 free_ruleset function is added*/
 /*!Last Changed 13.05.2003*/
 Ruleset* r;
 Ripper_parameterptr p;
 p = (Ripper_parameterptr) parameters;
 r = safemalloc(sizeof(Ruleset), "train_irep", 4);
 *r = learn_ruleset_ripper(trdata, 0, p);
 update_counts_ruleset(*r, *trdata);
 return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8b8d4(%rip), %rsi     # 0x95f11
pushq $0x28
popq %rdi
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x6f24f
movq 0x20(%r12), %rax
movq %rax, 0x20(%r15)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq (%r14), %rdi
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x72314
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_irep2
void* train_irep2(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 10.11.2003 Rulecount, decisioncount and mdl added*/
 /*!Last Changed 21.05.2003 free_ruleset function is added*/
 /*!Last Changed 13.05.2003*/
 Ruleset* r;
 Ripper_parameterptr p;
 p = (Ripper_parameterptr) parameters;
 r = safemalloc(sizeof(Ruleset), "train_irep2", 4);
 *r = learn_ruleset_ripper(trdata, 1, p);
 update_counts_ruleset(*r, *trdata);
 return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8b61d(%rip), %rsi     # 0x95f1c
pushq $0x28
popq %rdi
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r15
leaq 0x30(%rsp), %r12
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x6f24f
movq 0x20(%r12), %rax
movq %rax, 0x20(%r15)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq (%r14), %rdi
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x72314
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_ripper
void* train_ripper(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 10.11.2003 Rulecount, decisioncount and mdl added*/
 /*!Last Changed 21.05.2003 free_ruleset function is added*/
 /*!Last Changed 13.05.2003*/
 Ruleset* r;
 Ripper_parameterptr p;
 p = (Ripper_parameterptr) parameters;
 r = safemalloc(sizeof(Ruleset), "train_ripper", 4);
 *r = learn_ruleset_ripper(trdata, 2, p);
 update_counts_ruleset(*r, *trdata);
 return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8b590(%rip), %rsi     # 0x95f28
pushq $0x28
popq %rdi
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r15
leaq 0x30(%rsp), %r12
pushq $0x2
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x6f24f
movq 0x20(%r12), %rax
movq %rax, 0x20(%r15)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq (%r14), %rdi
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x72314
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_cn2
void* train_cn2(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 Ruleset* r;
 Cn2_parameterptr p;
 p = (Cn2_parameterptr)parameters;
 r = safemalloc(sizeof(Ruleset), "train_cn2", 2);
 *r = learn_ruleset_cn2(trdata, p);
 update_counts_ruleset(*r, *trdata);
 return r; 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8b485(%rip), %rsi     # 0x95f35
pushq $0x28
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd2a8
movq 0x20(%r12), %rax
movq %rax, 0x20(%r15)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq (%r14), %rdi
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x72314
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_lerils
void* train_lerils(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 Ruleset* r;
 Lerils_parameterptr p;
 p = (Lerils_parameterptr)parameters;
 r = safemalloc(sizeof(Ruleset), "train_lerils", 2);
 *r = learn_ruleset_lerils(trdata, p);
 return r; 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8b3f9(%rip), %rsi     # 0x95f3f
pushq $0x28
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x33158
movq 0x20(%r12), %rax
movq %rax, 0x20(%r15)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: test_part
Prediction test_part(Instanceptr data, void* model, void* parameters, double* posterior)
{
 Decisionruleptr tmp;
 Ruleset* r;
 Prediction predicted;
 r = (Ruleset*) model;
 tmp = r->start;
 while (tmp)
  {
   if (rule_cover_instance(data, *tmp))
    {
     predicted.classno = tmp->classno;
     return predicted;    
    }
   tmp = tmp->next;
  }
 predicted.classno = r->defaultclass;
 return predicted;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %r12
movq (%r12), %r12
testq %r12, %r12
je 0xac5d
movq 0x30(%r12), %rax
movq %rax, 0x30(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x71406
testl %eax, %eax
jne 0xac64
addq $0x30, %r12
jmp 0xac19
addq $0x14, %r14
movq %r14, %r12
movl (%r12), %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_c45rules
void* train_c45rules(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 10.11.2003 Rulecount, decisioncount and mdl added*/
 /*!Last Changed 03.11.2003*/
 Ruleset* r;
 C45_parameterptr p;
 Decisionnodeptr rootnode;
 r = safemalloc(sizeof(Ruleset), "train_c45rules", 3);
 p = safemalloc(sizeof(C45_parameter), "train_c45rules", 4);
 p->prunetype = PREPRUNING;
 p->pruningthreshold = 0.0;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 create_c45children(rootnode, p);
 safe_free(p);
 *trdata = NULL;
 accumulate_instances_tree(trdata, rootnode);
 *r = create_ruleset_from_decision_tree(rootnode);
 deallocate_tree(rootnode);
 safe_free(rootnode);
 r->possibleconditioncount = possible_condition_count(*trdata);
 generalize_c45rules(r, *trdata);
 sort_rules(r);
 find_class_rulesets(r, *trdata);
 if (r->rulecount > 0)
   rank_classes(r, *trdata);
 choose_default_class(r, *trdata);
 if (r->rulecount > 0)
   polish_ruleset(r, *trdata);
 update_counts_ruleset(*r, *trdata);
 return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
leaq 0x8b2c8(%rip), %r15     # 0x95f57
pushq $0x28
popq %rdi
pushq $0x3
popq %rdx
movq %r15, %rsi
callq 0x34f59
movq %rax, %rbx
pushq $0x10
popq %rdi
pushq $0x4
popq %rdx
movq %r15, %rsi
callq 0x34f59
movq %rax, %r12
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x1ac98
movq %rax, %r15
movq (%r14), %rax
movq %rax, 0x20(%r15)
movq %r15, %rdi
movq %r12, %rsi
callq 0x91b41
movq %r12, %rdi
callq 0x34ff7
andq $0x0, (%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1aad3
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x826d
movq 0x20(%r12), %rax
movq %rax, 0x20(%rbx)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %r15, %rdi
callq 0x1b2aa
movq %r15, %rdi
callq 0x34ff7
movq (%r14), %rdi
callq 0x8ef98
movl %eax, 0x20(%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x7d07
movq %rbx, %rdi
callq 0x6ffc
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x7a4c
cmpl $0x0, 0x10(%rbx)
jle 0xad64
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x7de0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x7d32
cmpl $0x0, 0x10(%rbx)
jle 0xad80
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x809b
movq (%r14), %rdi
movq 0x20(%rbx), %rax
movq %rax, 0x20(%rsp)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x72314
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: test_c45rules
Prediction test_c45rules(Instanceptr data, void* model, void* parameters, double* posterior)
{
 int covered = 0, bestclass;
 double besterror = 1.5, error; 
 Ruleset* r;
 Prediction predicted;
 Decisionruleptr tmp, bestrule = NULL;
 r = (Ruleset*) model;
 tmp = r->start;
 while (tmp)
  {
   if (rule_cover_instance(data, *tmp))
    {
     covered = 1;
     error = laplace_estimate_of_rule(*tmp);
     if (error < besterror)
      {
       bestrule = tmp;
       besterror = error;
       bestclass = tmp->classno;
      }
     tmp = get_next_class_rule(tmp);
     if (tmp)
       continue;
     else
       break;
    }
   tmp = tmp->next;
  }
 if (!covered)
  {
			if (get_parameter_o("laplaceestimate") == ON)
     normalize_array_laplace(r->counts, posterior, current_dataset->classno);
			else
     normalize_array(r->counts, posterior, current_dataset->classno);
   predicted.classno = r->defaultclass;
   return predicted;
  }
 else
  {
			if (get_parameter_o("laplaceestimate") == ON)
     normalize_array_laplace(bestrule->counts, posterior, current_dataset->classno);
			else
     normalize_array(bestrule->counts, posterior, current_dataset->classno);
   predicted.classno = bestclass;
   return predicted;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, 0x38(%rsp)
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, 0x40(%rsp)
xorl %ebx, %ebx
movsd 0x8b010(%rip), %xmm0    # 0x95de8
movsd %xmm0, 0x48(%rsp)
pushq $0x1
popq %r15
movq %rdx, 0x50(%rsp)
xorl %r14d, %r14d
movq (%r13), %r13
testq %r13, %r13
je 0xae95
movq 0x30(%r13), %rax
movq %rax, 0x30(%rsp)
movupd (%r13), %xmm0
movupd 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rsp)
movupd %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq %r12, %rdi
callq 0x71406
testl %eax, %eax
je 0xae8c
movq 0x30(%r13), %rax
movq %rax, 0x30(%rsp)
movupd (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
callq 0x724bd
movsd 0x48(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xae73
movl (%r13), %ebp
movsd %xmm0, 0x48(%rsp)
movq %r13, %r14
movq %r13, %rdi
callq 0x7250e
movq %rax, %r13
movl %r15d, %ebx
testq %rax, %rax
jne 0xadf7
jmp 0xae99
addq $0x30, %r13
jmp 0xadea
testl %ebx, %ebx
je 0xaee8
leaq 0x8b023(%rip), %rdi     # 0x95ec3
callq 0x4cff1
movq 0x10(%r14), %rdi
leaq 0xc29c0(%rip), %rcx     # 0xcd870
movq (%rcx), %rcx
movl 0x10(%rcx), %edx
cmpl $0x1, %eax
jne 0xaec7
movq 0x38(%rsp), %rsi
callq 0x33bf9
jmp 0xaed1
movq 0x38(%rsp), %rsi
callq 0x33b8f
movq 0x40(%rsp), %rax
movl %ebp, 0x8(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8afd4(%rip), %rdi     # 0x95ec3
callq 0x4cff1
movq 0x50(%rsp), %rbx
movq 0x18(%rbx), %rdi
leaq 0xc296c(%rip), %rcx     # 0xcd870
movq (%rcx), %rcx
movl 0x10(%rcx), %edx
cmpl $0x1, %eax
jne 0xaf1b
movq 0x38(%rsp), %rsi
callq 0x33bf9
jmp 0xaf25
movq 0x38(%rsp), %rsi
callq 0x33b8f
movq 0x40(%rsp), %rax
movl 0x14(%rbx), %ebp
jmp 0xaed6
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_multiripper
void* train_multiripper(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 07.01.2004*/
 Ruleset* r;
 Ripper_parameterptr p;
 p = (Ripper_parameterptr) parameters;
 r = safemalloc(sizeof(Ruleset), "train_multiripper", 4);
 *r = multivariate_rule_learner(trdata, *cvdata, p);
 update_counts_ruleset(*r, *trdata);
 return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8b01c(%rip), %rsi     # 0x95f66
pushq $0x28
popq %rdi
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r12
movq (%r14), %rdx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x45c82
movq 0x20(%r14), %rax
movq %rax, 0x20(%r12)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
movq (%r15), %rdi
movq 0x20(%r12), %rax
movq %rax, 0x20(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x72314
movq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_hybridripper
void* train_hybridripper(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 24.01.2004*/
 Ruleset* r;
 Ripper_parameterptr p;
 p = (Ripper_parameterptr) parameters;
 r = safemalloc(sizeof(Ruleset), "train_hybridripper", 4);
 *r = hybrid_rule_learner(trdata, *cvdata, p);
 update_counts_ruleset(*r, *trdata);
 return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8af8f(%rip), %rsi     # 0x95f78
pushq $0x28
popq %rdi
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r12
movq (%r14), %rdx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x4ad7b
movq 0x20(%r14), %rax
movq %rax, 0x20(%r12)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
movq (%r15), %rdi
movq 0x20(%r12), %rax
movq %rax, 0x20(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x72314
movq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: test_rbf
Prediction test_rbf(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 19.08.2007*/
 Rbfnetworkptr network;
 double* p;
 Prediction predicted;
 network = (Rbfnetworkptr) model;
 p = safemalloc((network->hidden + 1) * sizeof(double), "test_rbf", 4);
 rbf_forward_propagation(network, data, p, posterior);
 safe_free(p);
 predicted.classno = findMaxOutput(posterior, current_dataset->classno);
 return predicted;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movslq (%rdx), %rax
leaq 0x8(,%rax,8), %rdi
leaq 0x8aed7(%rip), %rsi     # 0x95f8b
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x668fe
movq %r13, %rdi
callq 0x34ff7
leaq 0xc2791(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x10(%rax), %esi
movq %r14, %rdi
callq 0x339b7
movl %eax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_mlpgeneric
void* train_mlpgeneric(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 23.06.2005 added cv*/
 Mlpparameters mlpparams;
 Mlpnetworkptr neuralnetwork;
 matrix train, cv;
 neuralnetwork = safemalloc(sizeof(Mlpnetwork), "train_mlpgeneric", 4);
 mlpparams = *((Mlpparametersptr) parameters);
 mlpparams.inputnum = data_size(*trdata);
 mlpparams.trnum = mlpparams.inputnum;
 mlpparams.cvnum = data_size(*cvdata);
 train = instancelist_to_matrix(*trdata, CLASSIFICATION, -1, MULTIVARIATE_LINEAR);
 cv = instancelist_to_matrix(*cvdata, CLASSIFICATION, -1, MULTIVARIATE_LINEAR);
 *neuralnetwork = mlpn_general(train, cv, &mlpparams, CLASSIFICATION);
 matrix_free(train);
 matrix_free(cv);
 return neuralnetwork;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8ae76(%rip), %rsi     # 0x95f94
pushq $0x4
popq %rdx
movl $0x98, %edi
callq 0x34f59
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x4310
movq (%r12), %rdi
callq 0x2c3cc
movl %eax, 0x8(%r14)
movl %eax, 0x10(%r14)
movq (%r15), %rdi
callq 0x2c3cc
movl %eax, 0xc(%r14)
movq (%r12), %rdi
pushq $-0x1
popq %rbp
pushq $-0x2
popq %rbx
xorl %esi, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x2c130
movq %rax, %r12
movq %rdx, %r13
movq (%r15), %rdi
xorl %esi, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x2c130
movq %rax, %rbx
movq %rdx, %r15
andl $0x0, (%rsp)
leaq 0xa0(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x3d96a
movl $0x98, %edx
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x4310
movq %r12, %rdi
movq %r13, %rsi
callq 0x3929f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3929f
movq %r14, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: test_mlpgeneric
Prediction test_mlpgeneric(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 01.11.2005*/
 /*!Last Changed 23.06.2005 added cv*/
 Mlpnetwork neuralnetwork;
 matrix test, testY;
 int res, i;
 double prob;
 Prediction predicted;
 neuralnetwork = *((Mlpnetworkptr) model);
 test = instancelist_to_matrix(data, CLASSIFICATION, -1, MULTIVARIATE_LINEAR);
 testMlpnInput_cls(test.values[0], &testY, neuralnetwork, &res, &prob);
 for (i = 0; i < current_dataset->classno; i++)
   posterior[i] = testY.values[0][i];
 predicted.classno = findMaxOutput(testY.values[0], current_dataset->classno);
 matrix_free(testY);
 matrix_free(test);
 return predicted;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %r8, %r14
movq %rdx, %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc0(%rsp), %r13
movl $0x98, %edx
movq %r13, %rdi
movq %rax, %rsi
callq 0x4310
xorl %ebp, %ebp
pushq $-0x1
popq %rdx
pushq $-0x2
popq %rcx
movq %r15, %rdi
xorl %esi, %esi
callq 0x2c130
movq %rax, %r15
movq %rdx, %r12
movq (%rdx), %rax
pushq $0x13
popq %rcx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa8(%rsp), %r13
leaq 0xa4(%rsp), %rdx
leaq 0xb8(%rsp), %rcx
movq %rax, %rdi
movq %r13, %rsi
callq 0x3fa90
leaq 0xc25f6(%rip), %rax     # 0xcd870
movq (%rax), %rax
movl 0x10(%rax), %esi
movq 0x8(%r13), %rax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
cmpq %rbp, %rcx
je 0xb2a6
movq (%rax), %rdx
movsd (%rdx,%rbp,8), %xmm0
movsd %xmm0, (%r14,%rbp,8)
incq %rbp
jmp 0xb28e
movq (%rax), %rdi
callq 0x339b7
movl %eax, 0x8(%rbx)
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x3929f
movq %r15, %rdi
movq %r12, %rsi
callq 0x3929f
movq %rbx, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_dnc
void* train_dnc(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 16.04.2007*/
 Mlpparameters mlpparams;
 Mlpnetworkptr neuralnetwork;
 matrix train;
 neuralnetwork = safemalloc(sizeof(Mlpnetwork), "train_dnc", 4);
 mlpparams = *((Mlpparametersptr) parameters);
 mlpparams.inputnum = data_size(*trdata);
 mlpparams.trnum = mlpparams.inputnum;
 train = instancelist_to_matrix(*trdata, CLASSIFICATION, -1, MULTIVARIATE_LINEAR);
 *neuralnetwork = dnc_cls(train, &mlpparams);
 matrix_free(train);
 return neuralnetwork;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdx, %r15
movq %rdi, %r12
leaq 0x8aca2(%rip), %rsi     # 0x95fa5
pushq $0x4
popq %rdx
movl $0x98, %edi
callq 0x34f59
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4310
movq (%r12), %rdi
callq 0x2c3cc
movl %eax, 0x8(%r14)
movl %eax, 0x10(%r14)
movq (%r12), %rdi
pushq $-0x1
popq %rdx
pushq $-0x2
popq %rcx
xorl %esi, %esi
callq 0x2c130
movq %rax, %r15
movq %rdx, %r12
leaq 0x98(%rsp), %r13
movq %r13, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0x400a0
movl $0x98, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4310
movq %r15, %rdi
movq %r12, %rsi
callq 0x3929f
movq %rbx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_rexripper
void* train_rexripper(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 03.12.2004 added deallocate(exceptiondata)*/
 /*!Last Changed 08.05.2004*/
 Model_rexripperptr m;
 Ripper_parameterptr p;
 m = safemalloc(sizeof(Model_rexripper), "train_rexripper", 3);
 p = (Ripper_parameterptr) parameters;
 m->r = learn_ruleset_ripper(trdata, 2, p);
 update_counts_ruleset(m->r, *trdata);
 m->exceptiondata = NULL;
 create_list_from_exceptions(&(m->exceptiondata), trdata);
 return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x8abf4(%rip), %rsi     # 0x95faf
pushq $0x30
popq %rdi
pushq $0x3
popq %rdx
callq 0x34f59
movq %rax, %r14
leaq 0x30(%rsp), %r12
pushq $0x2
popq %rdx
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x6f24f
movq 0x20(%r12), %rax
movq %rax, 0x20(%r14)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
movq (%rbx), %rdi
movq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x72314
leaq 0x28(%r14), %rdi
andq $0x0, 0x28(%r14)
movq %rbx, %rsi
callq 0x2c668
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_multildt
void* train_multildt(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 04.10.2004 added writerules*/
 /*!Last Changed 21.09.2004*/
 Decisionnodeptr rootnode;
 Multildt_parameterptr p;
 p = (Multildt_parameterptr) parameters;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 create_multildtchildren(rootnode, p);
 prune_tree(rootnode, rootnode, *cvdata);
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x1ac98
movq %rax, %r12
movq (%r15), %rax
movq %rax, 0x20(%r12)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4719a
movq (%r14), %rdx
movq %r12, %rdi
movq %r12, %rsi
callq 0x1b4d4
andq $0x0, (%r15)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq