LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movl %esi, %ebp
movq %rdi, %r15
movslq %esi, %r14
leaq (,%r14,8), %rdi
leaq 0x77d75(%rip), %r12     # 0xa8b7a
movq %r12, %rsi
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
movq %r12, %rdx
movl $0x4, %ecx
callq 0x3a1fc
movq %rax, %r14
leaq 0xa4a3c(%rip), %rax     # 0xd5870
movq (%rax), %rax
xorl %r12d, %r12d
cmpl $0x0, 0x10(%rax)
jle 0x30e59
movq (%r15), %rdi
callq 0x11678
movq %rax, (%rsp)
movq (%r15), %rdi
callq 0x115a6
movq %rax, %r13
jmp 0x30e64
xorl %r13d, %r13d
movq $0x0, (%rsp)
movq (%r15), %rax
testq %rax, %rax
je 0x30e7b
xorl %r12d, %r12d
incl %r12d
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x30e6f
leaq 0xa49ee(%rip), %rax     # 0xd5870
movq (%rax), %rax
movl 0x10(%rax), %edx
movq (%rsp), %rdi
movl %r12d, %esi
movq %r13, %rcx
callq 0x2f9b1
movq %rax, %r12
movq (%r15), %rsi
testq %rsi, %rsi
je 0x30ed7
movq %r12, %rcx
movq 0x10(%rsi), %rdi
movl (%rcx), %eax
cltd
idivl %ebp
movslq %edx, %rax
movq (%r14,%rax,8), %rdx
leaq 0x10(%rdx), %r8
testq %rdx, %rdx
leaq (%rbx,%rax,8), %rdx
cmovneq %r8, %rdx
movq %rsi, (%rdx)
movq %rsi, (%r14,%rax,8)
addq $0x4, %rcx
movq %rdi, %rsi
testq %rdi, %rdi
jne 0x30ea5
testl %ebp, %ebp
jle 0x30ef8
movl %ebp, %eax
xorl %ecx, %ecx
movq (%r14,%rcx,8), %rdx
testq %rdx, %rdx
je 0x30ef0
movq $0x0, 0x10(%rdx)
incq %rcx
cmpq %rcx, %rax
jne 0x30edf
movq $0x0, (%r15)
leaq 0xa496a(%rip), %rax     # 0xd5870
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x30f20
movq %r13, %rdi
callq 0x3a180
movq (%rsp), %rdi
callq 0x3a180
movq %r12, %rdi
callq 0x3a180
movq %r14, %rdi
callq 0x3a180
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa4919(%rip), %r13     # 0xd5870
movq (%r13), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x77c2f(%rip), %r15     # 0xa8b99
movq %r15, %rsi
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %r14
movq (%r13), %rax
movslq 0x10(%rax), %rdi
movl $0x8, %esi
movq %r15, %rdx
movl $0x4, %ecx
callq 0x3a1fc
movq %rax, %r15
movq (%rbx), %r12
testq %r12, %r12
je 0x30fd0
movq 0x10(%r12), %rbp
movq %r12, %rdi
callq 0x2f33a
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
testq %rbp, %rbp
jne 0x30f9f
movq (%r13), %rax
movslq 0x10(%rax), %rax
testq %rax, %rax
jle 0x30ff8
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
testq %rdx, %rdx
je 0x30ff0
movq $0x0, 0x10(%rdx)
incq %rcx
cmpq %rcx, %rax
jne 0x30fdf
movq $0x0, (%rbx)
movq %r15, %rdi
callq 0x3a180
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_O3/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
pushq %rax
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xa4839(%rip), %rax     # 0xd5870
movq (%rax), %rax
xorl %r14d, %r14d
cmpl $0x0, 0x10(%rax)
jle 0x3105c
movq (%rbx), %rdi
callq 0x11678
movq %rax, (%rsp)
movq (%rbx), %rdi
callq 0x115a6
movq %rax, %rbp
jmp 0x31066
xorl %ebp, %ebp
movq $0x0, (%rsp)
movq (%rbx), %rax
testq %rax, %rax
je 0x3107d
xorl %r14d, %r14d
incl %r14d
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x31071
leaq 0xa47ec(%rip), %rax     # 0xd5870
movq (%rax), %rax
movl 0x10(%rax), %edx
movq (%rsp), %rdi
movl %r14d, %esi
movq %rbp, %rcx
callq 0x2f9b1
movq %rax, %r14
movq (%rbx), %r8
testq %r8, %r8
je 0x31106
leal -0x1(%r15), %edi
xorl %ecx, %ecx
movq %r14, %r9
xorl %esi, %esi
movq 0x10(%r8), %r10
movl (%r9), %eax
cltd
idivl %r15d
cmpl %edi, %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
testq %r10, %r10
jne 0x310af
testq %rsi, %rsi
je 0x310f9
movq $0x0, 0x10(%rsi)
testq %rcx, %rcx
je 0x31106
movq $0x0, 0x10(%rcx)
movq $0x0, (%rbx)
leaq 0xa475c(%rip), %rax     # 0xd5870
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x3112e
movq %rbp, %rdi
callq 0x3a180
movq (%rsp), %rdi
callq 0x3a180
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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), %rbx
testq %rbx, %rbx
sete %al
testl %esi, %esi
setle %r8b
xorl %ecx, %ecx
orb %al, %r8b
jne 0x311fb
movl $0x1, %r9d
movl $0x1, %ebp
xorl %r8d, %r8d
xorl %r10d, %r10d
xorl %r14d, %r14d
xorl %eax, %eax
movslq %ecx, %r11
movl (%rdi,%r11,4), %r11d
cmpl %r11d, 0x18(%rbx)
jge 0x311a1
addq $0x10, %r8
testl %r9d, %r9d
cmovneq %rdx, %r8
movq %rbx, (%r8)
movq 0x10(%rbx), %r11
xorl %r9d, %r9d
movq %rbx, %r8
jmp 0x311d2
jne 0x311b3
movq 0x10(%rbx), %r11
xorl %r15d, %r15d
testl %ebp, %ebp
je 0x311be
movq %rbx, %rax
jmp 0x311c7
movq %rbx, %r11
movq %r14, %rbx
movl %ebp, %r15d
jmp 0x311ca
testq %r10, %r10
je 0x311c7
movq %rbx, 0x10(%r10)
movq %rbx, %r10
incl %ecx
movq %rbx, %r14
movl %r15d, %ebp
testq %r11, %r11
je 0x311de
movq %r11, %rbx
cmpl %esi, %ecx
jl 0x3117a
testq %r14, %r14
je 0x311eb
movq $0x0, 0x10(%r14)
testl %r9d, %r9d
jne 0x311fd
testq %r8, %r8
je 0x31204
movq %r11, 0x10(%r8)
jmp 0x31204
xorl %eax, %eax
movq $0x0, (%rdx)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x313a3
testq %rsi, %rsi
je 0x313a7
xorl %ecx, %ecx
movq %rsi, %rdx
movq %rdi, %rax
movl 0x18(%rdi), %r8d
cmpl 0x18(%rdx), %r8d
jge 0x3136d
movq 0x10(%rdi), %r9
movq %rdx, %r8
movq %rdi, %rcx
jmp 0x3138d
movq %rsi, %r9
testq %rcx, %rcx
je 0x3137c
movq %rdx, 0x10(%rcx)
movq %rax, %r9
movq 0x10(%rdx), %r8
movq %rdi, 0x10(%rdx)
movq %r9, %rax
movq %rdi, %r9
movq %rdx, %rcx
testq %r9, %r9
je 0x3139d
movq %r8, %rdx
movq %r9, %rdi
testq %r8, %r8
jne 0x31357
testq %r9, %r9
je 0x313ab
retq
movq %rsi, %rax
retq
movq %rdi, %rax
retq
movq %r8, 0x10(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
xorl %eax, %eax
testq %rdi, %rdi
je 0x313c9
movq %rbx, %rcx
incl %eax
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x313be
movl %eax, (%rsi)
movslq %eax, %rdi
shlq $0x2, %rdi
leaq 0x777e1(%rip), %rsi     # 0xa8bba
movl $0x4, %edx
callq 0x3a0e1
testq %rbx, %rbx
je 0x313fd
movq %rax, %rcx
movl 0x18(%rbx), %edx
movl %edx, (%rcx)
movq 0x10(%rbx), %rbx
addq $0x4, %rcx
testq %rbx, %rbx
jne 0x313eb
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0x0, (%rdx)
testq %rdi, %rdi
je 0x31509
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa4447(%rip), %r13     # 0xd5870
movq %rdi, %r12
movq (%r13), %rax
movq 0x1407210(%rax), %rax
movq 0x8(%rax), %rbp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2ed6a
cvttsd2si %xmm0, %eax
cltq
movq (%rbp,%rax,8), %rbp
movq %r12, %rdi
xorl %esi, %esi
callq 0x2ed6a
cvttsd2si %xmm0, %eax
cltq
movsd (%rbp,%rax,8), %xmm0
ucomisd 0x7489a(%rip), %xmm0    # 0xa5d08
jbe 0x31473
incl (%r15)
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x3142c
movslq (%r15), %rdi
shlq $0x3, %rdi
leaq 0x77750(%rip), %rsi     # 0xa8bdb
movl $0xa, %edx
callq 0x3a0e1
movq %rax, %r15
testq %r14, %r14
je 0x314f7
xorl %r12d, %r12d
movq (%r13), %rax
movq 0x1407210(%rax), %rax
movq 0x8(%rax), %rbp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2ed6a
cvttsd2si %xmm0, %eax
cltq
movq (%rbp,%rax,8), %rbp
movq %r14, %rdi
xorl %esi, %esi
callq 0x2ed6a
cvttsd2si %xmm0, %eax
cltq
movsd (%rbp,%rax,8), %xmm0
ucomisd 0x74826(%rip), %xmm0    # 0xa5d08
jbe 0x314ee
movslq %r12d, %r12
movq %r14, (%r15,%r12,8)
incl %r12d
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x314a0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x776cb(%rip), %rsi     # 0xa8bdb
xorl %edi, %edi
movl $0xa, %edx
jmp 0x3a0e1
// File: /workspace/github_c_makefile_star2_O3/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
movq %rsi, %r14
movq %rdi, %r15
movl %edx, 0x4(%rsp)
movslq %edx, %rbx
leaq (,%rbx,8), %r13
leaq 0x776ab(%rip), %rbp     # 0xa8bee
movq %r13, %rdi
movq %rbp, %rsi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r12
movq %r13, %rdi
movq %rbp, %rsi
movl $0x5, %edx
callq 0x3a0e1
movq %rax, %r13
testl %ebx, %ebx
jle 0x31592
movl 0x4(%rsp), %eax
xorl %ecx, %ecx
movabsq $0x43e0000000000000, %rdx # imm = 0x43E0000000000000
movq %rdx, (%r13,%rcx,8)
movq $0x0, (%r12,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x3157d
testq %r15, %r15
je 0x3162f
movl 0x4(%rsp), %eax
decl %eax
movl %eax, 0x4(%rsp)
movslq %eax, %rbp
movabsq $0x100000000, %rbx      # imm = 0x100000000
movq %r15, %rdi
movq %r14, %rsi
callq 0x2fe29
movsd (%r13,%rbp,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x31626
movq $-0x1, %rcx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %rbx, %rax
ucomisd 0x8(%r13,%rcx,8), %xmm0
leaq 0x1(%rcx), %rcx
ja 0x315db
cmpl %ecx, 0x4(%rsp)
jle 0x3161b
sarq $0x20, %rax
movq %rbp, %rdx
movq -0x8(%r12,%rdx,8), %rsi
movq %rsi, (%r12,%rdx,8)
movsd -0x8(%r13,%rdx,8), %xmm1
movsd %xmm1, (%r13,%rdx,8)
leaq -0x1(%rdx), %rsi
movq %rsi, %rdx
cmpq %rax, %rsi
jg 0x315f8
movq %r15, (%r12,%rcx,8)
movsd %xmm0, (%r13,%rcx,8)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x315b2
movq %r13, %rdi
callq 0x3a180
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x78, %rsp
movq %rsi, 0x70(%rsp)
movq %rdi, %r15
movl %edx, %r14d
movslq %edx, %rbx
leaq (,%rbx,8), %r13
leaq 0x7757a(%rip), %rbp     # 0xa8bee
movq %r13, %rdi
movq %rbp, %rsi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r12
movq %r13, %rdi
movq %rbp, %rsi
movl $0x5, %edx
callq 0x3a0e1
movq %rax, %r13
testl %ebx, %ebx
jle 0x316c2
movl %r14d, %eax
xorl %ecx, %ecx
movabsq $0x43e0000000000000, %rdx # imm = 0x43E0000000000000
movq %rdx, (%r13,%rcx,8)
movq $0x0, (%r12,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x316ad
testq %r15, %r15
je 0x317b5
leaq 0xe0(%rsp), %rbp
leaq 0xb0(%rsp), %rbx
decl %r14d
movl %r14d, 0x64(%rsp)
movslq %r14d, %rax
movq %rax, 0x68(%rsp)
movabsq $0x100000000, %r14      # imm = 0x100000000
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups 0x20(%rbp), %xmm2
movups %xmm2, 0x50(%rsp)
movups %xmm1, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movupd (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq %r15, %rdi
movq 0x70(%rsp), %rsi
callq 0x2fb32
movq 0x68(%rsp), %rax
movsd (%r13,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x317a8
movq $-0x1, %rcx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %r14, %rax
ucomisd 0x8(%r13,%rcx,8), %xmm0
leaq 0x1(%rcx), %rcx
ja 0x3175b
cmpl %ecx, 0x64(%rsp)
jle 0x3179d
sarq $0x20, %rax
movq 0x68(%rsp), %rdx
movq -0x8(%r12,%rdx,8), %rsi
movq %rsi, (%r12,%rdx,8)
movsd -0x8(%r13,%rdx,8), %xmm1
movsd %xmm1, (%r13,%rdx,8)
leaq -0x1(%rdx), %rsi
movq %rsi, %rdx
cmpq %rax, %rsi
jg 0x3177a
movq %r15, (%r12,%rcx,8)
movsd %xmm0, (%r13,%rcx,8)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x316f5
movq %r13, %rdi
callq 0x3a180
movq %r12, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x0, (%rsi)
testq %rdi, %rdi
je 0x31842
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x2f33a
movl %eax, %ebp
movslq (%rbx), %r12
movl $0x0, %eax
testq %r12, %r12
jle 0x31814
xorl %eax, %eax
cmpl (%r15,%rax,4), %ebp
je 0x31814
incq %rax
cmpq %rax, %r12
jne 0x31804
jmp 0x31819
cmpl %r12d, %eax
jne 0x31837
leaq 0x1(%r12), %rdx
movl %edx, (%rbx)
leaq 0x4(,%r12,4), %rsi
movq %r15, %rdi
callq 0x3a0b4
movq %rax, %r15
movl %ebp, (%rax,%r12,4)
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x317eb
jmp 0x31845
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %ebx
movq %rsi, %r14
movq %rdi, %r15
movslq %edx, %r13
leaq (,%r13,8), %rdi
leaq 0x7733b(%rip), %rsi     # 0xa8bee
movl $0x5, %edx
callq 0x3a0e1
movq %rax, %r12
movq %r13, (%rsp)
testl %r13d, %r13d
jle 0x31968
movl %ebx, %ecx
leal 0x1(%rbx), %eax
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl %eax
shlq $0x4, %rax
movdqa 0x74b53(%rip), %xmm1    # 0xa6440
xorl %ecx, %ecx
movdqa 0x74b59(%rip), %xmm2    # 0xa6450
pxor %xmm2, %xmm0
movabsq $0x43e0000000000000, %rdx # imm = 0x43E0000000000000
pcmpeqd %xmm3, %xmm3
movdqa 0x74b7f(%rip), %xmm4    # 0xa6490
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x31947
movq %rdx, (%r12,%rcx)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x3195b
movq %rdx, 0x8(%r12,%rcx)
paddq %xmm4, %xmm1
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x31911
testq %r15, %r15
je 0x319e3
decl %ebx
movslq %ebx, %rbp
movabsq $0x100000000, %r13      # imm = 0x100000000
movq %r15, %rdi
movq %r14, %rsi
callq 0x2fe29
movsd (%r12,%rbp,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x319da
movq $-0x1, %rcx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %r13, %rax
ucomisd 0x8(%r12,%rcx,8), %xmm0
leaq 0x1(%rcx), %rcx
ja 0x319a4
cmpl %ecx, %ebx
jle 0x319d4
sarq $0x20, %rax
movq %rbp, %rdx
movsd -0x8(%r12,%rdx,8), %xmm1
movsd %xmm1, (%r12,%rdx,8)
decq %rdx
cmpq %rax, %rdx
jg 0x319bf
movsd %xmm0, (%r12,%rcx,8)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x3197c
movq (%rsp), %rax
movsd -0x8(%r12,%rax,8), %xmm0
movsd %xmm0, (%rsp)
movq %r12, %rdi
callq 0x3a180
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x3b, %esi
callq 0x4220
testq %rax, %rax
jne 0x31a9f
movq %rbx, %rdi
movl $0x2d, %esi
callq 0x4220
testq %rax, %rax
jne 0x31a9f
movq %rbx, %rdi
callq 0x3a938
testl %eax, %eax
je 0x31b8a
leaq 0x77e41(%rip), %rsi     # 0xa98e7
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rcx
callq 0x3b4c1
cmpl $0x0, (%r14)
jle 0x31b75
xorl %ebp, %ebp
leaq 0x77514(%rip), %r14     # 0xa8fe2
xorl %r15d, %r15d
movq 0x10(%rsp,%rbp,8), %rsi
leaq 0x1f50(%rsp), %r12
movq %r12, %rdi
callq 0x4270
movq %r12, %rdi
movq %r14, %rsi
callq 0x4280
movq %rax, %r13
movl $0x10, %edi
leaq 0x77105(%rip), %rsi     # 0xa8c05
movl $0xc, %edx
callq 0x3a0e1
movq %rax, %r12
movq $0x0, 0x8(%rax)
movq %r13, %rdi
callq 0x4200
movl %eax, (%r12)
xorl %edi, %edi
movq %r14, %rsi
callq 0x4280
testq %rax, %rax
je 0x31b3a
movq %rax, %rdi
callq 0x4200
jmp 0x31b3e
movl (%r12), %eax
movl %eax, 0x4(%r12)
movq %r12, %r13
testq %rbp, %rbp
je 0x31b52
movq %r12, 0x8(%r15)
movq %rbx, %r13
movq 0x10(%rsp,%rbp,8), %rdi
callq 0x3a180
incq %rbp
movslq 0xc(%rsp), %rax
movq %r12, %r15
movq %r13, %rbx
cmpq %rax, %rbp
jl 0x31ad1
jmp 0x31b75
movq %r13, %rax
addq $0x7c078, %rsp          # imm = 0x7C078
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r13d, %r13d
jmp 0x31b75
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1bc40
leaq 0x3804e2(%rip), %r14    # 0x3b2090
movq %rax, (%r14)
movq %rsp, %rdi
callq 0x4340
movl %eax, %edi
callq 0x3af63
movq 0xa2431(%rip), %r15     # 0xd3ff8
movq (%r15), %rax
leaq 0x3804d7(%rip), %r12    # 0x3b20a8
movq %rax, (%r12)
leaq 0x77044(%rip), %rdi     # 0xa8c20
callq 0x4090
xorl %eax, %eax
callq 0x2e51a
xorl %eax, %eax
callq 0xe50d
xorl %eax, %eax
callq 0xe8b5
leaq 0x3804b3(%rip), %r13    # 0x3b20b0
movq %rax, (%r13)
xorl %eax, %eax
callq 0x54de3
leaq 0xa3c59(%rip), %rdi     # 0xd5868
leaq 0xa38ee(%rip), %rsi     # 0xd5504
callq 0x33cca
leaq 0x76ff4(%rip), %rdi     # 0xa8c16
leaq 0x79d32(%rip), %rsi     # 0xab95b
callq 0x40f0
testq %rax, %rax
je 0x31c57
movq %rax, %rdi
callq 0x42a0
leaq 0x76fd4(%rip), %rdi     # 0xa8c16
callq 0x33ed1
testl %eax, %eax
je 0x31c57
leaq 0x76fc4(%rip), %rdi     # 0xa8c16
callq 0x630b6
cmpl $0x2, %ebp
jl 0x31c72
movq 0x8(%rbx), %rdi
callq 0x33ed1
testl %eax, %eax
je 0x31c72
movq 0x8(%rbx), %rdi
callq 0x630b6
xorl %eax, %eax
callq 0x5da04
leaq 0xa38a8(%rip), %rbx     # 0xd5528
movq (%rbx), %rdi
callq 0xe16c
testl %eax, %eax
je 0x31c9c
movl %eax, %edi
callq 0x634e9
xorl %eax, %eax
callq 0x5da04
jmp 0x31c80
movq (%r12), %rdi
cmpq (%r15), %rdi
je 0x31caa
callq 0x42a0
xorl %eax, %eax
callq 0x5520f
movq (%r13), %rdi
callq 0xea41
xorl %eax, %eax
callq 0x6e05f
movq (%r14), %rdi
callq 0x1bc9f
leaq 0x76f7f(%rip), %rdi     # 0xa8c4f
callq 0x4090
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, (%rcx)
movl %edx, %r13d
testl %edx, %edx
jle 0x31d41
leaq 0xa3b5a(%rip), %rdx     # 0xd5870
movl $0x30f08, %eax          # imm = 0x30F08
addq (%rdx), %rax
movl $0x1, %edx
xorl %esi, %esi
movslq (%r14,%rsi,4), %rdi
imulq $0x340, %rdi, %rdi      # imm = 0x340
imull 0x18(%rax,%rdi), %edx
movl %edx, (%rcx)
incq %rsi
cmpq %rsi, %r13
jne 0x31d25
jmp 0x31d46
movl $0x1, %edx
leaq 0x76f17(%rip), %r8      # 0xa8c64
movl $0x8, %edi
movl $0x4, %esi
movl $0x2, %ecx
movl $0x7, %r9d
callq 0x3a231
movq %rax, %r12
testq %r15, %r15
je 0x31dd9
movq %r15, %rdi
callq 0x2f33a
testl %ebp, %ebp
jle 0x31dc3
movq (%r15), %rcx
leaq 0xa3aeb(%rip), %rdx     # 0xd5870
movq (%rdx), %rdx
movl $0x30f08, %esi          # imm = 0x30F08
addq %rsi, %rdx
xorl %esi, %esi
movl $0x1, %edi
xorl %r8d, %r8d
movslq (%r14,%rsi,4), %r9
movl (%rcx,%r9,8), %r10d
imull %edi, %r10d
addl %r10d, %r8d
imulq $0x340, %r9, %r9        # imm = 0x340
imull 0x18(%rdx,%r9), %edi
incq %rsi
cmpq %rsi, %r13
jne 0x31d9a
movslq %r8d, %rcx
jmp 0x31dc5
xorl %ecx, %ecx
xorl %edx, %edx
cmpl %ebx, %eax
setne %dl
movq (%r12,%rcx,8), %rax
incl (%rax,%rdx,4)
movq 0x10(%r15), %r15
jmp 0x31d6a
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x39416
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 0x31deb
movl (%r12), %esi
movq %rbp, %rdi
callq 0x399cb
testl %eax, %eax
jne 0x31fb3
movq %rbp, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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 0x39416
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 0x39416
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 0x31deb
movl 0x4(%r12), %esi
movq 0x10(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x3206b
movq 0x10(%rsp), %rdi
callq 0x3a180
movl (%r12), %esi
movq 0x8(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x32057
movq 0x8(%rsp), %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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 0x39416
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 0x39416
movq %rax, 0x18(%rsp)
movq %rax, 0x58(%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edi
callq 0x39416
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 0x31deb
movl 0x8(%rbp), %esi
movq 0x20(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x3215e
movq 0x20(%rsp), %rdi
callq 0x3a180
movq 0x8(%rsp), %rax
movl 0x4(%rax), %esi
movq 0x18(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x32147
movq 0x18(%rsp), %rdi
callq 0x3a180
movq 0x8(%rsp), %rax
movl (%rax), %esi
movq 0x10(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x32130
movq 0x10(%rsp), %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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 0x39416
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 0x39416
movq %rax, 0x20(%rsp)
movq %rax, 0x68(%rsp)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edi
callq 0x39416
movq %rax, 0x28(%rsp)
movq %rax, 0x70(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %edi
callq 0x39416
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 0x31deb
movl 0xc(%rbp), %esi
movq 0x30(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x32290
movq 0x30(%rsp), %rdi
callq 0x3a180
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x28(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x32279
movq 0x28(%rsp), %rdi
callq 0x3a180
movq 0x10(%rsp), %rax
movl 0x4(%rax), %esi
movq 0x20(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x32262
movq 0x20(%rsp), %rdi
callq 0x3a180
movq 0x10(%rsp), %rax
movl (%rax), %esi
movq 0x18(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x3224b
movq 0x18(%rsp), %rdi
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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 $0x98, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x7693b(%rip), %rdi     # 0xa8c98
callq 0x54920
movl %eax, %r12d
movslq %eax, %r15
leaq (,%r15,8), %rdi
leaq 0x7692d(%rip), %rsi     # 0xa8ca4
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %rbx
testl %r15d, %r15d
jle 0x3244f
movl %r12d, 0x7c(%rsp)
movl %r12d, %eax
movq %rax, 0x80(%rsp)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorpd %xmm0, %xmm0
xorl %r13d, %r13d
movq %r14, %r12
movl %ebp, %r14d
movsd %xmm0, 0x88(%rsp)
leaq 0x1(%r13), %rbp
movq %r12, %rdi
movl %ebp, %esi
movl %r14d, %edx
leaq 0x90(%rsp), %rcx
callq 0x3246f
movq %rax, (%rbx,%r13,8)
movsd 0x90(%rsp), %xmm0
movsd 0x88(%rsp), %xmm1
ucomisd %xmm1, %xmm0
cmoval %r13d, %r15d
maxsd %xmm1, %xmm0
movq %rbp, %r13
cmpq %rbp, 0x80(%rsp)
jne 0x323b0
cmpl $0x0, 0x7c(%rsp)
movq 0x80(%rsp), %r12
jle 0x32440
movl %r15d, %r14d
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x32438
movq (%rbx,%r13,8), %rsi
movl $0xe, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
callq 0x7c1f4
movq (%rbx,%r13,8), %rdi
callq 0x3a180
incq %r13
cmpq %r13, %r12
jne 0x32416
cmpl $-0x1, %r15d
je 0x3244f
movslq %r15d, %rax
movq (%rbx,%rax,8), %r14
jmp 0x32452
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x3a180
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movslq 0x40(%rsp), %rbp
movl %ebp, (%rdi)
leaq (,%rbp,4), %r12
leaq 0x7654c(%rip), %r15     # 0xa8cf0
movq %r12, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r13
movq %rax, 0x10(%rbx)
movq %r12, %rdi
movq %r15, %rsi
movl $0x5, %edx
callq 0x3a0e1
movq %rax, %r14
movq %rax, 0x8(%rbx)
leaq (,%rbp,8), %rdi
movq %r15, %rsi
movl $0x6, %edx
callq 0x3a0e1
movq %rax, %r15
movq %rbx, (%rsp)
movq %rax, 0x18(%rbx)
movq 0x50(%rsp), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x4310
movq 0x48(%rsp), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x4310
testq %rbp, %rbp
jle 0x32873
leaq 0x40(%rsp), %rax
movq 0x18(%rax), %rbx
xorl %r12d, %r12d
leaq 0xa3046(%rip), %rax     # 0xd5870
movq (%rax), %rax
movslq (%r14,%r12,4), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movslq 0x30f20(%rax,%rcx), %r13
shlq $0x2, %r13
movq %r13, %rdi
leaq 0x764a2(%rip), %rsi     # 0xa8cf0
movl $0xc, %edx
callq 0x3a0e1
movq %rax, (%r15,%r12,8)
movq (%rbx,%r12,8), %rsi
movq %rax, %rdi
movq %r13, %rdx
callq 0x4310
incq %r12
cmpq %r12, %rbp
jne 0x32823
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_O3/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 0x39416
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 0x3293f
movl (%r13), %esi
movq %rbx, %rdi
callq 0x399cb
testl %eax, %eax
jne 0x328f7
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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 0x39416
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 0x39416
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 0x3293f
movl 0x4(%r13), %esi
movq 0x10(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x32c31
movq 0x10(%rsp), %rdi
callq 0x3a180
movl (%r13), %esi
movq 0x8(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x32c1e
movq 0x8(%rsp), %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/ktree.c
// Function: find_best_discrete_split_3
void find_best_discrete_split_3(Korderingsplit* ksplit, int* rangelist, int* iter, int** featurecounts, int* nodecounts, 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_split(ksplit, perm, rangelist, iter, featurecounts, nodecounts, 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 %r9, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x8(%rsp)
movl (%rsi), %edi
callq 0x39416
leaq 0x50(%rsp), %r14
movq %rax, 0x10(%rsp)
movq %rax, (%r14)
movq 0x40(%rsp), %r15
movq 0x38(%rsp), %r12
movq 0x30(%rsp), %rbp
movq 0x28(%rsp), %r13
movq 0x8(%rsp), %rbx
movq 0x8(%rsp), %rax
movl 0x4(%rax), %edi
callq 0x39416
movq %rax, 0x18(%rsp)
movq %rax, 0x58(%rsp)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edi
callq 0x39416
movq %rax, 0x20(%rsp)
movq %rax, 0x60(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0x3293f
movl 0x8(%rbx), %esi
movq 0x20(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x32d1b
movq 0x20(%rsp), %rdi
callq 0x3a180
movq 0x8(%rsp), %rax
movl 0x4(%rax), %esi
movq 0x18(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x32d04
movq 0x18(%rsp), %rdi
callq 0x3a180
movq 0x8(%rsp), %rax
movl (%rax), %esi
movq 0x10(%rsp), %rdi
callq 0x399cb
testl %eax, %eax
jne 0x32ced
movq 0x10(%rsp), %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180