LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariaterule.c
// Function: prunerule_in_optimize_phase
void prunerule_in_optimize_phase(Decisionruleptr rule, Instanceptr pruneset, int positive)
{
 /*!Last Changed 02.12.2004 added free_condition and safe_free*/
 /* Last Changed 21.05.2003*/
 int improved = 1;
 double performance, bestperformance = rule_value(rule, positive, pruneset);
 Decisionconditionptr best, bestbefore, tmpcondition, tmpbefore;
 while (improved)
  {
   improved = 0;
   tmpbefore = NULL;
   tmpcondition = rule->start;
   while (tmpcondition)
    {
     remove_condition_after(rule, tmpbefore, tmpcondition);
     performance = rule_value(rule, positive, pruneset);
     if (dless(performance, bestperformance) || dequal(performance, bestperformance))
      {
       bestperformance = performance;
       bestbefore = tmpbefore;
       best = tmpcondition;
       improved = 1;
      }
     add_condition_after(rule, tmpbefore, tmpcondition);
     tmpbefore = tmpcondition;
     tmpcondition = tmpcondition->next;
    }
   if (improved)
    {
     remove_condition_after(rule, bestbefore, best);
     free_condition(*best);
     safe_free(best);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0xd9b90
movsd %xmm0, -0x28(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xd9b82
movl $0x0, -0x18(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xd9b1b
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xae6b0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0xd9b90
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x52750
cmpl $0x0, %eax
jne 0xd9ad0
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x526b0
cmpl $0x0, %eax
je 0xd9af1
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xae5c0
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xd9a77
cmpl $0x0, -0x18(%rbp)
je 0xd9b7d
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xae6b0
movq -0x30(%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 -0x30(%rbp), %rdi
callq 0x52e80
jmp 0xd9a52
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariaterule.c
// Function: rule_value
double rule_value(Decisionruleptr rule, int positive, Instanceptr instances)
{
 /*!Last Changed 01.12.2003*/
 int negative = 0, total = 0;
 Instanceptr tmp;
 tmp = instances;
 while (tmp)
  {
   if (rule_cover_instance(tmp, *rule))
    {
     if (give_classno(tmp) != positive)
       negative++;
    }
   else
     if (give_classno(tmp) == positive)
       negative++;     
   total++;
   tmp = tmp->next;
  }
 return negative/(total+0.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xd9c3f
movq -0x28(%rbp), %rdi
movq -0x8(%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 0xd9c0c
movq -0x28(%rbp), %rdi
callq 0x43530
cmpl -0xc(%rbp), %eax
je 0xd9c0a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd9c25
movq -0x28(%rbp), %rdi
callq 0x43530
cmpl -0xc(%rbp), %eax
jne 0xd9c23
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd9c25
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xd9bb9
cvtsi2sdl -0x1c(%rbp), %xmm0
cvtsi2sdl -0x20(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariaterule.c
// Function: update_counts_rules
void update_counts_rules(Decisionruleptr start, Instanceptr list1, int* covered, int* uncovered, int* fp, int* fn)
{
 /*!Last Changed 04.11.2003*/
 Decisionruleptr tmprule;
 Instanceptr tmpinstance;
 int classno;
 tmpinstance = list1;
 while (tmpinstance)
  {
   tmprule = start;
   while (tmprule)
    {
     if (rule_cover_instance(tmpinstance, *tmprule))
      {
       (*covered)++;
       (*uncovered)--;
       classno = give_classno(tmpinstance);
       if (classno == tmprule->classno)
        {
         tmprule->covered++;
         (*fn)--;
        }
       else
        {
         (*fp)++;
         tmprule->falsepositives++;
        }
       break;
      }
     tmprule = tmprule->next;
    }
   tmpinstance = tmpinstance->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xda07f
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xda06e
movq -0x40(%rbp), %rdi
movq -0x38(%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 0xda05d
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x40(%rbp), %rdi
callq 0x43530
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xda043
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x30(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0xda05b
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0xda06e
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xd9fbe
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xd9fab
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariaterule.c
// Function: check_for_bestgain
void check_for_bestgain(int positive, int total, double it, double* bestgain, Decisionconditionptr result, char comparison, double value, int featureindex)
{
 /*!Last Changed 27.05.2003 gain = positive * (it - itdot);*/
 /*!Last Changed 10.05.2003*/
 double itdot, gain;
 if (positive > 0)
  {
   itdot = information(positive, total);
   gain = positive * (it - itdot);
   if (dless(*bestgain, gain))
    {
     *bestgain = gain;
     result->comparison = comparison;
     result->value = value;
     result->featureindex = featureindex;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r8b, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movsd %xmm1, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0xda36f
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0xae3a0
movsd %xmm0, -0x40(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
subsd -0x40(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd -0x48(%rbp), %xmm1
callq 0x52750
cmpl $0x0, %eax
je 0xda36d
movsd -0x48(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movb -0x21(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x4(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0xda36f
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariaterule.c
// Function: send_exceptions
void send_exceptions(Decisionconditionptr condition, Instanceptr* obey, Instanceptr* notobey)
{
 /*!Last Changed 10.05.2003*/
 Instanceptr tmp, next, last, tmpbefore;
 last = *notobey;
 if (last)
   while (last->next)
     last = last->next;
 tmpbefore = NULL;
 tmp = *obey;
 while (tmp)
  {
   next = tmp->next;
   if (!condition_cover_instance(tmp, condition))
    {
     if (last)
       last->next = tmp;
     else
       (*notobey) = tmp;
     last = tmp;
    }
   else
    {
     if (tmpbefore)
       tmpbefore->next = tmp;
     else
       (*obey) = tmp;
     tmpbefore = tmp;
    }
   tmp = next;
  }
 if (last)
   last->next = NULL;
 if (tmpbefore)
   tmpbefore->next = NULL;
 else
   (*obey) = NULL;
}

// 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), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xdada3
jmp 0xdad88
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xdada1
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xdad88
jmp 0xdada3
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xdae3a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xabfc0
cmpl $0x0, %eax
jne 0xdae05
cmpq $0x0, -0x30(%rbp)
je 0xdadf0
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xdadfb
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xdae2d
cmpq $0x0, -0x38(%rbp)
je 0xdae1a
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xdae25
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xdadb6
cmpq $0x0, -0x30(%rbp)
je 0xdae4d
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x38(%rbp)
je 0xdae62
movq -0x38(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0xdae6d
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariaterule.c
// Function: rule_value_metric
double rule_value_metric(int n, int p, int N, int P, int reptype)
{
 /*!Last Changed 18.06.2003 integer division problem*/
 /*!Last Changed 19.05.2003 if p + n is zero returns inf*/
 /*!Last Changed 10.05.2003*/
 if (reptype == 0)
   return (p + N - n) / (P + N + 0.0);
 else
   if ((p + n) != 0)
     return (p - n) / (p + n + 2.0);
   else
     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xdaec3
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
cvtsi2sd %eax, %xmm0
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
cvtsi2sd %eax, %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xdaf01
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0xdaef9
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
cvtsi2sd %eax, %xmm0
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
cvtsi2sd %eax, %xmm1
movsd 0x7db6(%rip), %xmm2     # 0xe2ca0
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xdaf01
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariaterule.c
// Function: remove_covered
void remove_covered(Instanceptr* list1, Instanceptr* list2, Decisionruleptr rule)
{
 /*!Last Changed 10.05.2003*/
 Instanceptr tmp, next, last, tmpbefore;
 last = *list2;
 if (last)
   while (last->next)
     last = last->next;
 tmpbefore = NULL;
 tmp = *list1;
 while (tmp)
  {
   next = tmp->next;
   if (rule_cover_instance(tmp, *rule))
    {
     if (last)
       last->next = tmp;
     else
       (*list2) = tmp;
     last = tmp;
    }
   else
    {
     if (tmpbefore)
       tmpbefore->next = tmp;
     else
       (*list1) = tmp;
     tmpbefore = tmp;
    }
   tmp = next;
  }
 if (last)
   last->next = NULL;
 if (tmpbefore)
   tmpbefore->next = NULL;
 else
   (*list1) = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xdb5f3
jmp 0xdb5d8
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xdb5f1
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xdb5d8
jmp 0xdb5f3
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xdb6af
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%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 0xdb67a
cmpq $0x0, -0x30(%rbp)
je 0xdb665
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xdb670
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xdb6a2
cmpq $0x0, -0x38(%rbp)
je 0xdb68f
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xdb69a
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xdb606
cmpq $0x0, -0x30(%rbp)
je 0xdb6c2
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x38(%rbp)
je 0xdb6d7
movq -0x38(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0xdb6e2
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariaterule.c
// Function: are_conditions_equal
int are_conditions_equal(Decisionconditionptr condition1, Decisionconditionptr condition2)
{
 if (condition1->featureindex != condition2->featureindex)
   return NO;
 if (in_list(current_dataset->features[condition1->featureindex].type, 2, INTEGER, REAL))
  {
   if (condition1->upperlimit != condition2->upperlimit || condition1->lowerlimit != condition2->lowerlimit)
     return NO;
   if (condition1->comparison != condition2->comparison)
     return NO;
  }
 else
   if (condition1->value != condition2->value)
     return NO;
 return YES;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0xdb71a
movl $0x0, -0x4(%rbp)
jmp 0xdb7d2
leaq 0x2a11f(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl (%rax), %edi
movl $0x2, %ecx
xorl %edx, %edx
movl %ecx, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0xdb7a8
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x10(%rax), %xmm0
jne 0xdb780
jp 0xdb780
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x18(%rax), %xmm0
jne 0xdb780
jp 0xdb780
jmp 0xdb789
movl $0x0, -0x4(%rbp)
jmp 0xdb7d2
movq -0x10(%rbp), %rax
movsbl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movsbl 0x4(%rcx), %ecx
cmpl %ecx, %eax
je 0xdb7a6
movl $0x0, -0x4(%rbp)
jmp 0xdb7d2
jmp 0xdb7cb
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0xdb7c0
jp 0xdb7c0
jmp 0xdb7c9
movl $0x0, -0x4(%rbp)
jmp 0xdb7d2
jmp 0xdb7cb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariaterule.c
// Function: are_rules_equal
int are_rules_equal(Decisionruleptr rule1, Decisionruleptr rule2)
{
 Decisionconditionptr condition1, condition2;
 if (rule1->decisioncount != rule2->decisioncount)
   return NO;
 condition1 = rule1->start;
 condition2 = rule2->start;
 while (condition1)
  {
   if (!are_conditions_equal(condition1, condition2))
     return NO;
   condition1 = condition1->next;
   condition2 = condition2->next;
  }
 return YES;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
je 0xdb809
movl $0x0, -0x4(%rbp)
jmp 0xdb864
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xdb85d
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xdb6f0
cmpl $0x0, %eax
jne 0xdb843
movl $0x0, -0x4(%rbp)
jmp 0xdb864
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xdb821
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariaterule.c
// Function: rule_exists
int rule_exists(Ruleset ruleset, Decisionruleptr rule)
{
 Decisionruleptr tmp;
 tmp = ruleset.start;
 while (tmp)
  {
   if (are_rules_equal(rule, tmp))
     return YES;
   tmp = tmp->next;
  }
 return NO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xdb8b7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xdb7e0
cmpl $0x0, %eax
je 0xdb8a9
movl $0x1, -0x4(%rbp)
jmp 0xdb8be
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xdb887
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariaterule.c
// Function: exception_count_of_ruleset
int exception_count_of_ruleset(Ruleset r, Instanceptr instances, int positive)
{
 Instanceptr tmp;
 int covered, classno, exception_count = 0;
 tmp = instances;
 while (tmp != NULL)
  {
   covered = ruleset_cover_instance(tmp, r);
   classno = give_classno(tmp);
   if ((classno == positive && !covered) || (classno != positive && covered))
     exception_count++;
   tmp = tmp->next;
  }
 return exception_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xdb965
movq -0x30(%rbp), %rcx
movq -0x18(%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 0xae230
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x43530
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0xdb940
cmpl $0x0, -0x1c(%rbp)
je 0xdb94e
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0xdb957
cmpl $0x0, -0x1c(%rbp)
je 0xdb957
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xdb8f6
movl -0x24(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariaterule.c
// Function: insert_rule_and_update_counts
void insert_rule_and_update_counts(Decisionruleptr newrule, Ruleset* r, int* covered, int* uncovered, int* fp, int* fn)
{
 /*!Last Changed 02.11.2003*/
 add_rule(r, newrule);
 *covered += newrule->covered + newrule->falsepositives;
 *uncovered -= newrule->covered + newrule->falsepositives;
 *fp += newrule->falsepositives;
 *fn -= newrule->covered;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xaea30
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x30(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: decisiontree_univariate_node_count
int decisiontree_univariate_node_count(Decisionnodeptr node)
{
 /*!Last Changed 24.11.2004*/
 if (node->featureno == LEAF_NODE)
   return 0;
 else
   if (node->featureno != LINEAR && node->featureno != QUADRATIC)
     return 1 + decisiontree_univariate_node_count(node->left) + decisiontree_univariate_node_count(node->right);
   else
     return decisiontree_univariate_node_count(node->left) + decisiontree_univariate_node_count(node->right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0xdba1f
movl $0x0, -0x4(%rbp)
jmp 0xdba84
movq -0x10(%rbp), %rax
cmpl $-0x2, 0x30(%rax)
je 0xdba5e
movq -0x10(%rbp), %rax
cmpl $-0x3, 0x30(%rax)
je 0xdba5e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xdba00
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xdba00
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xdba84
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xdba00
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xdba00
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: createcondition
Decisioncondition createcondition(int featureindex, char comparison, double value)
{
/*!Last Changed 08.04.2003*/
 Decisioncondition rule;
 rule.featureindex = featureindex;
 rule.comparison = comparison;
 rule.value = value;
 return rule;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %cl
movq %rdi, %rax
movl %esi, -0x4(%rbp)
movb %cl, -0x5(%rbp)
movsd %xmm0, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movl %ecx, (%rdi)
movb -0x5(%rbp), %cl
movb %cl, 0x4(%rdi)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rdi)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: test_univariate
int test_univariate(Instanceptr testingdata, int fno, double split, int leftclass, int rightclass)
{
 /*!Last Changed 23.09.2004*/
 int i, error = 0;
 double value;
 Instanceptr test = testingdata;
 while (test)
  {
   value = real_feature(test, fno);   
   i = give_classno(test);
   if (value <= split)
    {
     if (i != leftclass)
       error++;
    }
   else
    {
     if (i != rightclass)
       error++;
    }
   test = test->next;
  }
 return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xdbb51
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x42c40
movsd %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rdi
callq 0x43530
movl %eax, -0x24(%rbp)
movsd -0x30(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0xdbb30
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0xdbb2e
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xdbb43
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0xdbb41
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xdbb43
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xdbae9
movl -0x28(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: find_occurences_for_discrete_feature
void find_occurences_for_discrete_feature(Instanceptr instances, int fno, int ratio[MAXVALUES][MAXCLASSES])
{
/*!Last Changed 22.04.2003*/
 int i, j;
 Instanceptr tmp = instances;
 for (i = 0; i < MAXVALUES; i++)
   for (j = 0;j < MAXCLASSES; j++)
     ratio[i][j] = 0;
 while (tmp)
  {
   j = give_classno(tmp);
   i = tmp->values[fno].stringindex;
   ratio[i][j]++;
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x64, -0x1c(%rbp)
jge 0xdbbca
movl $0x0, -0x20(%rbp)
cmpl $0x32, -0x20(%rbp)
jge 0xdbbbd
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xdbb8f
jmp 0xdbbbf
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xdbb82
jmp 0xdbbcc
cmpq $0x0, -0x28(%rbp)
je 0xdbc1d
movq -0x28(%rbp), %rdi
callq 0x43530
movl %eax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xc8, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xdbbcc
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: quicksort_instances
void quicksort_instances(Instanceptr instances,int start,int end,int fno)
{
 /*!Last Changed 26.01.2003*/
 int pivot;
 if (start < end)
  {
   if (!mustrealize)
     if (quicksort_all_sorted(instances, start, end, fno))
       return;
   pivot = quicksort_partition(instances, start, end, fno);
   quicksort_instances(instances, start, pivot - 1, fno);
   quicksort_instances(instances, pivot + 1, end, fno);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xdc363
leaq 0x305c70(%rip), %rax    # 0x3e1f74
cmpl $0x0, (%rax)
jne 0xdc324
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0xdc760
cmpl $0x0, %eax
je 0xdc322
jmp 0xdc363
jmp 0xdc324
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0xdc6a0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
subl $0x1, %edx
movl -0x14(%rbp), %ecx
callq 0xdc2e0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0xdc2e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: sort_function_instances
int sort_function_instances(Instanceptr x, Instanceptr y, int fno)
{
 /*!Last Changed 22.05.2005*/
 if (!mustrealize)
   if (current_dataset->features[fno].type == INTEGER)
     if (x->values[fno].intvalue < y->values[fno].intvalue)
       return -1;
     else
       if (x->values[fno].intvalue > y->values[fno].intvalue)
         return 1;
       else
         return 0;
   else
     if (x->values[fno].floatvalue < y->values[fno].floatvalue)
       return -1;
     else
       if (x->values[fno].floatvalue > y->values[fno].floatvalue)
         return 1;
       else
         return 0;
 else
   if (real_feature(x, fno) < real_feature(y, fno))
     return -1;
   else
     if (real_feature(x, fno) > real_feature(y, fno))
       return 1;
     else
       return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq 0x305b6a(%rip), %rax    # 0x3e1f74
cmpl $0x0, (%rax)
jne 0xdc4fc
leaq 0x29426(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x1c(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0xdc496
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,8), %eax
jge 0xdc460
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdc568
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,8), %eax
jle 0xdc48a
movl $0x1, -0x4(%rbp)
jmp 0xdc568
movl $0x0, -0x4(%rbp)
jmp 0xdc568
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xdc4c8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdc568
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0xdc4f3
movl $0x1, -0x4(%rbp)
jmp 0xdc568
movl $0x0, -0x4(%rbp)
jmp 0xdc568
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x42c40
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x42c40
movsd -0x28(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xdc52d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdc568
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x42c40
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x42c40
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xdc561
movl $0x1, -0x4(%rbp)
jmp 0xdc568
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: quicksort_three_elements
Instance quicksort_three_elements(Instanceptr instances, int start, int end, int fno)
{
 /*!Last Changed 22.05.2005*/
 int mid = (start + end) / 2;
 if (sort_function_instances(&(instances[mid]), &(instances[start]), fno) < 0)
   exchange_instances(instances, start, mid);
 if (sort_function_instances(&(instances[end]), &(instances[mid]), fno) < 0)
   exchange_instances(instances, end, mid);
 if (sort_function_instances(&(instances[mid]), &(instances[start]), fno) < 0)
   exchange_instances(instances, start, mid);
 exchange_instances(instances, mid, end);
 return instances[end];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0xdc3f0
cmpl $0x0, %eax
jge 0xdc5e9
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xdc370
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x18(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0xdc3f0
cmpl $0x0, %eax
jge 0xdc623
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xdc370
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0xdc3f0
cmpl $0x0, %eax
jge 0xdc65d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xdc370
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0xdc370
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movl $0x30, %edx
callq 0x42b0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: quicksort_partition
int quicksort_partition(Instanceptr instances, int start, int end, int fno)
{
 /*!Last Changed 22.01.2004*/
 /*!Last Changed 26.01.2003*/
 Instance x;
 int i = start - 1, j;
 x = quicksort_three_elements(instances, start, end, fno);
 for (j = start; j < end; j++)
   if (sort_function_instances(&(instances[j]), &x, fno) <= 0)
    {
     i++;
     exchange_instances(instances,i,j);
    }
 exchange_instances(instances,i+1,end);
 return i + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq -0x80(%rbp), %rdi
callq 0xdc580
leaq -0x48(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl $0x30, %edx
callq 0x42b0
movl -0xc(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xdc73d
movq -0x8(%rbp), %rdi
movslq -0x50(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rsi
callq 0xdc3f0
cmpl $0x0, %eax
jg 0xdc730
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x4c(%rbp), %esi
movl -0x50(%rbp), %edx
callq 0xdc370
jmp 0xdc732
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0xdc6f0
movq -0x8(%rbp), %rdi
movl -0x4c(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0xdc370
movl -0x4c(%rbp), %eax
addl $0x1, %eax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: quicksort_all_sorted
int quicksort_all_sorted(Instanceptr instances, int start, int end, int fno)
{
 /*!Last Changed 21.05.2005*/
 int i;
 if (current_dataset->features[fno].type == INTEGER)
  {
   for (i = start + 1; i <= end; i++)
     if (instances[i].values[fno].intvalue < instances[i - 1].values[fno].intvalue)
       return 0;
  }
 else
  {
   for (i = start + 1; i <= end; i++)
     if (instances[i].values[fno].floatvalue < instances[i - 1].values[fno].floatvalue)
       return 0;
  }   
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq 0x290c8(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x1c(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0xdc7f9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0xdc7f7
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movq -0x10(%rbp), %rcx
movl -0x20(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,8), %eax
jge 0xdc7ea
movl $0x0, -0x4(%rbp)
jmp 0xdc86a
jmp 0xdc7ec
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xdc79d
jmp 0xdc863
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0xdc861
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xdc854
movl $0x0, -0x4(%rbp)
jmp 0xdc86a
jmp 0xdc856
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xdc802
jmp 0xdc863
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: find_value_list
double* find_value_list(Instanceptr instances, int fno, int* size)
{
/*!Last Changed 22.03.2002*/
 Instanceptr tmp = instances;
 double* values = NULL, value;
 int i, found;
 (*size) = 0;
 while (tmp)
  {
   found = 0;
   if (current_dataset->features[fno].type == INTEGER)
     value = tmp->values[fno].intvalue;
   else
     value = tmp->values[fno].floatvalue;
   for (i = 0; i < (*size); i++)
     if (values[i] == value)
      {
       found = 1;
       break;
      }
   if (!found)
    {
     (*size)++;
     values = (double *)alloc(values, (*size) * sizeof(double), (*size));
     values[(*size) - 1] = value;
    }
   tmp = tmp->next;
  }
 return values;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0xdc996
movl $0x0, -0x38(%rbp)
leaq 0x28f8a(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0xc(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0xdc8e9
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0xdc8fe
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xdc93c
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x30(%rbp), %xmm0
jne 0xdc92f
jp 0xdc92f
movl $0x1, -0x38(%rbp)
jmp 0xdc93c
jmp 0xdc931
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xdc905
cmpl $0x0, -0x38(%rbp)
jne 0xdc985
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
shlq $0x3, %rsi
movq -0x18(%rbp), %rax
movl (%rax), %edx
callq 0x52d10
movq %rax, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xdc89d
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: find_best_feature
int find_best_feature(Instanceptr instances, double* split)
{
/*!Last Changed 23.03.2002*/
 int i, bestfeature = -1;
 double bestgain = +INT_MAX;
 for (i = 0; i < current_dataset->featurecount; i++)
   if (find_best_split_for_feature_i(instances, i, split, &bestgain))
    {
     bestfeature = i;
     if (bestgain == 0)
       return i;
    }
 if (bestgain == ISELL)
   return -1;
 else
   return bestfeature;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movsd 0x52d1(%rip), %xmm0     # 0xe2010
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x28aeb(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0xdcda6
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0xdc9a0
cmpl $0x0, %eax
je 0xdcd99
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xdcd97
jp 0xdcd97
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xdcdca
jmp 0xdcd99
jmp 0xdcd9b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xdcd4b
movsd -0x28(%rbp), %xmm0
movsd 0x5be5(%rip), %xmm1     # 0xe2998
ucomisd %xmm1, %xmm0
jne 0xdcdc4
jp 0xdcdc4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdcdca
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: count_feature_combinations
int** count_feature_combinations(Instanceptr instances, int* iter, int size, int* permsize)
{
 int i, classno, permpos, permmultiplier;
 int** featurecounts;
 Instanceptr tmp = instances;
 (*permsize) = 1;
 for (i = 0; i < size; i++)
   (*permsize) *= current_dataset->features[iter[i]].valuecount;
 featurecounts = (int**) safecalloc_2d(sizeof(int*), sizeof(int), *permsize, current_dataset->classno, "count_feature_combinations", 7);
 while (tmp != NULL)
  {
   classno = give_classno(tmp);
   permpos = 0;
   permmultiplier = 1;
   for (i = 0; i < size; i++)
    {
     permpos += permmultiplier * tmp->values[iter[i]].stringindex;
     permmultiplier *= current_dataset->features[iter[i]].valuecount;
    }
   featurecounts[permpos][classno]++;
   tmp = tmp->next;
  }
 return featurecounts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xdd475
leaq 0x28401(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl 0x18(%rax), %ecx
movq -0x20(%rbp), %rax
imull (%rax), %ecx
movl %ecx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xdd430
movq -0x20(%rbp), %rax
movl (%rax), %edx
leaq 0x283be(%rip), %rax     # 0x105840
movq (%rax), %rax
movl 0x10(%rax), %ecx
movl $0x8, %edi
movl $0x4, %esi
leaq 0x8303(%rip), %r8       # 0xe579c
movl $0x7, %r9d
callq 0x52fa0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xdd561
movq -0x40(%rbp), %rdi
callq 0x43530
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x1, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xdd537
movl -0x30(%rbp), %eax
movq -0x40(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rdx
movslq -0x24(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
imull (%rcx,%rdx,8), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq 0x2833d(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl 0x18(%rax), %eax
imull -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xdd4d4
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xdd4a8
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/univariatetree.c
// Function: create_c45children
int create_c45children(Decisionnodeptr node, C45_parameterptr p)
{
 /*!Last Changed 10.08.2005 parametre eklendi*/
 /*!Last Changed 23.01.2003*/
 int count, i;
 node->conditiontype = UNIVARIATE_CONDITION;
 if (!(can_be_divided(node, p)))
   return 1;
 node->featureno = find_best_feature(node->instances,&(node->split));
 if (!(make_children(node)))
   return 1;
 switch (current_dataset->features[node->featureno].type)
  {
   case INTEGER:
   case REAL   :create_c45children(node->left, p);
                create_c45children(node->right, p);
                break;
   case STRING :count = current_dataset->features[node->featureno].valuecount;
                for (i = 0; i < count; i++)
                  create_c45children(&(node->string[i]), p);
                break;
  }
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x98(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x29340
cmpl $0x0, %eax
jne 0xdd76c
movl $0x1, -0x4(%rbp)
jmp 0xdd872
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0xdcd20
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0xdcde0
cmpl $0x0, %eax
jne 0xdd7a4
movl $0x1, -0x4(%rbp)
jmp 0xdd872
leaq 0x28095(%rip), %rax     # 0x105840
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x30(%rcx), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0xdd7e5
jmp 0xdd7cd
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0xdd808
jmp 0xdd7d7
movl -0x24(%rbp), %eax
subl $0x2, %eax
jne 0xdd86b
jmp 0xdd7e5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xdd730
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xdd730
jmp 0xdd86b
leaq 0x28031(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movq -0x10(%rbp), %rcx
movslq 0x30(%rcx), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xdd869
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x20(%rbp), %rax
imulq $0x160, %rax, %rax      # imm = 0x160
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xdd730
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xdd837
jmp 0xdd86b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)