LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/cart.c
// Function: create_cartchildren
int create_cartchildren(Decisionnodeptr node, C45_parameterptr param)
{
 node->conditiontype = MULTIVARIATE_CONDITION;
 if (!(can_be_divided(node, param)))
   return 1;
 if (!find_best_cart_split(node))
  {
   make_leaf_node(node);
   return 1;
  }
 node->lineard = current_dataset->multifeaturecount - 1;
 node->featureno = LINEAR; 
 if (!(make_multivariate_children(node)))
   return 1;
 create_cartchildren(node->left, param);
 create_cartchildren(node->right, param);
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x98(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x29340
cmpl $0x0, %eax
jne 0x96bc
movl $0x1, -0x4(%rbp)
jmp 0x9743
movq -0x10(%rbp), %rdi
callq 0x9150
cmpl $0x0, %eax
jne 0x96dc
movq -0x10(%rbp), %rdi
callq 0x28a30
movl $0x1, -0x4(%rbp)
jmp 0x9743
leaq 0xfc15d(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x1c0(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x10(%rbp), %rax
movl $0xfffffffe, 0x30(%rax) # imm = 0xFFFFFFFE
movq -0x10(%rbp), %rdi
callq 0x6f570
cmpl $0x0, %eax
jne 0x971b
movl $0x1, -0x4(%rbp)
jmp 0x9743
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9680
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9680
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/c45rules.c
// Function: sort_rules
void sort_rules(Ruleset* r)
{
 /*!Last Changed 05.11.2003 If i is r->end then after exchange j will be  r->end*/
 /*!Last Changed 30.10.2003*/
 Decisionruleptr i;
 Decisionruleptr j;
 Decisionruleptr ibefore;
 Decisionruleptr tmp;
 Decisionruleptr jbefore;
 if (r->start == NULL)
   return;
 for (ibefore = r->start, i = r->start->next; i != NULL; ibefore = i, i = i->next)
   for (jbefore = NULL, j = r->start; j != i; jbefore = j, j = j->next)
     if (j->classno > i->classno)
      {
       ibefore->next = j;
       if (jbefore)
         jbefore->next = i;
       else
         r->start = i;
       if (i->next == NULL)
         r->end = j;
       tmp = j->next;
       j->next = i->next;
       i->next = tmp;
       break;
      }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x9767
jmp 0x985e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x985e
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x9843
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x9828
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
cmpq $0x0, -0x30(%rbp)
je 0x97dc
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x97e7
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x97fe
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x9843
jmp 0x982a
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x979f
jmp 0x9845
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x9781
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/c45rules.c
// Function: create_subset_of_ruleset
void create_subset_of_ruleset(Ruleset* result, Decisionruleptr* rules, int* subset, int subsetcount)
{
 /*!Last Changed 30.10.2003*/
 int i;
 result->start = NULL;
 result->end = NULL;
 result->rulecount = subsetcount;
 if (subsetcount == 0)
   return;
 result->start = rules[subset[0]];
 result->end = rules[subset[subsetcount-1]];
 result->end->next = NULL;
 for (i = 0; i < subsetcount - 1; i++)
   rules[subset[i]]->next = rules[subset[i + 1]];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
cmpl $0x0, -0x1c(%rbp)
jne 0x9b1f
jmp 0x9bb6
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x30(%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x9bb6
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl -0x20(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdx
movslq -0x20(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x30(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9b6d
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/c45rules.c
// Function: remove_rules_according_indexes_of_rule
void remove_rules_according_indexes_of_rule(Decisionruleptr* rules, int rulecount, int* subset, int subsetcount)
{
 /*!Last Changed 02.12.2004*/
 int i, j;
 BOOLEAN found;
 for (i = 0; i < rulecount; i++)
  {
   found = BOOLEAN_FALSE;
   for (j = 0; j < subsetcount; j++)
     if (subset[j] == i)
      {
       found = BOOLEAN_TRUE;
       break;
      }
   if (!found)
    {
     free_rule(*(rules[i]));
     safe_free(rules[i]);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9c7e
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x9c25
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x20(%rbp), %eax
jne 0x9c18
movl $0x1, -0x28(%rbp)
jmp 0x9c25
jmp 0x9c1a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9bf7
cmpl $0x0, -0x28(%rbp)
jne 0x9c6e
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %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 0xadd10
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x52e80
jmp 0x9c70
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9bdd
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/c45rules.c
// Function: remove_rules_according_rules_themselves
void remove_rules_according_rules_themselves(Decisionruleptr* rules, int rulecount, Decisionruleptr* subsetrules, int subsetcount)
{
 /*!Last Changed 02.12.2004*/
 int i, j;
 BOOLEAN found;
 for (i = 0; i < rulecount; i++)
  {
   found = BOOLEAN_FALSE;
   for (j = 0; j < subsetcount; j++)
     if (rules[i] == subsetrules[j])
      {
       found = BOOLEAN_TRUE;
       break;
      }
   if (!found)
    {
     free_rule(*(rules[i]));
     safe_free(rules[i]);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9d58
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x9cff
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x9cf2
movl $0x1, -0x28(%rbp)
jmp 0x9cff
jmp 0x9cf4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9cc7
cmpl $0x0, -0x28(%rbp)
jne 0x9d48
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %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 0xadd10
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x52e80
jmp 0x9d4a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9cad
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/c45rules.c
// Function: create_array_from_link_list_of_rules
Decisionruleptr* create_array_from_link_list_of_rules(Decisionruleptr start, int rulecount)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 31.10.2003*/
 int i;
 Decisionruleptr tmp;
 Decisionruleptr* result;
 result = (Decisionruleptr*) safemalloc(rulecount * sizeof(Decisionruleptr), "create_array_from_link_list_of_rules", 4);
 for (i = 0, tmp = start; i < rulecount; i++)
  {
   result[i] = tmp;
   if (i != (rulecount - 1))
     tmp = tmp->next;
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
leaq 0xd8a8a(%rip), %rsi     # 0xe29c8
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9f99
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x9f8c
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9f8e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9f5b
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/c45rules.c
// Function: create_percentage_of_ruleset
void create_percentage_of_ruleset(Decisionruleptr* rules, int rulecount, int percentage, Ruleset* inlist, Ruleset* outlist)
{
 /*!Last Changed 01.11.2003*/
 int* rastgele, i;
 empty_ruleset(inlist);
 empty_ruleset(outlist);
 rastgele = random_array(rulecount);
 i = 0;
 while (i < rulecount)
  {
   if (i < (rulecount * percentage) / 10)
     add_rule(inlist, rules[rastgele[i]]);
   else
     add_rule(outlist, rules[rastgele[i]]);
   i++;
  }
 safe_free(rastgele);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xade30
movq -0x20(%rbp), %rdi
callq 0xade30
movl -0xc(%rbp), %edi
callq 0x54600
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xa2dc
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jge 0xa2b4
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xaea30
jmp 0xa2d1
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xaea30
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa26f
movq -0x28(%rbp), %rdi
callq 0x52e80
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/c45rules.c
// Function: merge_rulesets
void merge_rulesets(Ruleset* r, Ruleset sets[MAXCLASSES], int classcount)
{
 /*!Last Changed 15.11.2010*/
 /*!Last Changed 01.11.2003*/
 int i;
 safe_free(r->counts);
 empty_ruleset(r);
 for (i = 0; i < classcount; i++)
   merge_ruleset(r, sets[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rdi
callq 0xade30
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xa574
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rcx
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 0xadef0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa530
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/c45rules.c
// Function: is_pessimistic_error_rate_smaller
int is_pessimistic_error_rate_smaller(int Y1, int Y2, int E1, int E2)
{
/*!Last Changed 27.10.2003*/
 double ucfr, ucfrnegative;
 ucfr = (E1 + 0.0) / (Y1 + E1);
 ucfrnegative = (E1 + E2 + 0.0) / (Y1 + E1 + Y2 + E2);
 if (ucfr >= ucfrnegative)
   return YES;
 return NO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cvtsi2sdl -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
movl -0x8(%rbp), %eax
addl -0x10(%rbp), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
cvtsi2sd %eax, %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
movl -0x8(%rbp), %eax
addl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jb 0xa8de
movl $0x1, -0x4(%rbp)
jmp 0xa8e5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/c45rules.c
// Function: generalize_rule
void generalize_rule(Decisionruleptr rule, Instanceptr traindata)
{
 /*!Last Changed 27.10.2003*/
 int Y1, Y2, E1, E2;
 Decisionconditionptr condition, conditionbefore;
 conditionbefore = NULL;
 condition = rule->start;
 calculate_performance_for_prune(traindata, *rule, &Y1, &E1, rule->classno);
 while (condition)
  {
   remove_condition_after(rule, conditionbefore, condition);
   calculate_performance_for_prune(traindata, *rule, &Y2, &E2, rule->classno);
   if (is_pessimistic_error_rate_smaller(Y1, Y2, E1, E2))
    {
     free_condition(*condition);
     safe_free(condition);
     if (conditionbefore)
       condition = conditionbefore->next;
     else
       condition = rule->start;
     Y1 = Y2;
     E1 = E2;
    }
   else
    {
     add_condition_after(rule, conditionbefore, condition);
     conditionbefore = condition;
     condition = condition->next;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq 0x30(%rdx), %rsi
movq %rsp, %rax
movq %rsi, 0x30(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x14(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0xadab0
cmpq $0x0, -0x28(%rbp)
je 0xaa65
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xae6b0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq 0x30(%rdx), %rsi
movq %rsp, %rax
movq %rsi, 0x30(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0xadab0
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0xa870
cmpl $0x0, %eax
je 0xaa3b
movq -0x28(%rbp), %rcx
movups 0x60(%rcx), %xmm0
movq %rsp, %rax
movups %xmm0, 0x60(%rax)
movups 0x50(%rcx), %xmm0
movups %xmm0, 0x50(%rax)
movups 0x40(%rcx), %xmm0
movups %xmm0, 0x40(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xadc90
movq -0x28(%rbp), %rdi
callq 0x52e80
cmpq $0x0, -0x30(%rbp)
je 0xaa21
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xaa2d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xaa60
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xae5c0
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xa953
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/c45rules.c
// Function: generalize_c45rules
void generalize_c45rules(Ruleset* r, Instanceptr traindata)
{
 /*!Last Changed 27.10.2003*/
 Decisionruleptr rule;
 rule = r->start;
 while (rule)
  {
   generalize_rule(rule, traindata);
   rule = rule->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xaaad
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa8f0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xaa8b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/c45rules.c
// Function: choose_default_class
void choose_default_class(Ruleset* r, Instanceptr traindata)
{
 /*!Last Changed 02.02.2004 added safecalloc*/
 /*!Last Changed 03.11.2003*/
 int* classcounts, classno, i, max;
 Instanceptr tmp = traindata;
 classcounts = (int*) safecalloc(current_dataset->classno, sizeof(int), "choose_default_class", 3);
 while (tmp)
  {
   if (!ruleset_cover_instance(tmp, *r))
    {
     classno = give_classno(tmp);
     classcounts[classno]++;
    }
   tmp = tmp->next;
  }
 max = -1;
 for (i = 0; i < current_dataset->classno; i++)
   if (classcounts[i] > max)
    {
     r->defaultclass = i;
     max = classcounts[i];
    }
 safe_free(classcounts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0xfad61(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x4, %esi
leaq 0xd7efb(%rip), %rdx     # 0xe29ed
movl $0x3, %ecx
callq 0x52f40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xab5d
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rcx
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 0xae230
cmpl $0x0, %eax
jne 0xab4f
movq -0x30(%rbp), %rdi
callq 0x43530
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xab00
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
leaq 0xfaccb(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xabb2
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x24(%rbp), %eax
jle 0xaba5
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
jmp 0xaba7
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xab6b
movq -0x18(%rbp), %rdi
callq 0x52e80
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/c45rules.c
// Function: polish_ruleset
void polish_ruleset(Ruleset* r, Instanceptr traindata)
{
 /*!Last Changed 04.11.2003*/
 Decisionruleptr tmp, tmpbefore, tmpnext, deleted, deletedbefore;
 int error_decreased = YES, minerror = error_of_ruleset(*r, traindata), error;
 while (error_decreased)
  {
   error_decreased = NO;
   tmpbefore = NULL;
   tmp = r->start;
   while (tmp)
    {
     tmpnext = tmp->next;
     remove_rule_after(r, tmpbefore, tmp);
     error = error_of_ruleset(*r, traindata);
     if (error < minerror)
      {
       minerror = error;
       deleted = tmp;
       deletedbefore = tmpbefore;
       error_decreased = YES;
      }
     add_rule_after(r, tmpbefore, tmp);
     tmpbefore = tmp;
     tmp = tmpnext;
    }
   if (error_decreased)
    {
     remove_rule_after(r, deletedbefore, deleted);
     free_rule(*deleted);
     safe_free(deleted);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x3c(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %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 0xacee0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0xb122
movl $0x0, -0x3c(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb0d3
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xae850
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %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 0xacee0
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x40(%rbp), %eax
jge 0xb0ad
movl -0x44(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xae7d0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xb037
cmpl $0x0, -0x3c(%rbp)
je 0xb11d
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xae850
movq -0x30(%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 0xadd10
movq -0x30(%rbp), %rdi
callq 0x52e80
jmp 0xb013
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/c45rules.c
// Function: add_rules_from_tree
void add_rules_from_tree(Ruleset* r, Decisionnodeptr tree)
{
 /*!Last Changed 04.10.2004 added multivariate rules*/
 /*!Last Changed 24.10.2003*/
 int i, fno;
 Decisionruleptr newrule;
 if (tree->featureno == -1)
  {
   newrule = extract_rule_from_leaf(tree);
   add_rule(r, newrule);
  }
 else
  {
   fno = tree->featureno;
   if (fno < 0)
    {
     add_rules_from_tree(r, tree->left);
     add_rules_from_tree(r, tree->right);
    }
   else
     switch (current_dataset->features[fno].type){
       case INTEGER:
       case REAL:   add_rules_from_tree(r, tree->left);
                    add_rules_from_tree(r, tree->right);
                    break;
       case STRING: for (i=0;i<current_dataset->features[fno].valuecount;i++)
                      add_rules_from_tree(r, &(tree->string[i]));
                    break; 
     }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0xb169
movq -0x10(%rbp), %rdi
callq 0xad780
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xaea30
jmp 0xb259
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0xb19f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xb130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xb130
jmp 0xb257
leaq 0xfa69a(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0xb1d8
jmp 0xb1c4
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0xb1fb
jmp 0xb1ce
movl -0x24(%rbp), %eax
subl $0x2, %eax
jne 0xb255
jmp 0xb1d8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xb130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xb130
jmp 0xb255
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0xfa634(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
addq $0x30f08, %rcx          # imm = 0x30F08
movslq -0x18(%rbp), %rdx
imulq $0x340, %rdx, %rdx      # imm = 0x340
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jge 0xb253
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x14(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rsi
callq 0xb130
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb202
jmp 0xb255
jmp 0xb257
jmp 0xb259
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: read_posteriors
matrixptr read_posteriors(int numfolds, char *fname)
{
 /*!Last Changed 24.03.2006 Aydin*/
 FILE *infile;
 int i;
 char searchstring[100];
 matrixptr tmp = NULL;
 infile = fopen(fname, "r");
 if (infile)
   tmp = safemalloc(numfolds * sizeof(matrix), "read_posteriors", 6);
	else 
		 return NULL;
 for (i = 0 ; i < numfolds ; i++)
  {
   sprintf(searchstring, "####### CURRENT RUN COUNT %d", i + 1);
   infile = find_string_in_file(infile, searchstring);
   fscanf(infile, "%c", &searchstring[99]);
   tmp[i] = read_matrix_filehandle(infile);
  }
 fclose(infile);
 return(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x98(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xdcede(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xb2fa
movslq -0xc(%rbp), %rdi
shlq $0x4, %rdi
leaq 0xd77a1(%rip), %rsi     # 0xe2a88
movl $0x6, %edx
callq 0x52d70
movq %rax, -0x98(%rbp)
jmp 0xb307
movq $0x0, -0x8(%rbp)
jmp 0xb3d7
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xb3c3
leaq -0x90(%rbp), %rdi
movl -0x24(%rbp), %edx
addl $0x1, %edx
leaq 0xd776a(%rip), %rsi     # 0xe2a98
movb $0x0, %al
callq 0x4170
movq -0x20(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x512d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x90(%rbp), %rdx
addq $0x63, %rdx
leaq 0xdb5b9(%rip), %rsi     # 0xe6918
movb $0x0, %al
callq 0x4070
movq -0x98(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5a1e0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
movq %rcx, -0xa8(%rbp)
movq %rdx, -0xa0(%rbp)
movq -0xa8(%rbp), %rcx
movq %rcx, (%rax)
movq -0xa0(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb30e
movq -0x20(%rbp), %rdi
callq 0x4250
movq -0x98(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: print_confusion
void print_confusion(FILE* outfile, int** confusionmatrix, int classno)
{
 /*!Last Changed 02.08.2007*/
 int i, j;
 fprintf(outfile, "%d %d\n", classno, classno);
 for (i = 0; i < classno; i++)
  {
   for (j = 0; j < classno; j++)
     fprintf(outfile, "%d ", confusionmatrix[i][j]);
   fprintf(outfile, "\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0xd76b0(%rip), %rsi     # 0xe2ac4
movb $0x0, %al
callq 0x4280
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb486
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb469
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0xe103e(%rip), %rsi     # 0xec495
movb $0x0, %al
callq 0x4280
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb431
movq -0x8(%rbp), %rdi
leaq 0xda8c7(%rip), %rsi     # 0xe5d3b
movb $0x0, %al
callq 0x4280
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb422
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: print_posterior
void print_posterior(FILE* outfile, double** posteriors, int testsize, Instanceptr data)
{
 /*!Last Changed 01.11.2005*/
 int i = 0, j, classno;
 char pst[READLINELENGTH];
 Instanceptr tmp = data;
 fprintf(outfile, "# %d %d\n", testsize, current_dataset->classno + 1);
 while (tmp)
  {
   classno = give_classno(tmp);
   for (j = 0; j < current_dataset->classno; j++)
    {
     set_precision(pst, NULL, " ");
     fprintf(outfile, pst, posteriors[i][j]);
    }
   fprintf(outfile, "%d\n", classno);
   tmp = tmp->next;
   i++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a160, %rsp          # imm = 0x7A160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x7a158(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0xfa316(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
leaq 0xd7588(%rip), %rsi     # 0xe2ac2
movb $0x0, %al
callq 0x4280
cmpq $0x0, -0x7a158(%rbp)
je 0xb5f5
movq -0x7a158(%rbp), %rdi
callq 0x43530
movl %eax, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
leaq 0xfa2d1(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xb5c0
leaq -0x7a150(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xd9cfc(%rip), %rdx     # 0xe5285
callq 0x53310
movq -0x8(%rbp), %rdi
leaq -0x7a150(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movb $0x1, %al
callq 0x4280
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xb565
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0xe1683(%rip), %rsi     # 0xecc51
movb $0x0, %al
callq 0x4280
movq -0x7a158(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x7a158(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb541
addq $0x7a160, %rsp          # imm = 0x7A160
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: performance_initialize
Classificationresultptr performance_initialize(int testsize)
{
 /*!Last Changed 01.08.2007 added confusion matrix*/
 /*!Last Changed 02.02.2004 added safecalloc*/
 /*!Last Changed 19.03.2002*/
 int i;
 Classificationresultptr result;
 result = safemalloc(sizeof(Classificationresult), "performance_initialize", 2);
 result->performance = 0;
 result->confusion_matrix = (int**) safecalloc_2d(sizeof(int*), sizeof(int), current_dataset->classno, current_dataset->classno, "performance_initialize", 4);
 result->class_performance = safecalloc(current_dataset->classno, sizeof(int), "performance_initialize", 5);
 result->class_counts = safecalloc(current_dataset->classno, sizeof(int), "performance_initialize", 6);
 result->classno = current_dataset->classno;
 result->datasize = testsize;
 result->posteriors = (double **) safecalloc_2d(sizeof(double *), sizeof(double), testsize, current_dataset->classno, "performance_initialize", 8);
 result->hingeloss = 0.0;
 for (i = 0; i < 3; i++)
   result->knnloss[i] = 0.0;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x58, %edi
leaq 0xd7086(%rip), %rsi     # 0xe2add
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
leaq 0xf9dca(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %edx
leaq 0xf9dbd(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %ecx
movl $0x8, %edi
movl $0x4, %esi
leaq 0xd7043(%rip), %r8      # 0xe2add
movl $0x4, %r9d
callq 0x52fa0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq 0xf9d89(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x4, %esi
leaq 0xd7013(%rip), %rdx     # 0xe2add
movl $0x5, %ecx
callq 0x52f40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0xf9d5a(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x4, %esi
leaq 0xd6fe4(%rip), %rdx     # 0xe2add
movl $0x6, %ecx
callq 0x52f40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0xf9d2b(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movl -0x4(%rbp), %edx
leaq 0xf9d0a(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %ecx
movl $0x8, %esi
leaq 0xd6f95(%rip), %r8      # 0xe2add
movl $0x8, %r9d
movq %rsi, %rdi
callq 0x52fa0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rax)
movl $0x0, -0x8(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0xbb96
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xbb74
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: free_performance
void free_performance(Classificationresultptr result){
 /*!Last Changed 01.08.2007*/
 free_2d((void **) result->confusion_matrix, result->classno);
 safe_free(result->class_performance);
 safe_free(result->class_counts);
 free_2d((void **) result->posteriors, result->datasize);
 safe_free(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x52e20
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x52e20
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_select_max
void* train_select_max(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 04.08.2005*/
 /*!Last Changed 14.07.2001*/
 int i, *train_counts, datacount = data_size(*trdata);
 Model_selectmaxptr m;
 m = safemalloc(sizeof(Model_selectmax), "train_select_max", 3); 
 m->priors = safemalloc(current_dataset->classno * sizeof(double), "train_select_max", 4);
 train_counts = find_class_counts(*trdata);
 for (i = 0; i < current_dataset->classno; i++)
   m->priors[i] = train_counts[i] / (datacount + 0.0);
 m->classno = find_max_in_list(train_counts, current_dataset->classno);
 safe_free(train_counts);
 return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %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 $0x10, %edi
leaq 0xd690e(%rip), %rsi     # 0xe2b1d
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x38(%rbp)
leaq 0xf961c(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0xd68e7(%rip), %rsi     # 0xe2b1d
movl $0x4, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x183a0
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xf95d4(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xc2ad
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc262
movq -0x28(%rbp), %rdi
leaq 0xf9588(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x50070
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x52e80
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: test_select_max
Prediction test_select_max(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 01.11.2005*/
 /*!Last Changed 04.08.2005*/
 /*!Last Changed 14.07.2001*/
 Prediction predicted;
 int i;
 Model_selectmaxptr m;
 m = (Model_selectmaxptr)model;
 predicted.classno = m->classno;
 for (i = 0; i < current_dataset->classno; i++)
   posterior[i] = m->priors[i];
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq %rax, -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
movl (%rax), %eax
movl %eax, 0x8(%rdi)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
leaq 0xf9523(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0xc34e
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc313
movq -0x38(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: train_randomforest
void* train_randomforest(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 int i;
 Randomforest_parameterptr p;
 Decisionnodeptr* forest;
 Decisionnodeptr rootnode;
 Instanceptr data;
 p = (Randomforest_parameterptr) parameters;
 forest = safemalloc(p->forestsize * sizeof(Decisionnodeptr), "train_randomforest", 4);
 for (i = 0; i < p->forestsize; i++)
  {
   rootnode = createnewnode(NULL, 1);
   rootnode->instances = bootstrap_sample_without_stratification(*trdata);
   create_randomforestchildren(rootnode, p);
   data = NULL;
   accumulate_instances_tree(&data, rootnode);
   deallocate(data);
   forest[i] = rootnode;
  }
 return forest;
}

// 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)
movq -0x28(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
leaq 0xd67a0(%rip), %rsi     # 0xe2b2e
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xc41d
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x29480
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x45270
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x28820
movq $0x0, -0x40(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x29160
movq -0x40(%rbp), %rdi
callq 0x44510
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc3a3
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: test_randomforest
Prediction test_randomforest(Instanceptr data, void* model, void* parameters, double* posterior)
{
 int i;
 double* votes;
 Randomforest_parameterptr p;
 Decisionnodeptr* forest;
 Prediction predicted, predictedc45;
 forest = (Decisionnodeptr*) model;
 p = (Randomforest_parameterptr) parameters;
 votes = safecalloc(current_dataset->classno, sizeof(double), "test_randomforest", 5);
 for (i = 0; i < p->forestsize; i++) 
  {
   predictedc45 = test_c45(data, forest[i], parameters, posterior);
   votes[predictedc45.classno]++;
  }
 normalize_array_of_doubles(votes, current_dataset->classno);
 memcpy(posterior, votes, current_dataset->classno * sizeof(double));
 safe_free(votes);
 predicted.classno = findMaxOutput(posterior, current_dataset->classno);
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, -0xb8(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0xf93d0(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x8, %esi
leaq 0xd66be(%rip), %rdx     # 0xe2b41
movl $0x5, %ecx
callq 0x52f40
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xc501
movq -0x8(%rbp), %rsi
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq -0xb0(%rbp), %rdi
callq 0xc580
leaq -0x78(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0x38, %edx
callq 0x42b0
movq -0x30(%rbp), %rax
movslq -0x70(%rbp), %rcx
movsd 0xd5b2c(%rip), %xmm0    # 0xe2018
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc498
movq -0x30(%rbp), %rdi
leaq 0xf9334(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x50ba0
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq 0xf931a(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdx
shlq $0x3, %rdx
callq 0x42b0
movq -0x30(%rbp), %rdi
callq 0x52e80
movq -0x20(%rbp), %rdi
leaq 0xf92f6(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x505f0
movq -0xc0(%rbp), %rcx
movl %eax, %edx
movq -0xb8(%rbp), %rax
movl %edx, 0x8(%rcx)
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: test_c45
Prediction test_c45(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 11.07.2006 if there is no data at the node the posteriors will be same and 1 / classno*/
 /*!Last Changed 01.11.2005 added posteriors*/
 Decisionnodeptr currentnode, root = (Decisionnodeptr) model;
 Prediction predicted;
 currentnode = root;
 while (currentnode->featureno != LEAF_NODE)
   currentnode = next_node(currentnode, data);
 if (get_parameter_o("laplaceestimate") == ON)
   normalize_array_laplace(currentnode->counts, posterior, current_dataset->classno);
	else
   normalize_array(currentnode->counts, posterior, current_dataset->classno);
 predicted.classno = currentnode->classno;
 return predicted;
}

// Assembly:
pushq %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 0xc5cd
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x29a70
movq %rax, -0x28(%rbp)
jmp 0xc5b0
leaq 0xd657f(%rip), %rdi     # 0xe2b53
callq 0x79440
cmpl $0x1, %eax
jne 0xc601
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq 0xf924c(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %edx
callq 0x50ad0
jmp 0xc622
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq 0xf9229(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %edx
callq 0x50a20
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rdx
movl 0x34(%rdx), %edx
movl %edx, 0x8(%rcx)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/classification.c
// Function: test_kforest
Prediction test_kforest(Instanceptr data, void* model, void* parameters, double* posterior)
{
 int i;
 double* votes;
 Kforest_parameterptr p;
 Decisionnodeptr* forest;
 Prediction predicted, predictedc45;
 forest = (Decisionnodeptr*) model;
 p = (Kforest_parameterptr) parameters;
 votes = safecalloc(current_dataset->classno, sizeof(double), "test_randomforest", 5);
 for (i = 0; i < p->forestsize; i++)
  {
   predictedc45 = test_c45(data, forest[i], parameters, posterior);
   votes[predictedc45.classno]++;
  }
 normalize_array_of_doubles(votes, current_dataset->classno);
 memcpy(posterior, votes, current_dataset->classno * sizeof(double));
 safe_free(votes);
 predicted.classno = findMaxOutput(posterior, current_dataset->classno);
 return predicted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, -0xb8(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0xf90f0(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x8, %esi
leaq 0xd63de(%rip), %rdx     # 0xe2b41
movl $0x5, %ecx
callq 0x52f40
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xc7e1
movq -0x8(%rbp), %rsi
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq -0xb0(%rbp), %rdi
callq 0xc580
leaq -0x78(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0x38, %edx
callq 0x42b0
movq -0x30(%rbp), %rax
movslq -0x70(%rbp), %rcx
movsd 0xd584c(%rip), %xmm0    # 0xe2018
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc778
movq -0x30(%rbp), %rdi
leaq 0xf9054(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x50ba0
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq 0xf903a(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdx
shlq $0x3, %rdx
callq 0x42b0
movq -0x30(%rbp), %rdi
callq 0x52e80
movq -0x20(%rbp), %rdi
leaq 0xf9016(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %esi
callq 0x505f0
movq -0xc0(%rbp), %rcx
movl %eax, %edx
movq -0xb8(%rbp), %rax
movl %edx, 0x8(%rcx)
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)