LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: make_tree_stump
void make_tree_stump(Decisionnodeptr rootnode)
{
 int count, i;
 if (!make_children(rootnode))
  {
   setup_node_properties(rootnode);
   make_leaf_node(rootnode);
   return;
  }
 switch (current_dataset->features[rootnode->featureno].type)
  {
   case INTEGER:
   case REAL   :setup_node_properties(rootnode->left);
                make_leaf_node(rootnode->left);
                setup_node_properties(rootnode->right);
                make_leaf_node(rootnode->right);
                break;
   case STRING :count = current_dataset->features[rootnode->featureno].valuecount;
                for (i = 0; i < count; i++)
                 {
                  setup_node_properties(&(rootnode->string[i]));
                  make_leaf_node(&(rootnode->string[i]));
                 }
                break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdcde0
cmpl $0x0, %eax
jne 0xc891
movq -0x8(%rbp), %rdi
callq 0x29290
movq -0x8(%rbp), %rdi
callq 0x28a30
jmp 0xc980
leaq 0xf8fa8(%rip), %rax     # 0x105840
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0xc8d2
jmp 0xc8ba
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0xc906
jmp 0xc8c4
movl -0x14(%rbp), %eax
subl $0x2, %eax
jne 0xc980
jmp 0xc8d2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x29290
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x28a30
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x29290
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28a30
jmp 0xc980
leaq 0xf8f33(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl 0x18(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc97e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x10(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rdi
callq 0x29290
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x10(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rdi
callq 0x28a30
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc935
jmp 0xc980
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_c45stump
void* train_c45stump(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 Decisionnodeptr rootnode;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 rootnode->conditiontype = UNIVARIATE_CONDITION;
 rootnode->featureno = find_best_feature(rootnode->instances, &(rootnode->split));
 make_tree_stump(rootnode);
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x29480
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x98(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x28, %rsi
callq 0xdcd20
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x20(%rbp), %rdi
callq 0xc860
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: test_c45stump
Prediction test_c45stump(Instanceptr data, void* model, void* parameters, double* posterior)
{
 Decisionnodeptr currentnode, root = (Decisionnodeptr) model;
 Prediction predicted;
 currentnode = root;
 while (currentnode->featureno != LEAF_NODE)
   currentnode = next_node(currentnode, data);
 normalize_array(currentnode->counts, posterior, current_dataset->classno);
 predicted.classno = currentnode->classno;
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
je 0xca5d
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x29a70
movq %rax, -0x28(%rbp)
jmp 0xca40
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq 0xf8dcd(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %edx
callq 0x50a20
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rdx
movl 0x34(%rdx), %edx
movl %edx, 0x8(%rcx)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_multildtstump
void* train_multildtstump(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 Decisionnodeptr rootnode;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 rootnode->conditiontype = MULTIVARIATE_CONDITION;
 rootnode->lineard = find_best_multi_ldt_split(&(rootnode->instances), &(rootnode->w), &(rootnode->w0), MULTIVARIATE_LINEAR, 0.99);
 if (!(rootnode->lineard))
  {
   matrix_free(rootnode->w);
   setup_node_properties(rootnode);
   make_leaf_node(rootnode);
  }
 else
  {
   rootnode->featureno = LINEAR;
   make_multivariate_children(rootnode);
   setup_node_properties(rootnode->left);
   make_leaf_node(rootnode->left);
   setup_node_properties(rootnode->right);
   make_leaf_node(rootnode->right);
  }
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x29480
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x98(%rax)
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
addq $0x38, %rsi
movq -0x20(%rbp), %rdx
addq $0x48, %rdx
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
movsd 0xd5e88(%rip), %xmm0    # 0xe2a50
callq 0x6fd20
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x90(%rax)
jne 0xcc0b
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x59ea0
movq -0x20(%rbp), %rdi
callq 0x29290
movq -0x20(%rbp), %rdi
callq 0x28a30
jmp 0xcc51
movq -0x20(%rbp), %rax
movl $0xfffffffe, 0x30(%rax) # imm = 0xFFFFFFFE
movq -0x20(%rbp), %rdi
callq 0x6f570
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x29290
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x28a30
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x29290
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28a30
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_softstump
void* train_softstump(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	Decisionnodeptr treenode;
	Softregtree_parameterptr p;
	p = (Softregtree_parameterptr) parameters;
 treenode = createnewnode(NULL, 1);
 treenode->weight = 1.0;
 treenode->instances = *trdata;
 treenode->leaftype = p->leaftype;
 if (p->leaftype == CONSTANTLEAF)
   treenode->w0 = produce_random_value(-0.01, +0.01);
 else
   treenode->w = random_matrix(current_dataset->multifeaturecount, 1, -0.01, +0.01);
 find_best_soft_tree_split(treenode, treenode, *trdata, p);
 if (treenode->left != NULL)
  {
   make_leaf_node(treenode->left);
   make_leaf_node(treenode->right);
  }
 else
   make_leaf_node(treenode);
	*trdata = NULL;
	return treenode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x29480
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsd 0xd532e(%rip), %xmm0    # 0xe2018
movsd %xmm0, 0x78(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xcd34
movsd 0xd5d3c(%rip), %xmm0    # 0xe2a58
movsd 0xd52fc(%rip), %xmm1    # 0xe2020
callq 0x545a0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x48(%rax)
jmp 0xcd85
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0xf8afd(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %edi
movl $0x1, %esi
movsd 0xd5cff(%rip), %xmm0    # 0xe2a58
movsd 0xd52bf(%rip), %xmm1    # 0xe2020
callq 0x5a130
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
callq 0xc01f0
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xcdc2
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x28a30
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x28a30
jmp 0xcdcb
movq -0x20(%rbp), %rdi
callq 0x28a30
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: test_softstump
Prediction test_softstump(Instanceptr data, void* model, void* parameters, double* posterior)
{
	Decisionnodeptr treenode;
 Prediction predicted;
	treenode = (Decisionnodeptr) model;
 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;
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xbed30
callq 0x7aab0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
movsd 0xd51e9(%rip), %xmm0    # 0xe2018
subsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jbe 0xce5c
movq -0x38(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0xce67
movq -0x38(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_c45
void* train_c45(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 Decisionnodeptr rootnode;
 C45_parameterptr p;
 p = (C45_parameterptr) parameters;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 create_c45children(rootnode, p);
 if (in_list(p->prunetype, 2, MODELSELECTIONPRUNING, VALIDATIONPRUNING))
  prune_tree(rootnode, rootnode, *cvdata);
 else
  if (p->prunetype == SRMPRUNING)
   {
   if (p->prunemodel == LOCAL)
    prune_tree_according_to_model_selection_method(rootnode, MODEL_SELECTION_SRM);
   else
    prune_tree_global(rootnode, rootnode, MODEL_SELECTION_SRM);
   }
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x29480
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xdd730
movq -0x28(%rbp), %rax
movl (%rax), %edi
movl $0x2, %edx
movl $0x1, %ecx
movl %edx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0xcefe
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x2a370
jmp 0xcf37
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
jne 0xcf35
movq -0x28(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xcf21
movq -0x20(%rbp), %rdi
movl $0x3, %esi
callq 0x765a0
jmp 0xcf33
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x3, %edx
callq 0x76310
jmp 0xcf35
jmp 0xcf37
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_ktree
void* train_ktree(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 Decisionnodeptr rootnode;
 C45_parameterptr p;
 p = (C45_parameterptr) parameters;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 create_ktreechildren(rootnode, p);
 if (in_list(p->prunetype, 2, MODELSELECTIONPRUNING, VALIDATIONPRUNING))
   prune_tree(rootnode, rootnode, *cvdata);
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x29480
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x48d40
movq -0x28(%rbp), %rax
movl (%rax), %edi
movl $0x2, %edx
movl $0x1, %ecx
movl %edx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0xcfcc
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x2a370
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_nearestmean
void* train_nearestmean(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 22.03.2005*/
 int *counts;
 Instanceptr classmeans;
 counts = find_class_counts(*trdata);
 classmeans = find_class_means(*trdata, counts);
 safe_free(counts);
 return classmeans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x183a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x188c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x52e80
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, %rax
movq %rdi, %rdx
movq %rdx, %rdi
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rdx
callq 0x11900
movq -0x8(%rbp), %rdi
callq 0x43530
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x2c(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movsd 0xd4f38(%rip), %xmm0    # 0xe2018
movsd %xmm0, (%rcx,%rdx,8)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x449f0
movl %eax, -0x2c(%rbp)
movl $0x18, %edi
leaq 0xd5a44(%rip), %rsi     # 0xe2b63
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x183a0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x188c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x18e40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0xf86c0(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0xd59d1(%rip), %rsi     # 0xe2b63
movl $0x7, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
leaq 0xf8688(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xd1f9
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xd1ae
movq -0x28(%rbp), %rdi
callq 0x52e80
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
leaq 0xf85e4(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xd2fb
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x42a0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xc2390
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xd252
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
leaq 0xf8534(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xd33a
movsd -0x40(%rbp), %xmm1
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xd302
movq -0x20(%rbp), %rdi
leaq 0xf84fb(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x505f0
movq -0x50(%rbp), %rcx
movl %eax, %edx
movq -0x48(%rbp), %rax
movl %edx, 0x8(%rcx)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_ldt
void* train_ldt(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 04.10.2004 added writerules*/
 /*!Last Changed 02.02.2004*/
 /*!Last Changed 09.02.2003*/
 Decisionnodeptr rootnode;
 C45_parameterptr p;
 p = (C45_parameterptr) parameters;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 create_ldtchildren(rootnode, p);
 if (in_list(p->prunetype, 2, MODELSELECTIONPRUNING, VALIDATIONPRUNING))
   prune_tree(rootnode, rootnode, *cvdata);
 else
  {
   if (p->prunemodel == LOCAL)
     prune_tree_according_to_model_selection_method(rootnode, MODEL_SELECTION_SRM);
   else
     prune_tree_global(rootnode, rootnode, MODEL_SELECTION_SRM);
  }
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x29480
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xdf820
movq -0x28(%rbp), %rax
movl (%rax), %edi
movl $0x2, %edx
movl $0x1, %ecx
movl %edx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0xeb2e
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x2a370
jmp 0xeb5c
movq -0x28(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xeb48
movq -0x20(%rbp), %rdi
movl $0x3, %esi
callq 0x765a0
jmp 0xeb5a
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x3, %edx
callq 0x76310
jmp 0xeb5c
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x28, %edi
leaq 0xd3fb6(%rip), %rsi     # 0xe2ba1
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x50(%rbp), %rdi
xorl %edx, %edx
callq 0xa9da0
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x42b0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xaeb50
movq -0x20(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x28, %edi
leaq 0xd3c51(%rip), %rsi     # 0xe2bac
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x50(%rbp), %rdi
movl $0x1, %edx
callq 0xa9da0
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x42b0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xaeb50
movq -0x20(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x28, %edi
leaq 0xd3b7d(%rip), %rsi     # 0xe2bb8
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x50(%rbp), %rdi
movl $0x2, %edx
callq 0xa9da0
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x42b0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xaeb50
movq -0x20(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: test_rise
Prediction test_rise(Instanceptr data, void* model, void* parameters, double* posterior)
{
 Model_riseptr r;
 Decisionruleptr current;
 Prediction predicted;
 r = (Model_riseptr) model;
 current = nearest_rule(r, data, NO);
 if (current)
   predicted.classno = current->classno;
 else
   predicted.classno = r->rules.defaultclass;
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
callq 0xaaca0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xf171
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
jmp 0xf17f
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x28, %edi
leaq 0xd396a(%rip), %rsi     # 0xe2bc5
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x12ae0
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x42b0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xaeb50
movq -0x20(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_lerils
void* train_lerils(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 Ruleset* r;
 Lerils_parameterptr p;
 p = (Lerils_parameterptr)parameters;
 r = safemalloc(sizeof(Ruleset), "train_lerils", 2);
 *r = learn_ruleset_lerils(trdata, p);
 return r; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x28, %edi
leaq 0xd3897(%rip), %rsi     # 0xe2bcf
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x4f850
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x42b0
movq -0x20(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xf4bd
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xacfd0
cmpl $0x0, %eax
je 0xf4af
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
jmp 0xf4cb
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xf466
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x38(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x28, %edi
leaq 0xd36e4(%rip), %rsi     # 0xe2be7
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl $0x10, %edi
leaq 0xd36ca(%rip), %rsi     # 0xe2be7
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x29480
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xdd730
movq -0x28(%rbp), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x29160
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xb260
movq -0x60(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x28, %edx
callq 0x42b0
movq -0x30(%rbp), %rdi
callq 0x2a030
movq -0x30(%rbp), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xd9890
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0xaa70
movq -0x20(%rbp), %rdi
callq 0x9750
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0xa580
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0xf621
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0xabd0
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0xaac0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0xf64b
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0xafd0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xaeb50
movq -0x20(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x28, %edi
leaq 0xd334b(%rip), %rsi     # 0xe2bf6
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
leaq -0x50(%rbp), %rdi
callq 0x6de10
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x42b0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xaeb50
movq -0x20(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x28, %edi
leaq 0xd326d(%rip), %rsi     # 0xe2c08
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rcx
leaq -0x50(%rbp), %rdi
callq 0x75d90
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x42b0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xaeb50
movq -0x20(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0xd311c(%rip), %rsi     # 0xe2c1b
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x9d4f0
movq -0x30(%rbp), %rdi
callq 0x52e80
movq -0x20(%rbp), %rdi
leaq 0xf5d0a(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x505f0
movq -0x40(%rbp), %rdi
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rdi)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x98, %edi
leaq 0xd30a1(%rip), %rsi     # 0xe2c24
movl $0x4, %edx
callq 0x52d70
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x90, %edx
callq 0x42b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x449f0
movl %eax, -0xa0(%rbp)
movl -0xa0(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x449f0
movl %eax, -0x9c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x44720
movq %rax, -0xe0(%rbp)
movq %rdx, -0xd8(%rbp)
movq -0xe0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x44720
movq %rax, -0xf0(%rbp)
movq %rdx, -0xe8(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x190(%rbp)
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movq -0xd0(%rbp), %rcx
movq -0xc8(%rbp), %r8
leaq -0x188(%rbp), %rdi
leaq -0xa8(%rbp), %r9
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x61710
movq -0x190(%rbp), %rdi
leaq -0x188(%rbp), %rsi
movl $0x98, %edx
callq 0x42b0
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x59ea0
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x59ea0
movq -0xb0(%rbp), %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: test_mlpgeneric
Prediction test_mlpgeneric(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 01.11.2005*/
 /*!Last Changed 23.06.2005 added cv*/
 Mlpnetwork neuralnetwork;
 matrix test, testY;
 int res, i;
 double prob;
 Prediction predicted;
 neuralnetwork = *((Mlpnetworkptr) model);
 test = instancelist_to_matrix(data, CLASSIFICATION, -1, MULTIVARIATE_LINEAR);
 testMlpnInput_cls(test.values[0], &testY, neuralnetwork, &res, &prob);
 for (i = 0; i < current_dataset->classno; i++)
   posterior[i] = testY.values[0][i];
 predicted.classno = findMaxOutput(testY.values[0], current_dataset->classno);
 matrix_free(testY);
 matrix_free(test);
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x110(%rbp)
movq %rdi, -0x108(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movl $0x98, %edx
callq 0x42b0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x44720
movq %rax, -0xf8(%rbp)
movq %rdx, -0xf0(%rbp)
movq -0xf8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xf0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x100(%rbp)
movq %rsp, %rdi
movl $0x13, %ecx
leaq -0xb8(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x100(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
leaq -0xdc(%rbp), %rdx
leaq -0xe8(%rbp), %rcx
callq 0x64c10
movl $0x0, -0xe0(%rbp)
movl -0xe0(%rbp), %eax
leaq 0xf5a68(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xfe17
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movslq -0xe0(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0xe0(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0xe0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xe0(%rbp)
jmp 0xfdcb
movq -0xd0(%rbp), %rax
movq (%rax), %rdi
leaq 0xf5a18(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x505f0
movl %eax, %ecx
movq -0x110(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x59ea0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x59ea0
movq -0x108(%rbp), %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x98, %edi
leaq 0xd2d92(%rip), %rsi     # 0xe2c35
movl $0x4, %edx
callq 0x52d70
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x90, %edx
callq 0x42b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x449f0
movl %eax, -0xa0(%rbp)
movl -0xa0(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x44720
movq %rax, -0xd0(%rbp)
movq %rdx, -0xc8(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x170(%rbp)
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x168(%rbp), %rdi
leaq -0xa8(%rbp), %rcx
callq 0x653a0
movq -0x170(%rbp), %rdi
leaq -0x168(%rbp), %rsi
movl $0x98, %edx
callq 0x42b0
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x59ea0
movq -0xb0(%rbp), %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x30, %edi
leaq 0xd2c3c(%rip), %rsi     # 0xe2c3f
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x50(%rbp), %rdi
movl $0x2, %edx
callq 0xa9da0
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x28, %edx
callq 0x42b0
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xaeb50
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rsi
callq 0x44e00
movq -0x20(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x29480
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x701b0
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x2a370
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)