LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xcbc0
movq %r14, %rdi
callq 0x2eaca
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_O1/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 0x2fa14
movl %eax, %ebp
leaq 0x9955f(%rip), %r15     # 0xa2ecb
movl $0x18, %edi
movq %r15, %rsi
movl $0x3, %edx
callq 0x390f5
movq %rax, %rbx
movq (%r12), %rdi
callq 0x115e1
movq %rax, %r14
movq (%r12), %rdi
movq %rax, %rsi
callq 0x11918
movq %rax, (%rbx)
movq (%r12), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x11c3b
movq %rax, 0x8(%rbx)
leaq 0xc8eba(%rip), %r12     # 0xd2870
movq (%r12), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
movq %r15, %rsi
movl $0x7, %edx
callq 0x390f5
movq %rax, 0x10(%rbx)
movq (%r12), %rcx
movslq 0x10(%rcx), %rcx
testq %rcx, %rcx
jle 0x9a00
cvtsi2sd %ebp, %xmm0
xorl %edx, %edx
xorps %xmm1, %xmm1
cvtsi2sdl (%r14,%rdx,4), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x99e6
movq %r14, %rdi
callq 0x39194
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc8e3e(%rip), %rbp     # 0xd2870
movq (%rbp), %rax
movl 0x10(%rax), %esi
testl %esi, %esi
jle 0x9ac7
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 0x9928d(%rip), %xmm0    # 0xa2d08
jb 0x9a83
sqrtsd %xmm0, %xmm0
jmp 0x9a88
callq 0x4300
movq %r12, %rdi
movq %r13, %rsi
callq 0x8b3d0
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 0x9a51
movq (%rsp), %rbx
jmp 0x9acb
xorpd %xmm1, %xmm1
testl %esi, %esi
jle 0x9aeb
movl %esi, %eax
xorl %ecx, %ecx
movsd (%r14,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x9ad3
movq %r14, %rdi
callq 0x37852
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_O1/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 0x1c996
movq %rax, %r14
movq (%rbx), %rax
movq %rax, 0x20(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x9faa6
movl (%r15), %edi
movl $0x2, %esi
movl $0x2, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0xab09
movq (%r12), %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x1d22a
jmp 0xab2f
cmpl $0x0, 0x4(%r15)
je 0xab22
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x516d3
jmp 0xab2f
movq %r14, %rdi
movl $0x3, %esi
callq 0x518e8
movq $0x0, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9839e(%rip), %rsi     # 0xa2f09
movl $0x28, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x77d51
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 0x7b17c
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x980ec(%rip), %rsi     # 0xa2f14
movl $0x28, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x77d51
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 0x7b17c
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x98059(%rip), %rsi     # 0xa2f20
movl $0x28, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x77d51
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 0x7b17c
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x97f48(%rip), %rsi     # 0xa2f2d
movl $0x28, %edi
movl $0x2, %edx
callq 0x390f5
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xdbb1
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 0x7b17c
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb19e
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 0x7a0fc
testl %eax, %eax
jne 0xb1a5
movq 0x30(%r12), %r12
testq %r12, %r12
jne 0xb15f
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_O1/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 0x97d7d(%rip), %r15     # 0xa2f4f
movl $0x28, %edi
movq %r15, %rsi
movl $0x3, %edx
callq 0x390f5
movq %rax, %rbx
movl $0x10, %edi
movq %r15, %rsi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r12
movl $0x0, (%rax)
xorl %r13d, %r13d
movq %r13, 0x8(%rax)
xorl %edi, %edi
movl $0x1, %esi
callq 0x1c996
movq %rax, %r15
movq (%r14), %rax
movq %rax, 0x20(%r15)
movq %r15, %rdi
movq %r12, %rsi
callq 0x9e0a2
movq %r12, %rdi
callq 0x39194
movq %r13, (%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c787
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x8564
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 0x1cfd1
movq %r15, %rdi
callq 0x39194
movq (%r14), %rdi
callq 0x9b1b4
movl %eax, 0x20(%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x7fa4
movq %rbx, %rdi
callq 0x720c
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x7cae
cmpl $0x0, 0x10(%rbx)
jle 0xb2b5
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x8082
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x7fcf
cmpl $0x0, 0x10(%rbx)
jle 0xb2d1
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x837d
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 0x7b17c
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x97aa7(%rip), %rsi     # 0xa2f5e
movl $0x28, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r12
movq (%r14), %rdx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x4b9cf
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 0x7b17c
movq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x97a16(%rip), %rsi     # 0xa2f70
movl $0x28, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r12
movq (%r14), %rdx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x51216
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 0x7b17c
movq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9795a(%rip), %rsi     # 0xa2f83
movl $0x4, %edx
callq 0x390f5
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x6e714
movq %r13, %rdi
callq 0x39194
leaq 0xc721a(%rip), %rax     # 0xd2870
movq (%rax), %rax
movl 0x10(%rax), %esi
movq %r14, %rdi
callq 0x37852
movl %eax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x978f7(%rip), %rsi     # 0xa2f8c
movl $0x98, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x4310
movq (%r12), %rdi
callq 0x2fa14
movl %eax, 0x8(%r14)
movl %eax, 0x10(%r14)
movq (%r15), %rdi
callq 0x2fa14
movl %eax, 0xc(%r14)
movq (%r12), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x2f755
movq %rax, %r12
movq %rdx, %r13
movq (%r15), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x2f755
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 0x42ac4
movl $0x98, %edx
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4310
movq %r12, %rdi
movq %r13, %rsi
callq 0x3dbad
movq %r15, %rdi
movq %rbp, %rsi
callq 0x3dbad
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_O1/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 0x2f755
movq %rax, %r15
movq %rdx, %r12
movq (%rdx), %rax
movl $0x13, %ecx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x98(%rsp), %rsi
leaq 0xac(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
movq %rax, %rdi
callq 0x4500a
leaq 0xc7074(%rip), %rax     # 0xd2870
movq (%rax), %rax
movslq 0x10(%rax), %rsi
testq %rsi, %rsi
jle 0xb828
movq 0xa0(%rsp), %rax
movq (%rax), %rax
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rsi
jne 0xb815
movq 0xa0(%rsp), %rax
movq (%rax), %rdi
callq 0x37852
movl %eax, 0x8(%rbx)
movq 0x98(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0x3dbad
movq %r15, %rdi
movq %r12, %rsi
callq 0x3dbad
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_O1/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 0x97711(%rip), %rsi     # 0xa2f9d
movl $0x98, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4310
movq (%r12), %rdi
callq 0x2fa14
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 0x2f755
movq %rax, %r15
movq %rdx, %r12
leaq 0x98(%rsp), %r13
movq %r13, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0x45798
movl $0x98, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4310
movq %r15, %rdi
movq %r12, %rsi
callq 0x3dbad
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_O1/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 0x9765d(%rip), %rsi     # 0xa2fa7
movl $0x30, %edi
movl $0x3, %edx
callq 0x390f5
movq %rax, %r14
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl $0x2, %edx
movq %r15, %rcx
callq 0x77d51
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 0x7b17c
leaq 0x28(%r14), %rdi
movq $0x0, 0x28(%r14)
movq %rbx, %rsi
callq 0x2fcc4
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1c996
movq %rax, %r12
movq (%r15), %rax
movq %rax, 0x20(%r12)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4cf41
movq (%r14), %rdx
movq %r12, %rdi
movq %r12, %rsi
callq 0x1d22a
movq $0x0, (%r15)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %edi, %edi
movl $0x1, %esi
callq 0x1c996
movq %rax, %r14
movq (%rbx), %rax
movq %rax, 0x20(%r14)
movq (%rbx), %rdi
callq 0x9b1b4
movl %eax, 0x8c(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x52c86
movl (%r15), %edi
movl $0x2, %esi
movl $0x2, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0xbd2f
movl (%r15), %eax
cmpl $0x1, %eax
je 0xbd20
cmpl $0x2, %eax
jne 0xbd12
cmpl $0x0, 0x18(%r15)
je 0xbd20
movl 0x18(%r15), %esi
movq %r14, %rdi
callq 0x518e8
jmp 0xbd2f
movq (%r12), %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x1d22a
movq $0x0, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1c996
movq %rax, %r15
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%r15)
movq (%rbx), %rax
movq %rax, 0x20(%r15)
leaq 0xc6890(%rip), %r13     # 0xd2870
movq (%r13), %rax
movl 0x10(%rax), %edi
cmpl $0x2, %edi
jne 0xc025
movl (%r14), %ecx
movl %ecx, 0x60(%r15)
testl %ecx, %ecx
je 0xc07b
movl 0x1c0(%rax), %edi
movsd 0x96daf(%rip), %xmm0    # 0xa2db8
movsd 0x96daf(%rip), %xmm1    # 0xa2dc0
movl $0x1, %esi
callq 0x3dd75
movq %rax, 0x38(%r15)
movq %rdx, 0x40(%r15)
jmp 0xc096
movl $0x0, 0x60(%r15)
movsd 0x96d83(%rip), %xmm0    # 0xa2db8
movsd 0x96d83(%rip), %xmm1    # 0xa2dc0
callq 0x3a083
movq %rax, 0x50(%r15)
movq (%r13), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x96f6d(%rip), %rsi     # 0xa2fc6
movl $0xe, %edx
callq 0x390f5
movq %rax, 0x70(%r15)
movq (%r12), %rdx
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x89fc1
jmp 0xc0a8
movsd 0x96d35(%rip), %xmm0    # 0xa2db8
movsd 0x96d35(%rip), %xmm1    # 0xa2dc0
callq 0x39f62
movsd %xmm0, 0x48(%r15)
movq (%r12), %rdx
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x8a03e
movq $0x0, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc679f(%rip), %r12     # 0xd2870
movq (%r12), %rax
cmpl $0x2, 0x10(%rax)
jne 0xc10e
movq %rdx, %rdi
callq 0x88cfa
callq 0x54568
movsd %xmm0, 0x8(%r14)
movsd 0x9642a(%rip), %xmm1    # 0xa2520
subsd %xmm0, %xmm1
movsd %xmm1, (%r14)
ucomisd %xmm0, %xmm1
jbe 0xc158
movl $0x0, 0x8(%rbx)
jmp 0xc15f
movq %rdx, %rdi
callq 0x88c28
movq %rax, %r15
movq (%r12), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x5458c
movq (%r12), %rax
movslq 0x10(%rax), %rsi
testq %rsi, %rsi
jle 0xc14b
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
cmpq %rax, %rsi
jne 0xc137
movq %r14, %rdi
callq 0x37533
movl %eax, 0x8(%rbx)
jmp 0xc15f
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_O1/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 0xc640b(%rip), %rbp     # 0xd2870
movq (%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x96b5d(%rip), %rsi     # 0xa2fd5
movl $0x6, %edx
callq 0x390f5
movq %rax, %r15
movq (%rbp), %rax
movl 0x10(%rax), %esi
testl %esi, %esi
jle 0xc519
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
xorl %ebx, %ebx
movq (%r12,%rbx,8), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%r15,%rbx,8)
movq (%rbp), %rax
cmpl $0x2, 0x1c0(%rax)
jl 0xc500
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 0x2e4b6
mulsd 0x10(%rsp), %xmm0
addsd (%r15,%rbx,8), %xmm0
movsd %xmm0, (%r15,%rbx,8)
movq (%rbp), %rax
movslq 0x1c0(%rax), %rax
decq %rax
movq %r14, %rsi
cmpq %rax, %r14
jl 0xc4bc
incq %rbx
movq (%rbp), %rax
movslq 0x10(%rax), %rsi
cmpq %rsi, %rbx
jl 0xc49f
movq 0x8(%rsp), %rbx
movq (%rsp), %r14
movq %r15, %rdi
callq 0x37852
movl %eax, 0x8(%rbx)
movq (%rbp), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x5458c
movq (%rbp), %rax
movslq 0x10(%rax), %rax
testq %rax, %rax
jle 0xc556
xorl %ecx, %ecx
movsd (%r15,%rcx,8), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xc542
movq %r15, %rdi
callq 0x39194
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_O1/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 0x5439f
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 0x9157c
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x54550
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 0x8eb29
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2e3eb
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x9073f
cmpl $0x2, 0x58(%r15)
jne 0xc68f
leaq 0x9699c(%rip), %rsi     # 0xa2fde
movl $0x8, %edi
movl $0x7, %edx
callq 0x390f5
movq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8faf6
movq %r12, %rdi
callq 0x2eaca
addl %eax, %eax
movl $0x1, %ecx
subl %eax, %ecx
cvtsi2sd %ecx, %xmm0
movsd (%r13), %xmm1
callq 0x46030
movsd %xmm0, 0x10(%rbx)
movq %r13, %rdi
callq 0x39194
movq %r15, %rdi
movq %r14, %rsi
callq 0x90901
cvttsd2si %xmm0, %eax
movl %eax, 0x8(%rbx)
movq %r14, %rdi
callq 0x39194
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc61b3(%rip), %rax     # 0xd2870
movq (%rax), %rax
cmpl $0x2, 0x10(%rax)
jne 0xc6d3
movq (%rdi), %rdi
movq %rdx, %rsi
xorl %edx, %edx
jmp 0x92bec
cmpl $0x0, 0x18(%rdx)
je 0xc6e4
movq (%rdi), %rdi
movq %rdx, %rsi
jmp 0x93296
movq %rdx, %rsi
jmp 0x930a9
// File: /workspace/github_c_makefile_star2_O1/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 0xc6173(%rip), %rsi     # 0xd2870
movq (%rsi), %rsi
cmpl $0x2, 0x10(%rsi)
jne 0xc724
movq %rax, %rdi
movq %rcx, %rsi
callq 0x92f9e
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0xc737
movl $0x0, 0x8(%rbx)
jmp 0xc74e
cmpl $0x0, 0x18(%rcx)
je 0xc740
movq %rax, %rdi
movq %rcx, %rsi
callq 0x93367
jmp 0xc74b
movl $0x1, 0x8(%rbx)
jmp 0xc74e
movq %rax, %rdi
movq %rcx, %rsi
callq 0x931bb
movl %eax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcc20
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd 0x95932(%rip), %xmm0    # 0xa2518
movsd %xmm0, 0x8(%rsp)
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x2f4ea
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xcc12
movl %r13d, (%rbx)
movsd %xmm0, 0x8(%rsp)
movq %r15, %r12
movq 0x10(%r15), %r15
incl %r13d
testq %r15, %r15
jne 0xcbef
jmp 0xcc23
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_O1/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 0x963ac(%rip), %rdx     # 0xa3002
movl $0x8, %esi
movl $0x3, %ecx
callq 0x39210
movq %rax, %rbx
testq %r15, %r15
je 0xccdb
testq %r14, %r14
je 0xccad
xorl %ebp, %ebp
movq %r14, %r13
movsd 0x95899(%rip), %xmm0    # 0xa2518
movsd %xmm0, 0x10(%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x2f4ea
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
cmoval %ebp, %r12d
minsd %xmm1, %xmm0
movq 0x10(%r13), %r13
incl %ebp
testq %r13, %r13
jne 0xcc7f
movq %r14, %rdi
movl %r12d, %esi
callq 0x30fe5
movq %r15, %rdi
movq %rax, %rsi
callq 0x2f4ea
movslq %r12d, %rax
ucomisd (%rbx,%rax,8), %xmm0
jbe 0xccd2
movsd %xmm0, (%rbx,%rax,8)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0xcc6d
movl 0xc(%rsp), %eax
testl %eax, %eax
jle 0xcd49
movl %eax, %r14d
xorl %r15d, %r15d
movsd 0x9582f(%rip), %xmm2    # 0xa2520
xorpd %xmm3, %xmm3
movsd 0x9601b(%rip), %xmm4    # 0xa2d18
movsd (%rbx,%r15,8), %xmm1
ucomisd %xmm3, %xmm1
movapd %xmm2, %xmm0
jne 0xcd0f
jnp 0xcd3b
jb 0xcd1a
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0xcd37
movapd %xmm1, %xmm0
callq 0x4300
movsd 0x95fed(%rip), %xmm4    # 0xa2d18
xorpd %xmm3, %xmm3
movsd 0x957e9(%rip), %xmm2    # 0xa2520
mulsd %xmm4, %xmm0
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0xccfd
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_O1/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 0x2fa14
movl %eax, %ebx
testq %r14, %r14
je 0xd106
movq %r14, %r15
xorpd %xmm1, %xmm1
movsd %xmm1, (%rsp)
xorl %r12d, %r12d
movq %r14, %r13
movsd 0x95472(%rip), %xmm0    # 0xa2518
movsd %xmm0, 0x8(%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x2f4ea
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
cmovaq %r13, %r12
minsd %xmm1, %xmm0
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0xd0a6
movq %r12, %rdi
movq %r15, %rsi
callq 0x2f4ea
ucomisd 0x95c23(%rip), %xmm0    # 0xa2d08
jb 0xd0ed
sqrtsd %xmm0, %xmm0
jmp 0xd0f2
callq 0x4300
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0xd093
jmp 0xd10a
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
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x7a54a
movq %rax, %r12
xorl %eax, %eax
callq 0x7aa9e
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 0x7a77b
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd272
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 0x7b33f
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 0x7b33f
movsd 0x38(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xd2d9
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x7afad
cmpl %ebp, 0x10(%rbx)
jle 0xd357
movq 0x8(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7b0b6
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 0x7a989
movq %r14, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x39194
movq %r12, %r15
movq 0x30(%r12), %r12
testq %r12, %r12
je 0xd275
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 0x7b33f
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 0x7b33f
movsd 0x38(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xd2d9
jmp 0xd275
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq