LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %rsi, %r12
movq %rdi, %rbx
leaq 0xcbe2c(%rip), %rbp     # 0xd5870
movq (%rbp), %rax
movl 0x10(%rax), %esi
testl %esi, %esi
jle 0x9afb
movq %rdx, %r15
movq %rbx, (%rsp)
xorl %ebx, %ebx
xorpd %xmm1, %xmm1
movq %rdx, %r13
movsd %xmm1, 0x10(%rsp)
movq (%r13), %r13
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movsd (%rcx,%rbx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rax,%rbx,8), %xmm0
ucomisd 0x9c27b(%rip), %xmm0    # 0xa5d08
jb 0x9a95
sqrtsd %xmm0, %xmm0
jmp 0x9a9a
callq 0x4300
movq %r12, %rdi
movq %r13, %rsi
callq 0x8db6c
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, (%r14,%rbx,8)
movsd 0x10(%rsp), %xmm1
addsd %xmm2, %xmm1
addq $0x10, %r13
incq %rbx
movq (%rbp), %rax
movslq 0x10(%rax), %rsi
cmpq %rsi, %rbx
jl 0x9a63
testl %esi, %esi
jle 0x9af7
xorl %eax, %eax
movq (%rsp), %rbx
movsd (%r14,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
cmpq %rax, %rsi
jne 0x9add
jmp 0x9afb
movq (%rsp), %rbx
movq %r14, %rdi
callq 0x38362
movl %eax, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %edi, %edi
movl $0x1, %esi
callq 0x1d107
movq %rax, %r14
movq (%rbx), %rax
movq %rax, 0x20(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa2a76
movl (%r15), %edi
movl $0x2, %esi
movl $0x2, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
je 0xab20
movq (%r12), %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x1d99b
jmp 0xab46
cmpl $0x0, 0x4(%r15)
je 0xab39
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x52bc5
jmp 0xab46
movq %r14, %rdi
movl $0x3, %esi
callq 0x52dec
movq $0x0, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9b387(%rip), %rsi     # 0xa5f09
movl $0x28, %edi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x7969f
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 0x7ca47
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9b097(%rip), %rsi     # 0xa5f14
movl $0x28, %edi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x7969f
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 0x7ca47
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9b004(%rip), %rsi     # 0xa5f20
movl $0x28, %edi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x7969f
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 0x7ca47
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9aef3(%rip), %rsi     # 0xa5f2d
movl $0x28, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xdc38
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 0x7ca47
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rdi, %rbx
movq (%rdx), %r12
testq %r12, %r12
je 0xb1f3
movq %rsi, %r15
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 0x7b9ee
testl %eax, %eax
jne 0xb1fa
movq 0x30(%r12), %r12
testq %r12, %r12
jne 0xb1b4
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_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
leaq 0x9ad28(%rip), %r15     # 0xa5f4f
movl $0x28, %edi
movq %r15, %rsi
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %rbx
movl $0x10, %edi
movq %r15, %rsi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r12
movl $0x0, (%rax)
xorl %r13d, %r13d
movq %r13, 0x8(%rax)
xorl %edi, %edi
movl $0x1, %esi
callq 0x1d107
movq %rax, %r15
movq (%r14), %rax
movq %rax, 0x20(%r15)
movq %r15, %rdi
movq %r12, %rsi
callq 0xa10e8
movq %r12, %rdi
callq 0x3a180
movq %r13, (%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1cef5
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8595
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 0x1d74c
movq %r15, %rdi
callq 0x3a180
movq (%r14), %rdi
callq 0x9e1c4
movl %eax, 0x20(%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x7f96
movq %rbx, %rdi
callq 0x71f0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x7c8b
cmpl $0x0, 0x10(%rbx)
jle 0xb30a
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x8074
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x7fc1
cmpl $0x0, 0x10(%rbx)
jle 0xb326
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x8387
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 0x7ca47
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9aa3a(%rip), %rsi     # 0xa5f5e
movl $0x28, %edi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r12
movq (%r14), %rdx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x4ce75
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 0x7ca47
movq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9a9a9(%rip), %rsi     # 0xa5f70
movl $0x28, %edi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r12
movq (%r14), %rdx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x526fa
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 0x7ca47
movq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9a8ed(%rip), %rsi     # 0xa5f83
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x6fe88
movq %r13, %rdi
callq 0x3a180
leaq 0xca1ad(%rip), %rax     # 0xd5870
movq (%rax), %rax
movl 0x10(%rax), %esi
movq %r14, %rdi
callq 0x38362
movl %eax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9a88a(%rip), %rsi     # 0xa5f8c
movl $0x98, %edi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x4310
movq (%r12), %rdi
callq 0x30309
movl %eax, 0x8(%r14)
movl %eax, 0x10(%r14)
movq (%r15), %rdi
callq 0x30309
movl %eax, 0xc(%r14)
movq (%r12), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x3008b
movq %rax, %r12
movq %rdx, %r13
movq (%r15), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x3008b
movq %rax, %r15
movq %rdx, %rbp
movl $0x0, (%rsp)
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
movq %rbp, %r8
movq %r14, %r9
callq 0x43e30
movl $0x98, %edx
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4310
movq %r12, %rdi
movq %r13, %rsi
callq 0x3ed51
movq %r15, %rdi
movq %rbp, %rsi
callq 0x3ed51
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_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %r8, %r14
movq %rdx, %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xb8(%rsp), %r13
movl $0x98, %edx
movq %r13, %rdi
movq %rax, %rsi
callq 0x4310
movq %r15, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x3008b
movq %rax, %r15
movq %rdx, %r12
movq (%rdx), %rax
movl $0x13, %ecx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa0(%rsp), %r13
leaq 0x9c(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
movq %rax, %rdi
movq %r13, %rsi
callq 0x463c2
leaq 0xca004(%rip), %rax     # 0xd5870
movq (%rax), %rax
movslq 0x10(%rax), %rsi
movq 0x8(%r13), %rax
movq (%rax), %rdi
testq %rsi, %rsi
jle 0xb894
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
cmpq %rax, %rsi
jne 0xb881
callq 0x38362
movl %eax, 0x8(%rbx)
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x3ed51
movq %r15, %rdi
movq %r12, %rsi
callq 0x3ed51
movq %rbx, %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9a6b0(%rip), %rsi     # 0xa5f9d
movl $0x98, %edi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4310
movq (%r12), %rdi
callq 0x30309
movl %eax, 0x8(%r14)
movl %eax, 0x10(%r14)
movq (%r12), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x3008b
movq %rax, %r15
movq %rdx, %r12
leaq 0x98(%rsp), %r13
movq %r13, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0x46b44
movl $0x98, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4310
movq %r15, %rdi
movq %r12, %rsi
callq 0x3ed51
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_O3/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 0x9a5fc(%rip), %rsi     # 0xa5fa7
movl $0x30, %edi
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %r14
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl $0x2, %edx
movq %r15, %rcx
callq 0x7969f
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 0x7ca47
leaq 0x28(%r14), %rdi
movq $0x0, 0x28(%r14)
movq %rbx, %rsi
callq 0x305b9
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorl %edi, %edi
movl $0x1, %esi
callq 0x1d107
movq %rax, %r12
movq (%r15), %rax
movq %rax, 0x20(%r12)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4e3cb
movq (%r14), %rdx
movq %r12, %rdi
movq %r12, %rsi
callq 0x1d99b
movq $0x0, (%r15)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/classification.c
// Function: train_omnildt
void* train_omnildt(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 24.11.2004 added univariate and multivariate condition counts*/
 /*!Last Changed 22.11.2004 added possible conditioncount*/
 /*!Last Changed 04.10.2004 added writerules*/
 /*!Last Changed 23.09.2004*/
 Decisionnodeptr rootnode;
 Multildt_parameterptr p;
 p = (Multildt_parameterptr) parameters;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 rootnode->possibleconditioncount = possible_condition_count(*trdata);
 create_omnildtchildren(rootnode, p);
 if (in_list(p->c45param.prunetype, 2, MODELSELECTIONPRUNING, VALIDATIONPRUNING))
  {
   if (p->c45param.prunetype == VALIDATIONPRUNING || (p->c45param.prunetype == MODELSELECTIONPRUNING && p->modelselectionmethod == MODEL_SELECTION_CV))
     prune_tree(rootnode, rootnode, *cvdata);
   else
     prune_tree_according_to_model_selection_method(rootnode, p->modelselectionmethod);
  }
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
xorl %edi, %edi
movl $0x1, %esi
callq 0x1d107
movq %rax, %r14
movq (%rbx), %rdi
movq %rdi, 0x20(%rax)
callq 0x9e1c4
movl %eax, 0x8c(%r14)
movq %r14, %rdi
movq %r12, %rsi
callq 0x5419d
movl (%r12), %edi
movl $0x2, %esi
movl $0x2, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
je 0xbda0
movl (%r12), %eax
cmpl $0x1, %eax
je 0xbd83
cmpl $0x2, %eax
jne 0xbd93
movl 0x18(%r12), %esi
testl %esi, %esi
jne 0xbd98
movq (%r15), %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x1d99b
jmp 0xbda0
movl 0x18(%r12), %esi
movq %r14, %rdi
callq 0x52dec
movq $0x0, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/classification.c
// Function: train_softtree
void* train_softtree(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;
 if (current_dataset->classno == 2)
  {
   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);
   create_softtree(treenode, treenode, *cvdata, p);
  }
 else
  {
   treenode->leaftype = CONSTANTLEAF;
   treenode->w0s = random_array_double(current_dataset->classno, -0.01, +0.01);
   treenode->outputs = safemalloc(current_dataset->classno * sizeof(double), "train_softtree", 14);
   create_softtree_K_class(treenode, treenode, *cvdata, p);
  }
	*trdata = NULL;
	return treenode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorl %edi, %edi
movl $0x1, %esi
callq 0x1d107
movq %rax, %r15
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%r15)
movq (%rbx), %rax
movq %rax, 0x20(%r15)
leaq 0xc981f(%rip), %r13     # 0xd5870
movq (%r13), %rax
movl 0x10(%rax), %edi
cmpl $0x2, %edi
jne 0xc096
movl (%r14), %ecx
movl %ecx, 0x60(%r15)
testl %ecx, %ecx
je 0xc0ec
movl 0x1c0(%rax), %edi
movsd 0x99d3e(%rip), %xmm0    # 0xa5db8
movsd 0x99d3e(%rip), %xmm1    # 0xa5dc0
movl $0x1, %esi
callq 0x3ef18
movq %rax, 0x38(%r15)
movq %rdx, 0x40(%r15)
jmp 0xc107
movl $0x0, 0x60(%r15)
movsd 0x99d12(%rip), %xmm0    # 0xa5db8
movsd 0x99d12(%rip), %xmm1    # 0xa5dc0
callq 0x3b110
movq %rax, 0x50(%r15)
movq (%r13), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x99efc(%rip), %rsi     # 0xa5fc6
movl $0xe, %edx
callq 0x3a0e1
movq %rax, 0x70(%r15)
movq (%r12), %rdx
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x8c778
jmp 0xc119
movsd 0x99cc4(%rip), %xmm0    # 0xa5db8
movsd 0x99cc4(%rip), %xmm1    # 0xa5dc0
callq 0x3af6a
movsd %xmm0, 0x48(%r15)
movq (%r12), %rdx
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x8c7d6
movq $0x0, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/classification.c
// Function: test_softtree
Prediction test_softtree(Instanceptr data, void* model, void* parameters, double* posterior)
{
 int i;
	Decisionnodeptr treenode;
 Prediction predicted;
 double* output;
	treenode = (Decisionnodeptr) model;
 if (current_dataset->classno == 2)
  {
   posterior[1] = sigmoid(soft_tree_output(treenode, data));
   posterior[0] = 1 - posterior[1];
   if (posterior[0] > posterior[1])
     predicted.classno = 0;
   else
     predicted.classno = 1;
  }
 else
  {
   output = soft_tree_output_K_class(treenode, data);
   softmax(output, current_dataset->classno);
   for (i = 0; i < current_dataset->classno; i++)
     posterior[i] = output[i];
   predicted.classno = find_max_in_list_double(posterior, current_dataset->classno);
  }
 return predicted;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rdi, %rbx
leaq 0xc972e(%rip), %r12     # 0xd5870
movq (%r12), %rax
cmpl $0x2, 0x10(%rax)
jne 0xc17f
movq %rdx, %rdi
callq 0x8b4e2
callq 0x55a80
movsd %xmm0, 0x8(%r14)
movsd 0x993b9(%rip), %xmm1    # 0xa5520
subsd %xmm0, %xmm1
movsd %xmm1, (%r14)
ucomisd %xmm0, %xmm1
jbe 0xc1c9
movl $0x0, 0x8(%rbx)
jmp 0xc1d0
movq %rdx, %rdi
callq 0x8b410
movq %rax, %r15
movq (%r12), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x55aa4
movq (%r12), %rax
movslq 0x10(%rax), %rsi
testq %rsi, %rsi
jle 0xc1bc
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
cmpq %rax, %rsi
jne 0xc1a8
movq %r14, %rdi
callq 0x38031
movl %eax, 0x8(%rbx)
jmp 0xc1d0
movl $0x1, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/classification.c
// Function: test_logistic
Prediction test_logistic(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 17.04.2005*/
 double** w, *y;
 int i, j;
 Prediction predicted;
 w = (double**) model;
 y = safemalloc(current_dataset->classno * sizeof(double), "logistic", 6);
 for (i = 0; i < current_dataset->classno; i++)
  {
   y[i] = w[i][0];
   for (j = 0; j < current_dataset->multifeaturecount - 1; j++)
     y[i] += w[i][j + 1] * real_feature(data, j);
  }
 predicted.classno = findMaxOutput(y, current_dataset->classno);
 softmax(y, current_dataset->classno);
 for (i = 0; i < current_dataset->classno; i++)
   posterior[i] = y[i]; 
 safe_free(y);
 return predicted;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xc9370(%rip), %rbp     # 0xd5870
movq (%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x99ac2(%rip), %rsi     # 0xa5fd5
movl $0x6, %edx
callq 0x3a0e1
movq %rax, %r15
movq (%rbp), %rax
movl 0x10(%rax), %esi
testl %esi, %esi
jle 0xc5a8
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
xorl %ebx, %ebx
movq (%r12,%rbx,8), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%r15,%rbx,8)
cmpl $0x2, 0x1c0(%rax)
jl 0xc593
xorl %esi, %esi
movq (%r12,%rbx,8), %rax
leaq 0x1(%rsi), %r14
movsd 0x8(%rax,%rsi,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r13, %rdi
callq 0x2ed6a
mulsd 0x10(%rsp), %xmm0
addsd (%r15,%rbx,8), %xmm0
movsd %xmm0, (%r15,%rbx,8)
movq (%rbp), %rax
movslq 0x1c0(%rax), %rcx
decq %rcx
movq %r14, %rsi
cmpq %rcx, %r14
jl 0xc54f
incq %rbx
movslq 0x10(%rax), %rsi
cmpq %rsi, %rbx
jl 0xc536
movq 0x8(%rsp), %rbx
movq (%rsp), %r14
movq %r15, %rdi
callq 0x38362
movl %eax, 0x8(%rbx)
movq (%rbp), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x55aa4
movq (%rbp), %rax
movslq 0x10(%rax), %rax
testq %rax, %rax
jle 0xc5e5
xorl %ecx, %ecx
movsd (%r15,%rcx,8), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xc5d1
movq %r15, %rdi
callq 0x3a180
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/classification.c
// Function: train_svm
void* train_svm(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 03.05.2005*/
 Partition dummyp;
 Svm_modelptr model;
 Svm_problem prob;
 Svm_parameterptr param;
 dummyp = get_two_class_partition();
 prepare_svm_problem(&prob, C_SVC, *trdata, dummyp);
 free_partition(dummyp);
 param = (Svm_parameter*) parameters;
 model = svm_train(prob, *param, 1);
 return model;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x78(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x55888
movq (%r14), %rdx
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x90(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x93fdc
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x55a69
leaq 0x20(%rsp), %rdi
movl $0xb, %ecx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x1, %edi
callq 0x91556
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/classification.c
// Function: test_svm
Prediction test_svm(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 03.05.2005*/
 Prediction predicted;
 double* dec_values;
 int classno, y;
 Svm_nodeptr node;
 Svm_modelptr m;
 m = (Svm_modelptr) model;
 node = instance_to_svmnode(data);
 svm_predict_probability(m, node, posterior);
 if (m->nr_class == 2)
  {
   dec_values = safemalloc(sizeof(double), "test_svm", 7);
   svm_predict_values(m, node, dec_values);
   classno = give_classno(data);
   y = 1 - 2 * classno;
   predicted.hingeloss = hinge_loss(y, dec_values[0]);
   safe_free(dec_values);
  }
 predicted.classno = (int) svm_predict(m, node);
 safe_free(node);
 return predicted;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2ec9f
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x931b1
cmpl $0x2, 0x58(%r15)
jne 0xc71e
leaq 0x9990d(%rip), %rsi     # 0xa5fde
movl $0x8, %edi
movl $0x7, %edx
callq 0x3a0e1
movq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x925b3
movq %r12, %rdi
callq 0x2f33a
addl %eax, %eax
movl $0x1, %ecx
subl %eax, %ecx
cvtsi2sd %ecx, %xmm0
movsd (%r13), %xmm1
callq 0x473e0
movsd %xmm0, 0x10(%rbx)
movq %r13, %rdi
callq 0x3a180
movq %r15, %rdi
movq %r14, %rsi
callq 0x93373
cvttsd2si %xmm0, %eax
movl %eax, 0x8(%rbx)
movq %r14, %rdi
callq 0x3a180
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/classification.c
// Function: train_simplexsvm
void* train_simplexsvm(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 03.05.2005*/
 Svm_simplex_parameterptr param;
 param = (Svm_simplex_parameterptr) parameters;
 if (current_dataset->classno == 2)
   return solve_binary_svm(*trdata, param, 0);
 else
   if (param->problem_type == ONE_VS_ONE)
     return solve_one_vs_one_svm(trdata, param);
   else
     return solve_one_vs_rest_svm(*trdata, param);
}

// Assembly:
leaq 0xc9124(%rip), %rax     # 0xd5870
movq (%rax), %rax
cmpl $0x2, 0x10(%rax)
jne 0xc762
movq (%rdi), %rdi
movq %rdx, %rsi
xorl %edx, %edx
jmp 0x95729
cmpl $0x0, 0x18(%rdx)
je 0xc773
movq (%rdi), %rdi
movq %rdx, %rsi
jmp 0x95dc3
movq %rdx, %rsi
jmp 0x95bd9
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/classification.c
// Function: test_simplexsvm
Prediction test_simplexsvm(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 03.05.2005*/
 Svm_simplex_parameterptr param;
 Prediction predicted;
 param = (Svm_simplex_parameterptr) parameters;
 if (current_dataset->classno == 2)
  {
   if (test_binary_svm((Svm_binary_modelptr) model, param, data) < 0)
     predicted.classno = 0;
   else
     predicted.classno = 1;
  }
 else
   if (param->problem_type == ONE_VS_ONE)
     predicted.classno = test_one_vs_one_svm((Svm_simplex_modelptr) model, param, data);
  else
     predicted.classno = test_one_vs_rest_svm((Svm_simplex_modelptr) model, param, data);
  return predicted;
}

// Assembly:
pushq %rbx
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0xc90e4(%rip), %rsi     # 0xd5870
movq (%rsi), %rsi
cmpl $0x2, 0x10(%rsi)
jne 0xc7b3
movq %rax, %rdi
movq %rcx, %rsi
callq 0x95ace
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0xc7c6
movl $0x0, 0x8(%rbx)
jmp 0xc7dd
cmpl $0x0, 0x18(%rcx)
je 0xc7cf
movq %rax, %rdi
movq %rcx, %rsi
callq 0x95e94
jmp 0xc7da
movl $0x1, 0x8(%rbx)
jmp 0xc7dd
movq %rax, %rdi
movq %rcx, %rsi
callq 0x95ce6
movl %eax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/clustering.c
// Function: find_nearest_mean
Instanceptr find_nearest_mean(Instanceptr means, Instanceptr data, int* index)
{
	/*!Last Changed 22.03.2005*/
	double mindist, dist;
	Instanceptr temp, minindex = NULL;
	int i;
 mindist = +INT_MAX;
 i = 0;
 temp = means;
 while (temp)
  {
   dist = distance_between_instances(temp, data);
   if (dist < mindist)
    {
     mindist = dist;
     *index = i;
					minindex = temp;
    }
   temp = temp->next;
   i++;
  }
	return minindex;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %r13d, %r13d
testq %rdi, %rdi
je 0xccc4
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd 0x9888e(%rip), %xmm0    # 0xa5518
movsd %xmm0, 0x8(%rsp)
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x2fe29
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xccb6
movl %r13d, (%rbx)
movsd %xmm0, 0x8(%rsp)
movq %r15, %r12
movq 0x10(%r15), %r15
incl %r13d
testq %r15, %r15
jne 0xcc93
jmp 0xccc7
xorl %r12d, %r12d
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/clustering.c
// Function: cluster_spreads
double* cluster_spreads(Instanceptr data, Instanceptr means, int k)
{
	/*!Last Changed 20.08.2007*/
	int i, minindex;
	double* result, dist;
	Instanceptr tmp;
	result = safecalloc(k, sizeof(double), "cluster_spreads", 3);
	tmp = data;
	while (tmp)
	 {
		 find_nearest_mean(means, tmp, &minindex);
			dist = distance_between_instances(tmp, data_x(means, minindex));
			if (dist > result[minindex])
				 result[minindex] = dist;
		 tmp = tmp->next;
	 }
	for (i = 0; i < k; i++)
   if (result[i] == 0)
     result[i] = 1.0;
   else
		   result[i] = sqrt(result[i]) / 2;
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl %edx, 0xc(%rsp)
movslq %edx, %rdi
leaq 0x99308(%rip), %rdx     # 0xa6002
movl $0x8, %esi
movl $0x3, %ecx
callq 0x3a1fc
movq %rax, %rbx
testq %r15, %r15
je 0xcd7f
testq %r14, %r14
je 0xcd51
xorl %ebp, %ebp
movq %r14, %r13
movsd 0x987f5(%rip), %xmm0    # 0xa5518
movsd %xmm0, 0x10(%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x2fe29
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
cmoval %ebp, %r12d
minsd %xmm1, %xmm0
movq 0x10(%r13), %r13
incl %ebp
testq %r13, %r13
jne 0xcd23
movq %r14, %rdi
movl %r12d, %esi
callq 0x31851
movq %r15, %rdi
movq %rax, %rsi
callq 0x2fe29
movslq %r12d, %rax
ucomisd (%rbx,%rax,8), %xmm0
jbe 0xcd76
movsd %xmm0, (%rbx,%rax,8)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0xcd11
movl 0xc(%rsp), %eax
testl %eax, %eax
jle 0xcded
movl %eax, %r14d
xorl %r15d, %r15d
movsd 0x9878b(%rip), %xmm2    # 0xa5520
xorpd %xmm3, %xmm3
movsd 0x98f77(%rip), %xmm4    # 0xa5d18
movsd (%rbx,%r15,8), %xmm1
ucomisd %xmm3, %xmm1
movapd %xmm2, %xmm0
jne 0xcdb3
jnp 0xcddf
jb 0xcdbe
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0xcddb
movapd %xmm1, %xmm0
callq 0x4300
movsd 0x98f49(%rip), %xmm4    # 0xa5d18
xorpd %xmm3, %xmm3
movsd 0x98745(%rip), %xmm2    # 0xa5520
mulsd %xmm4, %xmm0
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0xcda1
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/clustering.c
// Function: calculate_mean_of_nearest_distance
double calculate_mean_of_nearest_distance(Instanceptr data)
{
 Instanceptr temp, mininst;
 double S = 0.0;
 int N;
 int index;
 temp = data;
 N = data_size(data);
 while (temp)
  {
  	mininst = find_nearest_mean(data, temp, &index);
	  S = S + sqrt(distance_between_instances(mininst, temp));
 	 temp = temp->next;
  }
 S = S / N;
 return S;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
callq 0x30309
movl %eax, %ebx
testq %r14, %r14
je 0xd19f
movq %r14, %r15
xorpd %xmm1, %xmm1
movsd %xmm1, (%rsp)
xorl %r12d, %r12d
movq %r14, %r13
movsd 0x983d9(%rip), %xmm0    # 0xa5518
movsd %xmm0, 0x8(%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x2fe29
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
cmovaq %r13, %r12
minsd %xmm1, %xmm0
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0xd13f
movq %r12, %rdi
movq %r15, %rsi
callq 0x2fe29
ucomisd 0x98b8a(%rip), %xmm0    # 0xa5d08
jb 0xd186
sqrtsd %xmm0, %xmm0
jmp 0xd18b
callq 0x4300
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0xd12c
jmp 0xd1a3
xorpd %xmm1, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/cn2.c
// Function: generate_candidate_for_newstar
Decisionruleptr generate_candidate_for_newstar(Decisionruleptr current, int fno, char comparison, double split, int falsepositives, int covered)
{
 Decisionruleptr result;
 Decisionconditionptr newcondition;
 result = create_copy_of_rule(current);
 newcondition = empty_condition();
 newcondition->conditiontype = UNIVARIATE_CONDITION;
 newcondition->freeparam = 1;
 newcondition->featureindex = fno;
 newcondition->comparison = comparison;
 newcondition->value = split;
 result->falsepositives = falsepositives;
 result->covered = covered;
 add_condition(result, newcondition);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movsd %xmm0, 0x8(%rsp)
movl %edx, %r14d
movl %esi, %r15d
callq 0x7be1e
movq %rax, %r12
xorl %eax, %eax
callq 0x7c366
movq $0x1, 0x3c(%rax)
movl %r15d, (%rax)
movb %r14b, 0x4(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movl %ebp, 0x8(%r12)
movl %ebx, 0x4(%r12)
movq %r12, %rdi
movq %rax, %rsi
callq 0x7c040
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/cn2.c
// Function: add_candidate_to_newstar
void add_candidate_to_newstar(Decisionruleptr candidate, Ruleset* newstar, int maxstar)
{
 Decisionruleptr tmp, tmpbefore = NULL, deleted;
 tmp = newstar->start;
 while (tmp)
  {
   if (laplace_estimate_of_rule(*tmp) > laplace_estimate_of_rule(*candidate))
     break;
   tmpbefore = tmp;
   tmp = tmp->next;
  }
 add_rule_after(newstar, tmpbefore, candidate);
 if (newstar->rulecount > maxstar)
  {
   deleted = newstar->end;
   remove_rule(newstar, newstar->end);
   free_rule(*deleted);
   safe_free(deleted);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r12
testq %r12, %r12
je 0xd30a
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)
callq 0x7cc0e
movsd %xmm0, 0x38(%rsp)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rsp)
movupd (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
callq 0x7cc0e
movsd 0x38(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xd371
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x7c86e
cmpl %ebp, 0x10(%rbx)
jle 0xd3ef
movq 0x8(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c981
movq 0x30(%r14), %rax
movq %rax, 0x30(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x7c251
movq %r14, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
movq %r12, %r15
movq 0x30(%r12), %r12
testq %r12, %r12
je 0xd30d
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)
callq 0x7cc0e
movsd %xmm0, 0x38(%rsp)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rsp)
movupd (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
callq 0x7cc0e
movsd 0x38(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xd371
jmp 0xd30d
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/cn2.c
// Function: rule_significantly_better
int rule_significantly_better(Decisionruleptr current, double positive_ratio)
{
 double pvalue, sum = 0.0;
 double falsepositives, covered;
 if (current->covered == 0 || error_rate_of_rule(*current) > 0.5)
   return NO;
 covered = positive_ratio * (current->covered + current->falsepositives);
 falsepositives = (1 - positive_ratio) * (current->covered + current->falsepositives);
 if (current->covered != 0 && covered != 0.0)
   sum += current->covered * log(current->covered / covered);
 if (current->falsepositives != 0 && falsepositives != 0.0)
   sum += current->falsepositives * log(current->falsepositives / falsepositives);
 sum *= 2;
 pvalue = chi_square(1, sum);
 if (pvalue > get_parameter_f("confidencelevel"))
   return NO;
 return YES;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x58, %rsp
xorl %ebp, %ebp
cmpl $0x0, 0x4(%rdi)
je 0xda2f
movq %rdi, %rbx
movsd %xmm0, 0x40(%rsp)
movq 0x30(%rdi), %rax
movq %rax, 0x30(%rsp)
movupd (%rdi), %xmm0
movupd 0x10(%rdi), %xmm1
movupd 0x20(%rdi), %xmm2
movupd %xmm2, 0x20(%rsp)
movupd %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
callq 0x7cbcf
ucomisd 0x983e3(%rip), %xmm0    # 0xa5d18
ja 0xda2f
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %eax
leal (%rax,%rcx), %edx
cvtsi2sd %edx, %xmm3
xorpd %xmm2, %xmm2
testl %ecx, %ecx
je 0xd9a9
movapd %xmm3, %xmm1
movsd 0x40(%rsp), %xmm0
mulsd %xmm0, %xmm1
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm1
jne 0xd96a
jnp 0xd9af
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x50(%rsp)
divsd %xmm1, %xmm0
movsd %xmm3, 0x48(%rsp)
callq 0x4160
movsd 0x48(%rsp), %xmm3
movapd %xmm0, %xmm2
movsd 0x40(%rsp), %xmm0
mulsd 0x50(%rsp), %xmm2
addsd 0x98364(%rip), %xmm2    # 0xa5d08
movl 0x8(%rbx), %eax
jmp 0xd9af
movsd 0x40(%rsp), %xmm0
testl %eax, %eax
je 0xd9fb
movsd 0x97b65(%rip), %xmm1    # 0xa5520
subsd %xmm0, %xmm1
mulsd %xmm3, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0xd9cf
jnp 0xd9fb
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x48(%rsp)
divsd %xmm1, %xmm0
movsd %xmm2, 0x40(%rsp)
callq 0x4160
movsd 0x40(%rsp), %xmm2
mulsd 0x48(%rsp), %xmm0
addsd %xmm0, %xmm2
addsd %xmm2, %xmm2
movl $0x1, %edi
movapd %xmm2, %xmm0
callq 0x1fc11
movsd %xmm0, 0x40(%rsp)
leaq 0x97f0e(%rip), %rdi     # 0xa5928
callq 0x549ba
xorl %ebp, %ebp
movsd 0x40(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setbe %bpl
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/combine.c
// Function: mean_combine
int mean_combine(int* predicted, matrix posteriors)
{
 int i,j;
 int numclass = posteriors.col;
 int numlearner = posteriors.row;
 int res = -1;
 double *classtotal;
 classtotal = (double *) safecalloc(numclass, sizeof(double), "mean_combine", 5);
 for (i = 0 ; i < numclass ; i++)
	 {
   for (j = 0 ; j < numlearner ; j++)
			 {
     classtotal[i] += posteriors.values[j][i];
			 }
	 }
 res = find_max_in_list_double(classtotal, numclass);
 safe_free(classtotal);
 return (res);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rbx
shrq $0x20, %rbx
movq %rsi, %rdi
sarq $0x20, %rdi
leaq 0x98219(%rip), %rdx     # 0xa6048
movl $0x8, %esi
movl $0x5, %ecx
callq 0x3a1fc
movq %rax, %r12
testl %ebx, %ebx
jle 0xde7b
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
testl %r15d, %r15d
jle 0xde73
movsd (%r12,%rcx,8), %xmm0
xorl %edx, %edx
movq (%r14,%rdx,8), %rsi
addsd (%rsi,%rcx,8), %xmm0
movsd %xmm0, (%r12,%rcx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xde5c
incq %rcx
cmpq %rbx, %rcx
jne 0xde4f
movq %r12, %rdi
movl %ebx, %esi
callq 0x38031
movl %eax, %ebx
movq %r12, %rdi
callq 0x3a180
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq