LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_one_vs_rest
void divide_instancelist_one_vs_rest(Instanceptr* parentlist, Instanceptr* list1, Instanceptr* list2, int positive)
{
 /*!Last Changed 07.01.2004*/
 Instanceptr ptmp, pnext, next1 = NULL, next2 = NULL;
 ptmp = (*parentlist);
 while (ptmp)
  {
   pnext = ptmp->next;
   if (give_classno(ptmp) == positive)
    {
     if (!next1)
       *list1 = ptmp;
     else
       next1->next = ptmp;
     next1 = ptmp;
    }
   else
    {
     if (!next2)
       *list2 = ptmp;
     else
       next2->next = ptmp;
     next2 = ptmp;
    }
   ptmp = pnext;
  }
 if (next1)
   next1->next = NULL;
 if (next2)
   next2->next = NULL;
 (*parentlist) = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movq (%rdi), %r12
xorl %ebx, %ebx
xorl %r13d, %r13d
testq %r12, %r12
je 0x2cd9b
movq 0x10(%r12), %rbp
movq %r12, %rdi
callq 0x2b47e
cmpl 0xc(%rsp), %eax
movq %r13, %rax
cmoveq %rbx, %rax
movq %r14, %rcx
cmoveq %r15, %rcx
cmoveq %r12, %rbx
cmovneq %r12, %r13
leaq 0x10(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %r12, (%rdx)
movq %rbp, %r12
jmp 0x2cd5c
testq %rbx, %rbx
je 0x2cda5
andq $0x0, 0x10(%rbx)
testq %r13, %r13
je 0x2cdaf
andq $0x0, 0x10(%r13)
movq 0x10(%rsp), %rax
andq $0x0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_into_parts
Instanceptr* divide_instancelist_into_parts(Instanceptr* parentlist, int partcount)
{
 /*!Last Changed 03.08.2006*/
 int i = 0, *classes = NULL, *classcounts = NULL, *partition, pos;
 Instanceptr *result, *next, ptmp, pnext;
 result = safemalloc(partcount * sizeof(Instanceptr), "divide_instancelist_into_parts", 3);
 next = safecalloc(partcount, sizeof(Instanceptr), "divide_instancelist_into_parts", 4);
 if (current_dataset->classno > 0)
  {
   classes = find_classes(*parentlist);
   classcounts = find_class_counts(*parentlist);
  }
 partition = stratified_partition(classes, data_size(*parentlist), current_dataset->classno, classcounts);
 i = 0;
 ptmp = (*parentlist);
 while (ptmp)
  {
   pnext = ptmp->next;
   pos = partition[i] % partcount;
   if (!next[pos])
     result[pos] = ptmp;
   else
     next[pos]->next = ptmp;
   next[pos] = ptmp;
   ptmp = pnext;
   i++;
  }
 for (i = 0; i < partcount; i++)
   if (next[i])
     next[i]->next = NULL;
 (*parentlist) = NULL;
 if (current_dataset->classno > 0)
  {
   safe_free(classcounts);
   safe_free(classes);
  }
 safe_free(partition);
 safe_free(next);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %rbp
movslq %esi, %r12
leaq (,%r12,8), %rdi
leaq 0x6bd0d(%rip), %r13     # 0x98afa
pushq $0x3
popq %rdx
movq %r13, %rsi
callq 0x34f59
movq %rax, %rbx
pushq $0x8
popq %rsi
pushq $0x4
popq %rcx
movq %r12, %rdi
movq %r13, %rdx
callq 0x35067
movq %rax, %r12
leaq 0xa0a5a(%rip), %rax     # 0xcd870
movq (%rax), %r13
cmpl $0x0, 0x10(%r13)
jle 0x2ce43
movq (%rbp), %rdi
movq %rax, %r13
callq 0x10987
movq %rax, %r14
movq (%rbp), %rdi
callq 0x108c8
movq %rax, 0x8(%rsp)
movq (%r13), %r13
jmp 0x2ce4f
movq $0x0, 0x8(%rsp)
xorl %r14d, %r14d
movq (%rbp), %rdi
callq 0x2c3cc
movl 0x10(%r13), %edx
movq %r14, 0x10(%rsp)
movq %r14, %rdi
movl %eax, %esi
movq 0x8(%rsp), %r14
movq %r14, %rcx
callq 0x2ba93
movq %rax, %r13
movq (%rbp), %rsi
movq %rax, %rcx
testq %rsi, %rsi
je 0x2ceb2
movq 0x10(%rsi), %r9
movl (%rcx), %eax
cltd
idivl %r15d
movslq %edx, %rax
movq (%r12,%rax,8), %rdx
leaq 0x10(%rdx), %r8
testq %rdx, %rdx
leaq (%rbx,%rax,8), %rdx
cmovneq %r8, %rdx
movq %rsi, (%rdx)
movq %rsi, (%r12,%rax,8)
addq $0x4, %rcx
movq %r9, %rsi
jmp 0x2ce7d
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %rax, %r15
je 0x2ced3
movq (%r12,%rax,8), %rcx
testq %rcx, %rcx
je 0x2cece
andq $0x0, 0x10(%rcx)
incq %rax
jmp 0x2cebb
andq $0x0, (%rbp)
leaq 0xa0991(%rip), %rax     # 0xcd870
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x2cefa
movq %r14, %rdi
callq 0x34ff7
movq 0x10(%rsp), %rdi
callq 0x34ff7
movq %r13, %rdi
callq 0x34ff7
movq %r12, %rdi
callq 0x34ff7
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_into_classes
Instanceptr* divide_instancelist_into_classes(Instanceptr* parentlist)
{
 /*!Last Changed 04.04.2007*/
 int pos, i;
 Instanceptr *result, *next, ptmp, pnext;
 result = safemalloc(current_dataset->classno * sizeof(Instanceptr), "divide_instancelist_into_classes", 3);
 next = safecalloc(current_dataset->classno, sizeof(Instanceptr), "divide_instancelist_into_classes", 4);
 ptmp = (*parentlist);
 while (ptmp)
  {
   pnext = ptmp->next;
   pos = give_classno(ptmp);
   if (!next[pos])
     result[pos] = ptmp;
   else
     next[pos]->next = ptmp;
   next[pos] = ptmp;
   ptmp = pnext;
  }
 for (i = 0; i < current_dataset->classno; i++)
   if (next[i])
     next[i]->next = NULL;
 (*parentlist) = NULL;
 safe_free(next);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa093f(%rip), %r13     # 0xcd870
movq (%r13), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x6bbd5(%rip), %r15     # 0x98b19
pushq $0x3
popq %rdx
movq %r15, %rsi
callq 0x34f59
movq %rax, %r14
movq (%r13), %rax
movslq 0x10(%rax), %rdi
pushq $0x8
popq %rsi
pushq $0x4
popq %rcx
movq %r15, %rdx
callq 0x35067
movq %rax, %r15
movq (%rbx), %r12
testq %r12, %r12
je 0x2cfa1
movq 0x10(%r12), %rbp
movq %r12, %rdi
callq 0x2b47e
cltq
movq (%r15,%rax,8), %rcx
leaq 0x10(%rcx), %rdx
testq %rcx, %rcx
leaq (%r14,%rax,8), %rcx
cmovneq %rdx, %rcx
movq %r12, (%rcx)
movq %r12, (%r15,%rax,8)
movq %rbp, %r12
jmp 0x2cf6e
movq (%r13), %rax
movl 0x10(%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x2cfc7
movq (%r15,%rcx,8), %rdx
testq %rdx, %rdx
je 0x2cfc2
andq $0x0, 0x10(%rdx)
incq %rcx
jmp 0x2cfaf
andq $0x0, (%rbx)
movq %r15, %rdi
callq 0x34ff7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist
void divide_instancelist(Instanceptr* parentlist, Instanceptr* list1, Instanceptr* list2, int mod)
{
 /*!Last Changed 28.10.2005 called find_classes and find_class_counts*/
 /*!Last Changed 24.03.2005*/
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 23.11.2003*/
 /*!Last Changed 10.05.2003*/
 int i = 0, *classes = NULL, *classcounts = NULL, *partition;
 Instanceptr ptmp, pnext, next1 = NULL, next2 = NULL;
 if (current_dataset->classno > 0)
  {
   classes = find_classes(*parentlist);
   classcounts = find_class_counts(*parentlist);
  }
 partition = stratified_partition(classes, data_size(*parentlist), current_dataset->classno, classcounts);
 i = 0;
 ptmp = (*parentlist);
 while (ptmp)
  {
   pnext = ptmp->next;
   if (partition[i] % mod == (mod - 1))
    {
     if (!next1)
       *list1 = ptmp;
     else
       next1->next = ptmp;
     next1 = ptmp;
    }
   else
    {
     if (!next2)
       *list2 = ptmp;
     else
       next2->next = ptmp;
     next2 = ptmp;
    }
   ptmp = pnext;
   i++;
  }
 if (next1)
   next1->next = NULL;
 if (next2)
   next2->next = NULL;
 (*parentlist) = NULL;
 if (current_dataset->classno > 0)
  {
   safe_free(classcounts);
   safe_free(classes);
  }
 safe_free(partition);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
leaq 0xa086a(%rip), %rax     # 0xcd870
movq (%rax), %r14
cmpl $0x0, 0x10(%r14)
jle 0x2d036
movq (%rbp), %rdi
callq 0x10987
movq %rax, %rbx
movq (%rbp), %rdi
callq 0x108c8
movq %rax, 0x8(%rsp)
leaq 0xa083f(%rip), %rax     # 0xcd870
movq (%rax), %r14
jmp 0x2d041
movq $0x0, 0x8(%rsp)
xorl %ebx, %ebx
movq (%rbp), %rdi
callq 0x2c3cc
movl 0x10(%r14), %edx
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
movl %eax, %esi
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
callq 0x2ba93
movq %rax, %r14
movq %rbp, %rdi
movq (%rbp), %r8
leal -0x1(%r15), %ebp
xorl %esi, %esi
movq %rax, %r9
xorl %ecx, %ecx
testq %r8, %r8
je 0x2d0b9
movq 0x10(%r8), %r10
movl (%r9), %eax
cltd
idivl %r15d
cmpl %ebp, %edx
movq %rcx, %rax
cmoveq %rsi, %rax
movq %r12, %rdx
cmoveq %r13, %rdx
cmoveq %r8, %rsi
cmovneq %r8, %rcx
leaq 0x10(%rax), %r11
testq %rax, %rax
cmoveq %rdx, %r11
movq %r8, (%r11)
addq $0x4, %r9
movq %r10, %r8
jmp 0x2d07a
testq %rsi, %rsi
je 0x2d0c3
andq $0x0, 0x10(%rsi)
testq %rcx, %rcx
leaq 0xa07a3(%rip), %rax     # 0xcd870
movq 0x10(%rsp), %r15
je 0x2d0d9
andq $0x0, 0x10(%rcx)
andq $0x0, (%rdi)
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x2d0f6
movq %rbx, %rdi
callq 0x34ff7
movq %r15, %rdi
callq 0x34ff7
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: create_instancelist
Instanceptr create_instancelist(int* indexes, int count, Instanceptr* list)
{
 /*!Last Changed 09.02.2003*/
 Instanceptr result = NULL, tmp = (*list), tmp1 = NULL, tmpbefore = NULL, last = NULL;
 int i, firstgone = 1, firstleft = 1;
 i = 0;
 while (tmp && i < count)
  {
   if (tmp->index < indexes[i])
    {
     if (firstleft)
      {
       (*list) = tmp;
       firstleft = 0;
      }
     else
       last -> next = tmp;
     last = tmp; 
     tmp = tmp -> next;
    }
   else
    {
     if (tmp->index == indexes[i])
      {
       tmp1 = tmp;
       tmp = tmp -> next;
       if (firstgone)
        {
         result = tmp1;
         firstgone = 0;
        }
       else
         if (tmpbefore)
           tmpbefore -> next = tmp1;
       tmpbefore = tmp1;
      }
     i++;
    }
  }
 if (tmp1)
   tmp1 -> next = NULL;
 if (firstleft)
   (*list) = NULL; 
 else
   if (last)
     last -> next = tmp;
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq (%rdx), %r11
movl $0x1, %ebp
xorl %eax, %eax
xorl %r14d, %r14d
xorl %r10d, %r10d
xorl %ecx, %ecx
xorl %r9d, %r9d
movl %ebp, %r8d
movl %r9d, %r9d
movq %r11, %rbx
testq %r11, %r11
je 0x2d192
cmpl %esi, %r9d
jge 0x2d192
movl (%rdi,%r9,4), %r11d
cmpl %r11d, 0x18(%rbx)
jge 0x2d15e
addq $0x10, %rcx
testl %r8d, %r8d
cmovneq %rdx, %rcx
movq %rbx, (%rcx)
movq 0x10(%rbx), %r11
xorl %r8d, %r8d
movq %rbx, %rcx
jmp 0x2d12d
jne 0x2d170
movq 0x10(%rbx), %r11
xorl %r15d, %r15d
testl %ebp, %ebp
je 0x2d17b
movq %rbx, %rax
jmp 0x2d184
movq %rbx, %r11
movq %r14, %rbx
movl %ebp, %r15d
jmp 0x2d187
testq %r10, %r10
je 0x2d184
movq %rbx, 0x10(%r10)
movq %rbx, %r10
incl %r9d
movq %rbx, %r14
movl %r15d, %ebp
jmp 0x2d12a
testq %r14, %r14
je 0x2d19c
andq $0x0, 0x10(%r14)
testl %r8d, %r8d
je 0x2d1a7
andq $0x0, (%rdx)
jmp 0x2d1b0
testq %rcx, %rcx
je 0x2d1b0
movq %rbx, 0x10(%rcx)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: restore_instancelist
Instanceptr restore_instancelist(Instanceptr mainlist,Instanceptr sublist)
{
 Instanceptr result = mainlist, tmpmain = mainlist, tmpsub = sublist, mainbefore = NULL, tmp;
 if (!mainlist)
   return sublist;
 while (tmpmain && tmpsub)
  {
   if (tmpmain->index < tmpsub->index)
    {
     mainbefore = tmpmain; 
     tmpmain = tmpmain -> next;
    }
   else
    {
     if (mainbefore != NULL)
       mainbefore -> next = tmpsub;
     else
       result = sublist;
     tmp = tmpsub -> next;
     tmpsub -> next = tmpmain;
     mainbefore = tmpsub;
     tmpsub = tmp;
    }
  }
 if (tmpmain == NULL)
   mainbefore -> next = tmpsub;
 return result;
}

// Assembly:
testq %rdi, %rdi
je 0x2d32f
movq %rdi, %rax
xorl %ecx, %ecx
movq %rdi, %rdx
movq %rsi, %r8
movq %rcx, %rdi
movq %r8, %rcx
testq %rdx, %rdx
je 0x2d329
testq %rcx, %rcx
je 0x2d329
movl 0x18(%rdx), %r8d
cmpl 0x18(%rcx), %r8d
jge 0x2d30d
movq %rdx, %rdi
movq 0x10(%rdx), %rdx
jmp 0x2d2f0
movq %rsi, %r9
testq %rdi, %rdi
je 0x2d31c
movq %rcx, 0x10(%rdi)
movq %rax, %r9
movq 0x10(%rcx), %r8
movq %rdx, 0x10(%rcx)
movq %r9, %rax
jmp 0x2d2ea
testq %rdx, %rdx
je 0x2d333
retq
movq %rsi, %rax
retq
movq %rcx, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: create_index_array_for_instances
int* create_index_array_for_instances(Instanceptr instances, int* count)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 int* result, i; 
 Instanceptr tmp = instances;
 (*count) = data_size(instances);
 result = (int *) safemalloc((*count) * sizeof(int), "create_index_array_for_instances", 4);
 i = 0;
 while (tmp)
  {
   result[i] = tmp -> index;
   tmp = tmp -> next;
   i++;
  }
 return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2c3cc
movl %eax, (%r14)
movslq %eax, %rdi
shlq $0x2, %rdi
leaq 0x6b7e2(%rip), %rsi     # 0x98b3a
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %rcx
testq %rbx, %rbx
je 0x2d377
movl 0x18(%rbx), %edx
movl %edx, (%rcx)
movq 0x10(%rbx), %rbx
addq $0x4, %rcx
jmp 0x2d363
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: find_all_neighbors
Instanceptr* find_all_neighbors(Instanceptr list, Instanceptr item, int* count)
{
 Instanceptr* neighbors, data;
 int i;
 data = list;
 *count = 0;
 while (data)
  {
   if (current_dataset->kernel->values[(int)(real_feature(item, 0))][(int)(real_feature(data, 0))] > 0)
     (*count)++;
   data = data->next;
  }
 neighbors = (Instanceptr*) safemalloc ((*count) * sizeof(Instanceptr), "find_all_neighbors", 10);
 data = list;
 i = 0;
 while (data)
  {
   if (current_dataset->kernel->values[(int)(real_feature(item, 0))][(int)(real_feature(data, 0))] > 0)
    {
     neighbors[i] = data;
     i++;
    }
   data = data->next;
  }
 return neighbors;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
andl $0x0, (%rdx)
movq %rdi, %r14
leaq 0xa04d3(%rip), %r13     # 0xcd870
movq %rdi, %r12
testq %r12, %r12
je 0x2d3f3
movq (%r13), %rax
movq 0x1407210(%rax), %rax
movq 0x8(%rax), %rbp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2aea2
cvttsd2si %xmm0, %eax
cltq
movq (%rbp,%rax,8), %rbp
movq %r12, %rdi
xorl %esi, %esi
callq 0x2aea2
cvttsd2si %xmm0, %eax
cltq
movsd (%rbp,%rax,8), %xmm0
ucomisd 0x68931(%rip), %xmm0    # 0x95d18
jbe 0x2d3ec
incl (%r15)
movq 0x10(%r12), %r12
jmp 0x2d3a0
movslq (%r15), %rdi
shlq $0x3, %rdi
leaq 0x6b75a(%rip), %rsi     # 0x98b5b
pushq $0xa
popq %rdx
callq 0x34f59
movq %rax, %r15
xorl %r12d, %r12d
testq %r14, %r14
je 0x2d468
movq (%r13), %rax
movq 0x1407210(%rax), %rax
movq 0x8(%rax), %rbp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2aea2
cvttsd2si %xmm0, %eax
cltq
movq (%rbp,%rax,8), %rbp
movq %r14, %rdi
xorl %esi, %esi
callq 0x2aea2
cvttsd2si %xmm0, %eax
cltq
movsd (%rbp,%rax,8), %xmm0
ucomisd 0x688c2(%rip), %xmm0    # 0x95d18
jbe 0x2d462
movslq %r12d, %r12
movq %r14, (%r15,%r12,8)
incl %r12d
movq 0x10(%r14), %r14
jmp 0x2d40f
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: find_nearest_neighbors
Instanceptr* find_nearest_neighbors(Instanceptr list, Instanceptr item, int count)
{
 /*!Last Changed 10.03.2004*/
 Instanceptr* neighbors, data;
 double* distances, d;
 int i, j;
 neighbors = (Instanceptr*) safemalloc (count * sizeof(Instanceptr), "find_nearest_neighbors", 4);
 distances = (double *) safemalloc(count * sizeof(double), "find_nearest_neighbors", 5);
 for (i = 0; i < count; i++)
  {
   distances[i] = (double) +LONG_MAX;
   neighbors[i] = NULL;
  }
 data = list;
 while (data)
  {
   d = distance_between_instances(data, item);
   if (d < distances[count - 1])
    {
     i = 0;
     while (distances[i] < d)
       i++;
     for (j = count - 1; j > i; j--)
      {
       neighbors[j] = neighbors[j - 1];
       distances[j] = distances[j - 1];
      }
     neighbors[i] = data;
     distances[i] = d;
    }
   data = data->next;
  }
 safe_free(distances);
 return neighbors;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %r13
leaq (,%r13,8), %r12
leaq 0x6b6cf(%rip), %rsi     # 0x98b6e
pushq $0x4
popq %rdx
movq %r12, %rdi
callq 0x34f59
movq %rax, %r15
pushq $0x5
popq %rdx
movq %r12, %rdi
leaq 0x6b6b4(%rip), %rsi     # 0x98b6e
callq 0x34f59
movq %rax, %r12
xorl %eax, %eax
testl %r13d, %r13d
movl $0x0, %ecx
cmovgl %ebp, %ecx
movabsq $0x43e0000000000000, %rdx # imm = 0x43E0000000000000
cmpq %rax, %rcx
je 0x2d4ec
movq %rdx, (%r12,%rax,8)
andq $0x0, (%r15,%rax,8)
incq %rax
jmp 0x2d4d9
decl %ebp
movslq %ebp, %r13
movabsq $0x100000000, %rbp      # imm = 0x100000000
testq %r14, %r14
je 0x2d56b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2beed
movsd (%r12,%r13,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2d565
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
xorl %ecx, %ecx
addq %rbp, %rax
ucomisd (%r12,%rcx), %xmm0
leaq 0x8(%rcx), %rcx
ja 0x2d523
sarq $0x20, %rax
movq %r13, %rdx
cmpq %rax, %rdx
jle 0x2d559
movq -0x8(%r15,%rdx,8), %rsi
movq %rsi, (%r15,%rdx,8)
movsd -0x8(%r12,%rdx,8), %xmm1
movsd %xmm1, (%r12,%rdx,8)
decq %rdx
jmp 0x2d539
movq %r14, -0x8(%r15,%rcx)
movsd %xmm0, -0x8(%r12,%rcx)
movq 0x10(%r14), %r14
jmp 0x2d4fb
movq %r12, %rdi
callq 0x34ff7
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: find_nearest_neighbors_before_normalize
Instanceptr* find_nearest_neighbors_before_normalize(Instanceptr list, Instanceptr item, int count, Instance mean, Instance variance)
{
 /*!Last Changed 17.05.2004*/
 Instanceptr* neighbors, data;
 double* distances, d;
 int i, j;
 neighbors = (Instanceptr*) safemalloc (count * sizeof(Instanceptr), "find_nearest_neighbors", 4);
 distances = (double *) safemalloc(count * sizeof(double), "find_nearest_neighbors", 5);
 for (i = 0; i < count; i++)
  {
   distances[i] = (double) +LONG_MAX;
   neighbors[i] = NULL;
  }
 data = list;
 while (data)
  {
   d = distance_between_instances_before_normalize(data, item, mean, variance);
   if (d < distances[count - 1])
    {
     i = 0;
     while (distances[i] < d)
       i++;
     for (j = count - 1; j > i; j--)
      {
       neighbors[j] = neighbors[j - 1];
       distances[j] = distances[j - 1];
      }
     neighbors[i] = data;
     distances[i] = d;
    }
   data = data->next;
  }
 safe_free(distances);
 return neighbors;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %r13d
movq %rsi, 0x60(%rsp)
movq %rdi, %r14
leaq 0xa0(%rsp), %rbp
movslq %edx, %rbx
leaq (,%rbx,8), %r12
leaq 0x6b5b6(%rip), %rsi     # 0x98b6e
pushq $0x4
popq %rdx
movq %r12, %rdi
callq 0x34f59
movq %rax, %r15
pushq $0x5
popq %rdx
movq %r12, %rdi
leaq 0x6b59b(%rip), %rsi     # 0x98b6e
callq 0x34f59
movq %rax, %r12
xorl %eax, %eax
testl %ebx, %ebx
movl $0x0, %ecx
cmovgl %r13d, %ecx
movabsq $0x43e0000000000000, %rdx # imm = 0x43E0000000000000
cmpq %rax, %rcx
je 0x2d605
movq %rdx, (%r12,%rax,8)
andq $0x0, (%r15,%rax,8)
incq %rax
jmp 0x2d5f2
decl %r13d
movslq %r13d, %rbx
movabsq $0x100000000, %r13      # imm = 0x100000000
testq %r14, %r14
je 0x2d6cc
leaq 0xd0(%rsp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x50(%rsp)
movups %xmm1, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movupd (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups 0x20(%rbp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq %r14, %rdi
movq 0x60(%rsp), %rsi
callq 0x2bc0a
movsd (%r12,%rbx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2d6c3
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
xorl %ecx, %ecx
addq %r13, %rax
ucomisd (%r12,%rcx), %xmm0
leaq 0x8(%rcx), %rcx
ja 0x2d681
sarq $0x20, %rax
movq %rbx, %rdx
cmpq %rax, %rdx
jle 0x2d6b7
movq -0x8(%r15,%rdx,8), %rsi
movq %rsi, (%r15,%rdx,8)
movsd -0x8(%r12,%rdx,8), %xmm1
movsd %xmm1, (%r12,%rdx,8)
decq %rdx
jmp 0x2d697
movq %r14, -0x8(%r15,%rcx)
movsd %xmm0, -0x8(%r12,%rcx)
movq 0x10(%r14), %r14
jmp 0x2d615
movq %r12, %rdi
callq 0x34ff7
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: get_classes
int* get_classes(Instanceptr instances, int *count)
{
 int *result = NULL, i, classno;
 Instanceptr tmp = instances;
 (*count) = 0;
 while (tmp)
  {
   classno = give_classno(tmp);
   for (i = 0; i < (*count); i++)
     if (classno == result[i])
       break;
   if (i == (*count))
    {
     (*count)++;
     result = (int *)alloc(result,(*count)*sizeof(int),(*count));
     result[i] = classno;
    }
   tmp = tmp->next;
  }
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
andl $0x0, (%rsi)
xorl %r15d, %r15d
testq %r14, %r14
je 0x2d755
movq %r14, %rdi
callq 0x2b47e
movl %eax, %ebp
movslq (%rbx), %r12
testl %r12d, %r12d
movl $0x0, %eax
cmovgl %r12d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x2d72c
cmpl (%r15,%rcx,4), %ebp
je 0x2d72a
incq %rcx
jmp 0x2d71a
movl %ecx, %eax
cmpl %r12d, %eax
jne 0x2d74f
leaq 0x1(%r12), %rdx
movl %edx, (%rbx)
leaq 0x4(,%r12,4), %rsi
movq %r15, %rdi
callq 0x34f30
movq %rax, %r15
movl %ebp, (%rax,%r12,4)
movq 0x10(%r14), %r14
jmp 0x2d6fa
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/instancelist.c
// Function: find_k_nearest_neighbor_distance
double find_k_nearest_neighbor_distance(Instanceptr list, Instanceptr item, int count)
{
 /*!Last Changed 31.03.2008*/
 Instanceptr data;
 double* distances, d;
 int i, j;
 distances = (double *) safemalloc(count * sizeof(double), "find_nearest_neighbors", 5);
 for (i = 0; i < count; i++)
   distances[i] = (double) +LONG_MAX;
 data = list;
 while (data)
  {
   d = distance_between_instances(data, item);
   if (d < distances[count - 1])
    {
     i = 0;
     while (distances[i] < d)
       i++;
     for (j = count - 1; j > i; j--)
       distances[j] = distances[j - 1];
     distances[i] = d;
    }
   data = data->next;
  }
 d = distances[count - 1];
 safe_free(distances);
 return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %r12
leaq (,%r12,8), %rdi
leaq 0x6b3ba(%rip), %rsi     # 0x98b6e
pushq $0x5
popq %rdx
callq 0x34f59
movq %rax, %r15
xorl %eax, %eax
movq %r12, (%rsp)
testl %r12d, %r12d
movl $0x0, %ecx
cmovgl %ebp, %ecx
movabsq $0x43e0000000000000, %rdx # imm = 0x43E0000000000000
cmpq %rax, %rcx
je 0x2d7e8
movq %rdx, (%r15,%rax,8)
incq %rax
jmp 0x2d7da
decl %ebp
movslq %ebp, %r13
movabsq $-0x100000000, %rbp     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %r12      # imm = 0x100000000
testq %r14, %r14
je 0x2d859
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2beed
movsd (%r15,%r13,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2d853
movq %rbp, %rax
movq %r15, %rcx
addq %r12, %rax
ucomisd (%rcx), %xmm0
leaq 0x8(%rcx), %rcx
ja 0x2d823
sarq $0x20, %rax
movq %r13, %rdx
cmpq %rax, %rdx
jle 0x2d84e
movsd -0x8(%r15,%rdx,8), %xmm1
movsd %xmm1, (%r15,%rdx,8)
decq %rdx
jmp 0x2d837
movsd %xmm0, -0x8(%rcx)
movq 0x10(%r14), %r14
jmp 0x2d801
movq (%rsp), %rax
movsd -0x8(%r15,%rax,8), %xmm0
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x34ff7
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/interval.c
// Function: is_in_interval
BOOLEAN is_in_interval(Intervalptr interval, int fno)
{
 /*!Last Changed 09.05.2005*/
 Intervalptr tmp;
 tmp = interval;
 while (tmp)
  {
   if (fno >= tmp->min && fno <= tmp->max)
     return BOOLEAN_TRUE;
   tmp = tmp->next;
  }
 return BOOLEAN_FALSE;
}

// Assembly:
pushq $0x1
popq %rax
testq %rdi, %rdi
je 0x2d8cd
cmpl %esi, (%rdi)
jg 0x2d8c7
cmpl %esi, 0x4(%rdi)
jge 0x2d8cf
movq 0x8(%rdi), %rdi
jmp 0x2d8b9
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/interval.c
// Function: create_intervals
Intervalptr create_intervals(char* intervalst)
{
	/*!Last Changed 23.08.2007 corrected*/
 /*!Last Changed 09.05.2005*/
 Intervalptr result, tmp, current = NULL;
	int i, count;
 char *p, st[READLINELENGTH];
 char *strings[1000];
 if (!strchr(intervalst, ';') && !strchr(intervalst, '-') && !isinteger(intervalst))
   return NULL;
	stringlist(intervalst, ";\n", strings, &count);
 for (i = 0; i < count; i++)
	 {
		 strcpy(st, strings[i]);
   p = strtok(st, "-");
   tmp = safemalloc(sizeof(Interval), "create_intervals", 12);
   tmp->next = NULL;
   tmp->min = atoi(p);
   p = strtok(NULL, "-");
   if (p)
     tmp->max = atoi(p);
   else
     tmp->max = tmp->min;
			if (i != 0)
				 current->next = tmp;
			else
				 result = tmp;
			current = tmp;
			safe_free(strings[i]);
	 }
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7c078, %rsp          # imm = 0x7C078
movq %rdi, %rbx
pushq $0x3b
popq %rsi
callq 0x4220
testq %rax, %rax
jne 0x2d911
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0x4220
testq %rax, %rax
jne 0x2d911
movq %rbx, %rdi
callq 0x356ca
testl %eax, %eax
je 0x2d9d2
leaq 0x6bf3f(%rip), %rsi     # 0x99857
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
callq 0x36077
xorl %ebp, %ebp
leaq 0x6b61f(%rip), %r14     # 0x98f52
xorl %ebx, %ebx
movslq 0xc(%rsp), %rax
cmpq %rax, %rbp
jge 0x2d9d5
movq 0x10(%rsp,%rbp,8), %rsi
leaq 0x1f50(%rsp), %r15
movq %r15, %rdi
callq 0x4270
movq %r15, %rdi
movq %r14, %rsi
callq 0x4280
movq %rax, %r12
pushq $0x10
popq %rdi
leaq 0x6b215(%rip), %rsi     # 0x98b85
pushq $0xc
popq %rdx
callq 0x34f59
movq %rax, %r15
andq $0x0, 0x8(%rax)
movq %r12, %rdi
callq 0x4200
movl %eax, (%r15)
xorl %edi, %edi
movq %r14, %rsi
callq 0x4280
testq %rax, %rax
je 0x2d9a4
movq %rax, %rdi
callq 0x4200
jmp 0x2d9a7
movl (%r15), %eax
movl %eax, 0x4(%r15)
movq %r15, %r12
testq %rbp, %rbp
je 0x2d9ba
movq %r15, 0x8(%rbx)
movq %r13, %r12
movq 0x10(%rsp,%rbp,8), %rdi
callq 0x34ff7
incq %rbp
movq %r12, %r13
movq %r15, %rbx
jmp 0x2d935
xorl %r13d, %r13d
movq %r13, %rax
addq $0x7c078, %rsp          # imm = 0x7C078
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/isell.c
// Function: main
int main(int argc, char *argv[])
{
 FILE *myfile;
 int res;
 time_t t;
 ipstack = stack();
 mysrand(time(&t));
 output = stdout;
 printf(m1000);
 initialize_image();
 initialize_orders();
 commandtree = generate_command_tree();
 read_program_parameters();

#ifdef MPI
 MPI_Init(&argc, &argv);
 MPI_Comm_size(MPI_COMM_WORLD, &availableproccount);
 printf("Processor: %d\n", availableproccount);
 MPI_Comm_rank(MPI_COMM_WORLD, &rank);
#endif

 add_default_variables(&vars, &varcount);
 myfile = fopen("start.txt", "r");
 if (myfile)
  {
   fclose(myfile);
   res = compile_file("start.txt");
   if (res)
     load_file("start.txt");
  }
 if (argc > 1)
  {
   res = compile_file(argv[1]);
   if (res)
     load_file(argv[1]);
  }
 getorder();
 while ((res = get_order_index(order)) != 0)
  {
   process_order(res);
   getorder();
  }
 if (output != stdout)
   fclose(output);
 free_program_parameters();
 deallocate_command_tree(commandtree);
 deallocate_remaining_memory();
 free_stack(ipstack);
 printf(m1001);

#ifdef HEAP_DEBUG
 heap_debug_print_heap();
#endif

#ifdef MPI
 MPI_Finalize();
#endif
 return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
xorl %eax, %eax
callq 0x19a2f
leaq 0x37c686(%rip), %r14    # 0x3aa090
movq %rax, (%r14)
movq %rsp, %rdi
callq 0x4340
movl %eax, %edi
callq 0x35ca7
movq 0x9e5d5(%rip), %r15     # 0xcbff8
movq (%r15), %rax
leaq 0x37c67b(%rip), %r12    # 0x3aa0a8
movq %rax, (%r12)
leaq 0x6b168(%rip), %rdi     # 0x98ba0
callq 0x4090
xorl %eax, %eax
callq 0x2a6a5
xorl %eax, %eax
callq 0xdb52
xorl %eax, %eax
callq 0xdecb
leaq 0x37c657(%rip), %r13    # 0x3aa0b0
movq %rax, (%r13)
xorl %eax, %eax
callq 0x4d1c2
leaq 0x9fdfd(%rip), %rdi     # 0xcd868
leaq 0x9fa92(%rip), %rsi     # 0xcd504
callq 0x2f963
leaq 0x6b118(%rip), %rdi     # 0x98b96
leaq 0x6ddfa(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x2dab3
movq %rax, %rdi
callq 0x42a0
leaq 0x6b0f8(%rip), %rdi     # 0x98b96
callq 0x2fb39
testl %eax, %eax
je 0x2dab3
leaq 0x6b0e8(%rip), %rdi     # 0x98b96
callq 0x5a67c
cmpl $0x2, %ebp
jl 0x2dace
movq 0x8(%rbx), %rdi
callq 0x2fb39
testl %eax, %eax
je 0x2dace
movq 0x8(%rbx), %rdi
callq 0x5a67c
leaq 0x9fa53(%rip), %rbx     # 0xcd528
xorl %eax, %eax
callq 0x554f1
movq (%rbx), %rdi
callq 0xd7e8
testl %eax, %eax
je 0x2daf1
movl %eax, %edi
callq 0x5aaa8
jmp 0x2dad5
movq (%r12), %rdi
cmpq (%r15), %rdi
je 0x2daff
callq 0x42a0
xorl %eax, %eax
callq 0x4d5cb
movq (%r13), %rdi
callq 0xe029
xorl %eax, %eax
callq 0x64f15
movq (%r14), %rdi
callq 0x19a87
leaq 0x6b0aa(%rip), %rdi     # 0x98bcf
callq 0x4090
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/krule.c
// Function: count_feature_combinations_one_vs_rest
int** count_feature_combinations_one_vs_rest(Instanceptr instances, int* iter, int size, int* permsize, int positive)
{
 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, 2, "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;
    }
   if (classno == positive)
     featurecounts[permpos][0]++;
   else
     featurecounts[permpos][1]++;
   tmp = tmp->next;
  }
 return featurecounts;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movl $0x1, (%rcx)
leaq 0x9fd10(%rip), %rdx     # 0xcd870
movl $0x30f08, %eax          # imm = 0x30F08
addq (%rdx), %rax
xorl %esi, %esi
testl %r14d, %r14d
cmovlel %esi, %r14d
pushq $0x1
popq %rdx
cmpq %rsi, %r14
je 0x2db90
movslq (%r15,%rsi,4), %rdi
imulq $0x340, %rdi, %rdi      # imm = 0x340
imull 0x18(%rax,%rdi), %edx
movl %edx, (%rcx)
incq %rsi
jmp 0x2db74
leaq 0x6b04d(%rip), %r8      # 0x98be4
pushq $0x8
popq %rdi
pushq $0x4
popq %rsi
pushq $0x2
popq %rcx
pushq $0x7
popq %r9
callq 0x3509c
movq %rax, %r13
pushq $0x1
popq %rbp
testq %r12, %r12
je 0x2dc17
movq %r12, %rdi
callq 0x2b47e
leaq 0x9fcad(%rip), %rcx     # 0xcd870
movq (%rcx), %rcx
movl $0x30f08, %edx          # imm = 0x30F08
addq %rdx, %rcx
xorl %esi, %esi
xorl %edx, %edx
movl %ebp, %edi
cmpq %rsi, %r14
je 0x2dbfe
movq (%r12), %r8
movslq (%r15,%rsi,4), %r9
movl (%r8,%r9,8), %r8d
imull %edi, %r8d
addl %r8d, %edx
imulq $0x340, %r9, %r8        # imm = 0x340
imull 0x18(%rcx,%r8), %edi
incq %rsi
jmp 0x2dbd4
xorl %ecx, %ecx
cmpl %ebx, %eax
setne %cl
movslq %edx, %rax
movq (%r13,%rax,8), %rax
incl (%rax,%rcx,4)
movq 0x10(%r12), %r12
jmp 0x2dbaf
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/krule.c
// Function: find_best_discrete_condition_1
void find_best_discrete_condition_1(Korderingsplit* split, int* rangelist, int* iter, int** featurecounts, int partitioncounts[], int positive, double* bestgain)
{
 int* perm[1];
 perm[0] = first_permutation(rangelist[0]);
 do{
   update_best_discrete_condition(split, perm, rangelist, iter, featurecounts, partitioncounts, bestgain);
 }while (next_permutation(perm[0], rangelist[0]));
 safe_free(perm[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x50(%rsp), %rbx
movl (%rsi), %edi
callq 0x34711
movq %rax, %rbp
leaq 0x10(%rsp), %rax
movq %rbp, (%rax)
movq %rbx, (%rsp)
movq %r13, %rdi
leaq 0x10(%rsp), %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq 0x8(%rsp), %r9
callq 0x2dc29
movl (%r12), %esi
movq %rbp, %rdi
callq 0x34b70
testl %eax, %eax
jne 0x2ddf3
movq %rbp, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/krule.c
// Function: find_best_discrete_condition_2
void find_best_discrete_condition_2(Korderingsplit* split, int* rangelist, int* iter, int** featurecounts, int partitioncounts[], int positive, double* bestgain)
{
 int* perm[2];
 perm[0] = first_permutation(rangelist[0]);
 do{
   perm[1] = first_permutation(rangelist[1]);
   do{
     update_best_discrete_condition(split, perm, rangelist, iter, featurecounts, partitioncounts, bestgain);
   }while (next_permutation(perm[1], rangelist[1]));
   safe_free(perm[1]);
 }while (next_permutation(perm[0], rangelist[0]));
 safe_free(perm[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, %r12
movq %rdi, 0x20(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movl (%rsi), %edi
callq 0x34711
leaq 0x40(%rsp), %rcx
movq %rax, 0x8(%rsp)
movq %rax, (%rcx)
movq 0x38(%rsp), %r14
movq 0x30(%rsp), %r15
movq 0x28(%rsp), %r13
movq 0x20(%rsp), %rbx
movq 0x18(%rsp), %rbp
movl 0x4(%r12), %edi
callq 0x34711
movq %rax, 0x10(%rsp)
movq %rax, 0x48(%rsp)
movq %rbp, (%rsp)
movq %rbx, %rdi
leaq 0x40(%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x2dc29
movl 0x4(%r12), %esi
movq 0x10(%rsp), %rdi
callq 0x34b70
testl %eax, %eax
jne 0x2deab
movq 0x10(%rsp), %rdi
callq 0x34ff7
movl (%r12), %esi
movq 0x8(%rsp), %rdi
callq 0x34b70
testl %eax, %eax
jne 0x2de97
movq 0x8(%rsp), %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/krule.c
// Function: find_best_discrete_condition_3
void find_best_discrete_condition_3(Korderingsplit* split, int* rangelist, int* iter, int** featurecounts, int partitioncounts[], int positive, double* bestgain)
{
 int* perm[3];
 perm[0] = first_permutation(rangelist[0]);
 do{
   perm[1] = first_permutation(rangelist[1]);
   do{
     perm[2] = first_permutation(rangelist[2]);
     do{
       update_best_discrete_condition(split, perm, rangelist, iter, featurecounts, partitioncounts, bestgain);
     }while (next_permutation(perm[2], rangelist[2]));
     safe_free(perm[2]);
   }while (next_permutation(perm[1], rangelist[1]));
   safe_free(perm[1]);
 }while (next_permutation(perm[0], rangelist[0]));
 safe_free(perm[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rsi, 0x8(%rsp)
movl (%rsi), %edi
callq 0x34711
leaq 0x50(%rsp), %r14
movq %rax, 0x10(%rsp)
movq %rax, (%r14)
movq 0x40(%rsp), %r15
movq 0x38(%rsp), %rbx
movq 0x30(%rsp), %r13
movq 0x28(%rsp), %r12
movq 0x8(%rsp), %rbp
movq 0x8(%rsp), %rax
movl 0x4(%rax), %edi
callq 0x34711
movq %rax, 0x18(%rsp)
movq %rax, 0x58(%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edi
callq 0x34711
movq %rax, 0x20(%rsp)
movq %rax, 0x60(%rsp)
movq %r13, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq 0x48(%rsp), %r9
callq 0x2dc29
movl 0x8(%rbp), %esi
movq 0x20(%rsp), %rdi
callq 0x34b70
testl %eax, %eax
jne 0x2df9e
movq 0x20(%rsp), %rdi
callq 0x34ff7
movq 0x8(%rsp), %rax
movl 0x4(%rax), %esi
movq 0x18(%rsp), %rdi
callq 0x34b70
testl %eax, %eax
jne 0x2df87
movq 0x18(%rsp), %rdi
callq 0x34ff7
movq 0x8(%rsp), %rax
movl (%rax), %esi
movq 0x10(%rsp), %rdi
callq 0x34b70
testl %eax, %eax
jne 0x2df70
movq 0x10(%rsp), %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/krule.c
// Function: find_best_discrete_condition_4
void find_best_discrete_condition_4(Korderingsplit* split, int* rangelist, int* iter, int** featurecounts, int partitioncounts[], int positive, double* bestgain)
{
 int* perm[4];
 perm[0] = first_permutation(rangelist[0]);
 do{
   perm[1] = first_permutation(rangelist[1]);
   do{
     perm[2] = first_permutation(rangelist[2]);
     do{
       perm[3] = first_permutation(rangelist[3]);
       do{
         update_best_discrete_condition(split, perm, rangelist, iter, featurecounts, partitioncounts, bestgain);
       }while (next_permutation(perm[3], rangelist[3]));
       safe_free(perm[3]);
     }while (next_permutation(perm[2], rangelist[2]));
     safe_free(perm[2]);
   }while (next_permutation(perm[1], rangelist[1]));
   safe_free(perm[1]);
 }while (next_permutation(perm[0], rangelist[0]));
 safe_free(perm[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rdi, 0x38(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rsi, 0x10(%rsp)
movl (%rsi), %edi
callq 0x34711
leaq 0x60(%rsp), %r14
movq %rax, 0x18(%rsp)
movq %rax, (%r14)
movq 0x50(%rsp), %r15
movq 0x48(%rsp), %rbx
movq 0x40(%rsp), %r13
movq 0x38(%rsp), %r12
movq 0x10(%rsp), %rbp
movq 0x10(%rsp), %rax
movl 0x4(%rax), %edi
callq 0x34711
movq %rax, 0x20(%rsp)
movq %rax, 0x68(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edi
callq 0x34711
movq %rax, 0x28(%rsp)
movq %rax, 0x70(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %edi
callq 0x34711
movq %rax, 0x30(%rsp)
movq %rax, 0x78(%rsp)
movq %r13, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq 0x58(%rsp), %r9
callq 0x2dc29
movl 0xc(%rbp), %esi
movq 0x30(%rsp), %rdi
callq 0x34b70
testl %eax, %eax
jne 0x2e0d0
movq 0x30(%rsp), %rdi
callq 0x34ff7
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x28(%rsp), %rdi
callq 0x34b70
testl %eax, %eax
jne 0x2e0b9
movq 0x28(%rsp), %rdi
callq 0x34ff7
movq 0x10(%rsp), %rax
movl 0x4(%rax), %esi
movq 0x20(%rsp), %rdi
callq 0x34b70
testl %eax, %eax
jne 0x2e0a2
movq 0x20(%rsp), %rdi
callq 0x34ff7
movq 0x10(%rsp), %rax
movl (%rax), %esi
movq 0x18(%rsp), %rdi
callq 0x34b70
testl %eax, %eax
jne 0x2e08b
movq 0x18(%rsp), %rdi
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/krule.c
// Function: find_best_discrete_condition_omnivariate
Decisionconditionptr find_best_discrete_condition_omnivariate(Instanceptr growset, int positive)
{
 double bestgain = 0.0, gain;
 Decisionconditionptr* conditions;
 Decisionconditionptr result;
 int bestdepth = -1, depth, modelcount = get_parameter_i("hybridspace");
 conditions = safemalloc(modelcount * sizeof(Decisionconditionptr), "find_best_discrete_condition_omnivariate", 4);
 for (depth = 0; depth < modelcount; depth++)
  {
   conditions[depth] = find_best_discrete_condition(growset, depth + 1, positive, &gain);
   if (gain > bestgain)
    {
     bestgain = gain;
     bestdepth = depth;
    }
  }
 for (depth = 0; depth < modelcount; depth++)
   if (depth != bestdepth)
    {
     free_condition(*(conditions[depth]));
     safe_free(conditions[depth]);
    }
 if (bestdepth != -1)
   result = conditions[bestdepth];
 else
   result = NULL;
 safe_free(conditions);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, 0x74(%rsp)
movq %rdi, %r14
leaq 0x6aa79(%rip), %rdi     # 0x98c18
callq 0x4cd35
movslq %eax, %r13
leaq (,%r13,8), %rdi
leaq 0x6aa6e(%rip), %rsi     # 0x98c24
pushq $0x4
popq %rdx
callq 0x34f59
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
movq %rax, %rbx
xorpd %xmm0, %xmm0
pushq $-0x1
popq %r15
cmpq %rbp, %r13
je 0x2e221
leaq 0x1(%rbp), %r12
movq %r14, %rdi
movl %r12d, %esi
movl 0x74(%rsp), %edx
leaq 0x80(%rsp), %rcx
movsd %xmm0, 0x78(%rsp)
callq 0x2e283
movq %rax, (%rbx,%rbp,8)
movsd 0x80(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
ucomisd %xmm1, %xmm0
leal -0x1(%r12), %eax
cmoval %eax, %r15d
maxsd %xmm1, %xmm0
movq %r12, %rbp
jmp 0x2e1d2
movl %r15d, %r12d
xorl %ebp, %ebp
pushq $0xe
popq %r14
cmpq %rbp, %r13
je 0x2e254
cmpq %rbp, %r12
je 0x2e24f
movq (%rbx,%rbp,8), %rsi
movq %r14, %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x71b91
movq (%rbx,%rbp,8), %rdi
callq 0x34ff7
incq %rbp
jmp 0x2e22a
cmpl $-0x1, %r15d
je 0x2e263
movslq %r15d, %rax
movq (%rbx,%rax,8), %r14
jmp 0x2e266
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x34ff7
movq %r14, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/ktree.c
// Function: copy_of_korderingsplit
Korderingsplit copy_of_korderingsplit(Korderingsplit ksplit)
{
	int i, size;
	Korderingsplit newsplit;
	newsplit.featurecount = ksplit.featurecount;
	newsplit.discretesplit = safemalloc(newsplit.featurecount * sizeof(int), "copy_of_korderingsplit", 4);
	newsplit.featurelist = safemalloc(newsplit.featurecount * sizeof(int), "copy_of_korderingsplit", 5);
	newsplit.sortorder = safemalloc(newsplit.featurecount * sizeof(int*), "copy_of_korderingsplit", 6);
	memcpy(newsplit.discretesplit, ksplit.discretesplit, newsplit.featurecount * sizeof(int));
	memcpy(newsplit.featurelist, ksplit.featurelist, newsplit.featurecount * sizeof(int));
	for (i = 0; i < newsplit.featurecount; i++)
  {
   size = current_dataset->features[newsplit.featurelist[i]].valuecount;
   newsplit.sortorder[i] = safemalloc(size * sizeof(int), "copy_of_korderingsplit", 12);
   memcpy(newsplit.sortorder[i], ksplit.sortorder[i], size * sizeof(int));
  }
	return newsplit;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbp
movslq 0x40(%rsp), %r13
movl %r13d, (%rdi)
leaq (,%r13,4), %r14
leaq 0x6a6cf(%rip), %r12     # 0x98c60
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x34f59
movq %rax, %rbx
movq %rax, 0x10(%rbp)
pushq $0x5
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x34f59
movq %rax, %r15
movq %rax, 0x8(%rbp)
movq %r13, %rdi
shlq $0x3, %rdi
pushq $0x6
popq %rdx
movq %r12, %rsi
callq 0x34f59
movq %rax, %r12
movq %rbp, (%rsp)
movq %rax, 0x18(%rbp)
movq 0x50(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4310
movq 0x48(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x4310
movq 0x58(%rsp), %rbx
xorl %r14d, %r14d
testl %r13d, %r13d
movl $0x0, %ebp
cmovgl %r13d, %ebp
cmpq %r14, %rbp
je 0x2e65c
leaq 0x9f258(%rip), %rax     # 0xcd870
movq (%rax), %rax
movslq (%r15,%r14,4), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movslq 0x30f20(%rax,%rcx), %r13
shlq $0x2, %r13
movq %r13, %rdi
leaq 0x6a624(%rip), %rsi     # 0x98c60
pushq $0xc
popq %rdx
callq 0x34f59
movq %rax, (%r12,%r14,8)
movq (%rbx,%r14,8), %rsi
movq %rax, %rdi
movq %r13, %rdx
callq 0x4310
incq %r14
jmp 0x2e60c
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/ktree.c
// Function: create_kordering_condition
Decisioncondition create_kordering_condition(Korderingsplit ksplit, char comparison)
{
 Decisioncondition rule;
 rule.featureindex = DISCRETEMIX;
 rule.ksplit = copy_of_korderingsplit(ksplit);
	rule.comparison = comparison;
 return rule;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0xfffffffb, (%rdi)     # imm = 0xFFFFFFFB
addq $0x50, %rdi
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2e56c
movb %bl, 0x4(%r14)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/ktree.c
// Function: find_best_discrete_split_1
void find_best_discrete_split_1(Korderingsplit* ksplit, int* rangelist, int* iter, int** featurecounts, int* nodecounts, double* bestgain)
{
 int* perm[1];
 perm[0] = first_permutation(rangelist[0]);
 do{
   update_best_discrete_split(ksplit, perm, rangelist, iter, featurecounts, nodecounts, bestgain);
 }while (next_permutation(perm[0], rangelist[0]));
 safe_free(perm[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl (%rsi), %edi
callq 0x34711
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq %rbx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x2e728
movl (%r13), %esi
movq %rbx, %rdi
callq 0x34b70
testl %eax, %eax
jne 0x2e6e0
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/ktree.c
// Function: find_best_discrete_split_2
void find_best_discrete_split_2(Korderingsplit* ksplit, int* rangelist, int* iter, int** featurecounts, int* nodecounts, double* bestgain)
{
 int* perm[2];
 perm[0] = first_permutation(rangelist[0]);
 do{
   perm[1] = first_permutation(rangelist[1]);
   do{
     update_best_discrete_split(ksplit, perm, rangelist, iter, featurecounts, nodecounts, bestgain);
   }while (next_permutation(perm[1], rangelist[1]));
   safe_free(perm[1]);
 }while (next_permutation(perm[0], rangelist[0]));
 safe_free(perm[0]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %r13
movq %rdi, 0x18(%rsp)
movl (%rsi), %edi
callq 0x34711
leaq 0x40(%rsp), %rcx
movq %rax, 0x8(%rsp)
movq %rax, (%rcx)
movq 0x38(%rsp), %r14
movq 0x30(%rsp), %r15
movq 0x28(%rsp), %r12
movq 0x20(%rsp), %rbp
movq 0x18(%rsp), %rbx
movl 0x4(%r13), %edi
callq 0x34711
movq %rax, 0x10(%rsp)
movq %rax, 0x48(%rsp)
movq %r14, (%rsp)
movq %rbx, %rdi
leaq 0x40(%rsp), %rsi
movq %r13, %rdx
movq %rbp, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0x2e728
movl 0x4(%r13), %esi
movq 0x10(%rsp), %rdi
callq 0x34b70
testl %eax, %eax
jne 0x2e964
movq 0x10(%rsp), %rdi
callq 0x34ff7
movl (%r13), %esi
movq 0x8(%rsp), %rdi
callq 0x34b70
testl %eax, %eax
jne 0x2e951
movq 0x8(%rsp), %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7