LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: bootstrap_sample_without_stratification
Instanceptr bootstrap_sample_without_stratification(Instanceptr list)
{
 /*!Last Changed 19.02.2005*/
 int size, *array, i;
 Instanceptr* instancearray, result, tmp, newinstance, current;
 size = data_size(list);
 array = bootstrap_array(size);
 instancearray = create_array_of_instances(list);
 result = copy_of_instance(instancearray[array[0]]);
 current = result;
 for (i = 1; i < size; i++)
  {
   tmp = instancearray[array[i]];
   newinstance = copy_of_instance(tmp);
   current->next = newinstance;
   current = newinstance;
  }
 safe_free(instancearray);
 safe_free(array);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x2ff01
movq %r14, %rax
incl %ebp
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x2fef6
movl %ebp, %edi
callq 0x39e8c
movq %rax, %rbx
movq %r14, %rdi
callq 0x2fe52
movq %rax, %r14
movslq (%rbx), %rax
movq (%r14,%rax,8), %rdi
callq 0x2e4db
movq %rax, %r15
cmpl $0x2, %ebp
jl 0x2ff52
movl %ebp, %r12d
movl $0x1, %r13d
movq %r15, %rbp
movslq (%rbx,%r13,4), %rax
movq (%r14,%rax,8), %rdi
callq 0x2e4db
movq %rax, 0x10(%rbp)
incq %r13
movq %rax, %rbp
cmpq %r13, %r12
jne 0x2ff36
movq %r14, %rdi
callq 0x39194
movq %rbx, %rdi
callq 0x39194
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_O1/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_according_partition
void divide_instancelist_according_partition(Instanceptr* parentlist, Instanceptr* list1, Instanceptr* list2, Partition p)
{
 /* Last Changed 21.09.2004*/
 int i = 0, *classassignments, classno;
 Instanceptr ptmp, pnext, next1 = NULL, next2 = NULL;
 classassignments = find_class_assignments(p);
 ptmp = (*parentlist);
 while (ptmp)
  {
   pnext = ptmp->next;
   classno = give_classno(ptmp);
   if (classassignments[classno] == LEFT)
    {
     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;
 safe_free(classassignments);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x5442f
movq %rax, %rdi
movq %rbx, 0x18(%rsp)
movq (%rbx), %r13
testq %r13, %r13
je 0x3000d
xorl %ebp, %ebp
xorl %ebx, %ebx
movq 0x10(%r13), %rax
movq %rax, 0x20(%rsp)
movq %r15, %r12
movq %rdi, %r15
movq %r13, %rdi
callq 0x2eaca
movq %r15, %rdi
movq %r12, %r15
cltq
cmpl $0x0, (%rdi,%rax,4)
movq %rbp, %rax
cmoveq %rbx, %rax
movq %r12, %rcx
cmoveq %r14, %rcx
cmoveq %r13, %rbx
cmovneq %r13, %rbp
leaq 0x10(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq %r13, (%rdx)
movq 0x20(%rsp), %rax
movq %rax, %r13
testq %rax, %rax
jne 0x2ffb7
jmp 0x30011
xorl %ebx, %ebx
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x3001e
movq $0x0, 0x10(%rbx)
testq %rbp, %rbp
je 0x3002b
movq $0x0, 0x10(%rbp)
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_according_to_soft_split
void divide_instancelist_according_to_soft_split(Instanceptr* parentlist, Instanceptr* list1, Instanceptr* list2, matrix w)
{
 Instanceptr ptmp, pnext, next1 = NULL, next2 = NULL;
 *list1 = NULL;
 *list2 = NULL;
 ptmp = (*parentlist);
 while (ptmp)
 {
  pnext = ptmp->next;
  if (linear_fit_value(w, ptmp) > 0)
   {
    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
xorl %r14d, %r14d
movq %r14, (%rsi)
movq %r14, (%rdx)
movq %rdi, (%rsp)
movq (%rdi), %rbp
movl $0x0, %ebx
testq %rbp, %rbp
je 0x300da
movq %r8, %r12
movq %rdx, %r13
movq %rsi, %r15
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %rcx, 0x8(%rsp)
movq 0x10(%rbp), %rax
movq %rax, 0x10(%rsp)
movq %rcx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x75608
ucomisd 0x72c64(%rip), %xmm0    # 0xa2d08
movq %rbx, %rax
cmovaq %r14, %rax
movq %r13, %rcx
cmovaq %r15, %rcx
cmovaq %rbp, %r14
cmovbeq %rbp, %rbx
leaq 0x10(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq 0x8(%rsp), %rcx
movq %rbp, (%rdx)
movq 0x10(%rsp), %rax
movq %rax, %rbp
testq %rax, %rax
jne 0x30085
testq %r14, %r14
je 0x300e7
movq $0x0, 0x10(%r14)
testq %rbx, %rbx
je 0x300f4
movq $0x0, 0x10(%rbx)
movq (%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_according_centers
void divide_instancelist_according_centers(Instanceptr* parentlist, Instanceptr* list1, Instanceptr* list2, Instanceptr leftcenter, Instanceptr rightcenter, int quadratic)
{
 /*!Last Changed 03.04.2005*/
 /*!Last Changed 24.03.2005*/
 Instanceptr ptmp, pnext, next1 = NULL, next2 = NULL;
 CHILD_TYPE result;
 *list1 = NULL;
 *list2 = NULL;
 ptmp = (*parentlist);
 while (ptmp)
  {
   pnext = ptmp->next;
   if (quadratic)
     result = nearest_center_in_regression_tree(ptmp, QUADRATIC, leftcenter, rightcenter);
   else
     result = nearest_center_in_regression_tree(ptmp, LINEAR, leftcenter, rightcenter);
   if (result == LEFTCHILD)
    {
     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 $0x28, %rsp
xorl %r14d, %r14d
movq %r14, (%rsi)
movq %r14, (%rdx)
movq %rdi, 0x10(%rsp)
movq (%rdi), %rbp
movl $0x0, %r15d
testq %rbp, %rbp
je 0x301ac
movq %r8, %r13
movq %rdx, %rbx
movq %rsi, %r12
cmpl $0x1, %r9d
movl $0x0, %eax
adcl $-0x3, %eax
movl %eax, 0xc(%rsp)
xorl %r15d, %r15d
movq %rcx, 0x18(%rsp)
movq 0x10(%rbp), %rax
movq %rax, 0x20(%rsp)
movq %rbp, %rdi
movl 0xc(%rsp), %esi
movq %rcx, %rdx
movq %r13, %rcx
callq 0x74bac
testl %eax, %eax
movq %r15, %rax
cmoveq %r14, %rax
movq %rbx, %rcx
cmoveq %r12, %rcx
cmoveq %rbp, %r14
cmovneq %rbp, %r15
leaq 0x10(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq 0x18(%rsp), %rcx
movq %rbp, (%rdx)
movq 0x20(%rsp), %rax
movq %rax, %rbp
testq %rax, %rax
jne 0x30159
testq %r14, %r14
je 0x301b9
movq $0x0, 0x10(%r14)
testq %r15, %r15
je 0x301c6
movq $0x0, 0x10(%r15)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_according_to_split
void divide_instancelist_according_to_split(Instanceptr* parentlist, Instanceptr* list1, Instanceptr* list2, int fno, double split)
{
 /*!Last Changed 09.12.2004*/
 Instanceptr ptmp, pnext, next1 = NULL, next2 = NULL;
 ptmp = (*parentlist);
 while (ptmp)
  {
   pnext = ptmp->next;
   if (ptmp->values[fno].floatvalue <= split)
    {
     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 %r14
pushq %rbx
movq (%rdi), %r8
testq %r8, %r8
je 0x30232
movslq %ecx, %rcx
xorl %eax, %eax
xorl %r10d, %r10d
movq (%r8), %r9
ucomisd (%r9,%rcx,8), %xmm0
movq %rsi, %r11
cmovbq %rdx, %r11
movq 0x10(%r8), %rbx
movq %r8, %r9
cmovbq %r10, %r9
cmovbq %rax, %r10
cmovbq %r8, %rax
leaq 0x10(%r10), %r14
testq %r10, %r10
cmoveq %r11, %r14
movq %r8, (%r14)
movq %r9, %r10
movq %rbx, %r8
testq %rbx, %rbx
jne 0x301f4
jmp 0x30237
xorl %r9d, %r9d
xorl %eax, %eax
testq %r9, %r9
je 0x30244
movq $0x0, 0x10(%r9)
testq %rax, %rax
je 0x30251
movq $0x0, 0x10(%rax)
movq $0x0, (%rdi)
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_one_vs_one_with_copy
void divide_instancelist_one_vs_one_with_copy(Instanceptr parentlist, Instanceptr* list, int positive, int negative)
{
 Instanceptr tmp, inst, next = NULL;
 tmp = parentlist;
 while (tmp)
  {
   if (give_classno(tmp) == positive)
    {
     inst = copy_of_instance(tmp);
     inst->values[current_dataset->classdefno].stringindex = 0;
     if (!next)
       *list = inst;
     else
       next->next = inst;
     next = inst;
    }
   else
     if (give_classno(tmp) == negative)
      {
       inst = copy_of_instance(tmp);
       inst->values[current_dataset->classdefno].stringindex = 1;
       if (!next)
         *list = inst;
       else
         next->next = inst;
       next = inst;
      }
   tmp = tmp->next;
  }
 if (next)
   next->next = NULL;
 else
   *list = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x302f8
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0xa25eb(%rip), %r12     # 0xd2870
movq %r15, %rdi
callq 0x2eaca
movq %r15, %rdi
cmpl %r14d, %eax
jne 0x302b1
callq 0x2e4db
movq (%rax), %rcx
movq (%r12), %rdx
movslq 0x1407128(%rdx), %rdx
movl $0x0, (%rcx,%rdx,8)
jmp 0x302d7
callq 0x2eaca
cmpl %ebp, %eax
jne 0x302e7
movq %r15, %rdi
callq 0x2e4db
movq (%rax), %rcx
movq (%r12), %rdx
movslq 0x1407128(%rdx), %rdx
movl $0x1, (%rcx,%rdx,8)
testq %r13, %r13
je 0x302e2
movq %rax, 0x10(%r13)
jmp 0x302ea
movq %rax, (%rbx)
jmp 0x302ea
movq %r13, %rax
movq 0x10(%r15), %r15
movq %rax, %r13
testq %r15, %r15
jne 0x30285
jmp 0x302fa
xorl %eax, %eax
leaq 0x10(%rax), %rcx
testq %rax, %rax
cmoveq %rbx, %rcx
movq $0x0, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/instancelist.c
// Function: divide_instancelist_one_vs_one
void divide_instancelist_one_vs_one(Instanceptr* parentlist, Instanceptr* list, int positive, int negative)
{
 Instanceptr ptmp, pnext, next1 = NULL, next = NULL;
 ptmp = (*parentlist);
 while (ptmp)
  {
   pnext = ptmp->next;
   if (give_classno(ptmp) == positive)
    {
     if (!next1)
       *list = ptmp;
     else
       next1->next = ptmp;
     next1 = ptmp;
    }
   else
     if (give_classno(ptmp) == negative)
      {
       if (!next1)
         *list = ptmp;
       else
         next1->next = ptmp;
       next1 = ptmp;
      }
     else
      {
       if (!next)
         *parentlist = ptmp;
       else
         next->next = ptmp;
       next = ptmp;
      }
   ptmp = pnext;
  }
 if (next1)
   next1->next = NULL;
 if (next)
   next->next = NULL;
 else
   *parentlist = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movq %rdi, 0x10(%rsp)
movq (%rdi), %r12
testq %r12, %r12
je 0x303a4
movl %edx, %r14d
movq %rsi, %r15
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x10(%r12), %rbx
movq %r12, %rdi
callq 0x2eaca
cmpl %r14d, %eax
jne 0x3035f
movq %r15, %rcx
movq %r12, %rax
jmp 0x30389
movq %r12, %rdi
callq 0x2eaca
cmpl 0xc(%rsp), %eax
movq %r13, %rdx
cmoveq %rbp, %rdx
movq 0x10(%rsp), %rcx
cmoveq %r15, %rcx
movq %rbp, %rax
cmoveq %r12, %rax
cmovneq %r12, %r13
movq %rdx, %rbp
leaq 0x10(%rbp), %rdx
testq %rbp, %rbp
cmoveq %rcx, %rdx
movq %r12, (%rdx)
movq %rax, %rbp
movq %rbx, %r12
testq %rbx, %rbx
jne 0x30345
jmp 0x303a9
xorl %eax, %eax
xorl %r13d, %r13d
testq %rax, %rax
je 0x303b6
movq $0x0, 0x10(%rax)
leaq 0x10(%r13), %rax
testq %r13, %r13
cmoveq 0x10(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, 0x8(%rsp)
movq (%rdi), %r12
testq %r12, %r12
je 0x304d6
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %rbp
xorl %r13d, %r13d
xorl %ebx, %ebx
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movq %r12, %rdi
callq 0x2eaca
cmpl %r14d, %eax
movq %r13, %rax
cmoveq %rbx, %rax
movq %r15, %r8
cmoveq %rbp, %r8
cmoveq %r12, %rbx
cmovneq %r12, %r13
leaq 0x10(%rax), %rdi
testq %rax, %rax
cmoveq %r8, %rdi
movq %r12, (%rdi)
movq 0x10(%rsp), %rax
movq %rax, %r12
testq %rax, %rax
jne 0x3048e
jmp 0x304db
xorl %ebx, %ebx
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x304e8
movq $0x0, 0x10(%rbx)
testq %r13, %r13
je 0x304f5
movq $0x0, 0x10(%r13)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x755d0(%rip), %r12     # 0xa5b02
movq %r12, %rsi
movl $0x3, %edx
callq 0x390f5
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
movq %r12, %rdx
movl $0x4, %ecx
callq 0x39210
movq %rax, %r14
leaq 0xa230f(%rip), %rax     # 0xd2870
movq (%rax), %rax
xorl %r12d, %r12d
cmpl $0x0, 0x10(%rax)
jle 0x30586
movq (%r15), %rdi
callq 0x116b3
movq %rax, (%rsp)
movq (%r15), %rdi
callq 0x115e1
movq %rax, %r13
jmp 0x30591
xorl %r13d, %r13d
movq $0x0, (%rsp)
movq (%r15), %rax
testq %rax, %rax
je 0x305a8
xorl %r12d, %r12d
incl %r12d
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x3059c
leaq 0xa22c1(%rip), %rax     # 0xd2870
movq (%rax), %rax
movl 0x10(%rax), %edx
movq (%rsp), %rdi
movl %r12d, %esi
movq %r13, %rcx
callq 0x2f14d
movq %rax, %r12
movq (%r15), %rsi
testq %rsi, %rsi
je 0x30604
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 0x305d2
testl %ebp, %ebp
jle 0x30625
movl %ebp, %eax
xorl %ecx, %ecx
movq (%r14,%rcx,8), %rdx
testq %rdx, %rdx
je 0x3061d
movq $0x0, 0x10(%rdx)
incq %rcx
cmpq %rcx, %rax
jne 0x3060c
movq $0x0, (%r15)
leaq 0xa223d(%rip), %rax     # 0xd2870
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x3064d
movq %r13, %rdi
callq 0x39194
movq (%rsp), %rdi
callq 0x39194
movq %r12, %rdi
callq 0x39194
movq %r14, %rdi
callq 0x39194
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_O1/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 0xa21ec(%rip), %r13     # 0xd2870
movq (%r13), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x7548a(%rip), %r15     # 0xa5b21
movq %r15, %rsi
movl $0x3, %edx
callq 0x390f5
movq %rax, %r14
movq (%r13), %rax
movslq 0x10(%rax), %rdi
movl $0x8, %esi
movq %r15, %rdx
movl $0x4, %ecx
callq 0x39210
movq %rax, %r15
movq (%rbx), %r12
testq %r12, %r12
je 0x306fd
movq 0x10(%r12), %rbp
movq %r12, %rdi
callq 0x2eaca
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 0x306cc
movq (%r13), %rax
movslq 0x10(%rax), %rax
testq %rax, %rax
jle 0x30725
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
testq %rdx, %rdx
je 0x3071d
movq $0x0, 0x10(%rdx)
incq %rcx
cmpq %rcx, %rax
jne 0x3070c
movq $0x0, (%rbx)
movq %r15, %rdi
callq 0x39194
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_O1/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, %r12d
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0xa210c(%rip), %rax     # 0xd2870
movq (%rax), %rax
xorl %r14d, %r14d
cmpl $0x0, 0x10(%rax)
jle 0x30789
movq (%rbx), %rdi
callq 0x116b3
movq %rax, (%rsp)
movq (%rbx), %rdi
callq 0x115e1
movq %rax, %r15
jmp 0x30794
xorl %r15d, %r15d
movq $0x0, (%rsp)
movq (%rbx), %rax
testq %rax, %rax
je 0x307ab
xorl %r14d, %r14d
incl %r14d
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x3079f
leaq 0xa20be(%rip), %rax     # 0xd2870
movq (%rax), %rax
movl 0x10(%rax), %edx
movq (%rsp), %rdi
movl %r14d, %esi
movq %r15, %rcx
callq 0x2f14d
movq %rax, %r14
movq (%rbx), %r8
testq %r8, %r8
je 0x3081d
leal -0x1(%r12), %edi
xorl %ecx, %ecx
movq %r14, %r9
xorl %esi, %esi
movq 0x10(%r8), %r10
movl (%r9), %eax
cltd
idivl %r12d
cmpl %edi, %edx
movq %rcx, %rax
cmoveq %rsi, %rax
movq %r13, %rdx
cmoveq %rbp, %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 0x307de
jmp 0x30821
xorl %esi, %esi
xorl %ecx, %ecx
testq %rsi, %rsi
je 0x3082e
movq $0x0, 0x10(%rsi)
testq %rcx, %rcx
je 0x3083b
movq $0x0, 0x10(%rcx)
movq $0x0, (%rbx)
leaq 0xa2027(%rip), %rax     # 0xd2870
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
jle 0x30863
movq %r15, %rdi
callq 0x39194
movq (%rsp), %rdi
callq 0x39194
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/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), %r9
testq %r9, %r9
sete %al
testl %esi, %esi
setle %r8b
xorl %ecx, %ecx
orb %al, %r8b
jne 0x3091d
movl $0x1, %r10d
movl $0x1, %ebp
xorl %r8d, %r8d
xorl %r11d, %r11d
xorl %ebx, %ebx
movq %r9, %r14
xorl %eax, %eax
movslq %ecx, %r9
movl (%rdi,%r9,4), %r9d
cmpl %r9d, 0x18(%r14)
jge 0x308d8
addq $0x10, %r8
testl %r10d, %r10d
cmovneq %rdx, %r8
movq %r14, (%r8)
movq 0x10(%r14), %r9
xorl %r10d, %r10d
movq %r14, %r8
jmp 0x30909
jne 0x308ea
movq 0x10(%r14), %r9
xorl %r15d, %r15d
testl %ebp, %ebp
je 0x308f5
movq %r14, %rax
jmp 0x308fe
movq %r14, %r9
movq %rbx, %r14
movl %ebp, %r15d
jmp 0x30901
testq %r11, %r11
je 0x308fe
movq %r14, 0x10(%r11)
movq %r14, %r11
incl %ecx
movq %r14, %rbx
movl %r15d, %ebp
testq %r9, %r9
je 0x30915
movq %r9, %r14
cmpl %esi, %ecx
jl 0x308b1
testl %r10d, %r10d
sete %cl
jmp 0x30924
xorl %eax, %eax
xorl %ebx, %ebx
xorl %r8d, %r8d
testq %rbx, %rbx
je 0x30931
movq $0x0, 0x10(%rbx)
testb %cl, %cl
je 0x30940
testq %r8, %r8
je 0x30947
movq %r9, 0x10(%r8)
jmp 0x30947
movq $0x0, (%rdx)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x30b38
movq %rdi, %rax
testq %rsi, %rsi
je 0x30b3c
xorl %ecx, %ecx
movq %rsi, %rdi
movq %rax, %r8
movl 0x18(%r8), %edx
cmpl 0x18(%rdi), %edx
jge 0x30aff
movq 0x10(%r8), %r9
movq %rdi, %rdx
movq %r8, %rcx
jmp 0x30b1f
movq %rsi, %r9
testq %rcx, %rcx
je 0x30b0e
movq %rdi, 0x10(%rcx)
movq %rax, %r9
movq 0x10(%rdi), %rdx
movq %r8, 0x10(%rdi)
movq %r9, %rax
movq %r8, %r9
movq %rdi, %rcx
testq %r9, %r9
je 0x30b2f
movq %rdx, %rdi
movq %r9, %r8
testq %rdx, %rdx
jne 0x30aea
testq %r9, %r9
sete %dil
jmp 0x30b43
movq %rsi, %rax
retq
xorl %edi, %edi
movq %rsi, %rdx
xorl %ecx, %ecx
testb %dil, %dil
je 0x30b3b
movq %rdx, 0x10(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x30b66
movq %rbx, %rcx
incl %eax
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x30b5b
movl %eax, (%rsi)
movslq %eax, %rdi
shlq $0x2, %rdi
leaq 0x74fcc(%rip), %rsi     # 0xa5b42
movl $0x4, %edx
callq 0x390f5
testq %rbx, %rbx
je 0x30b9a
movq %rax, %rcx
movl 0x18(%rbx), %edx
movl %edx, (%rcx)
movq 0x10(%rbx), %rbx
addq $0x4, %rcx
testq %rbx, %rbx
jne 0x30b88
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %r14
movl $0x0, (%rdx)
testq %rdi, %rdi
je 0x30c16
leaq 0xa1cae(%rip), %r13     # 0xd2870
movq %r14, %r12
movq (%r13), %rax
movq 0x1407210(%rax), %rax
movq 0x8(%rax), %rbp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2e4b6
cvttsd2si %xmm0, %eax
cltq
movq (%rbp,%rax,8), %rbp
movq %r12, %rdi
xorl %esi, %esi
callq 0x2e4b6
cvttsd2si %xmm0, %eax
cltq
movsd (%rbp,%rax,8), %xmm0
ucomisd 0x72101(%rip), %xmm0    # 0xa2d08
jbe 0x30c0c
incl (%r15)
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x30bc5
movslq (%r15), %rdi
shlq $0x3, %rdi
leaq 0x74f3f(%rip), %rsi     # 0xa5b63
movl $0xa, %edx
callq 0x390f5
movq %rax, %r15
testq %r14, %r14
je 0x30c97
xorl %r12d, %r12d
leaq 0xa1c30(%rip), %r13     # 0xd2870
movq (%r13), %rax
movq 0x1407210(%rax), %rax
movq 0x8(%rax), %rbp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2e4b6
cvttsd2si %xmm0, %eax
cltq
movq (%rbp,%rax,8), %rbp
movq %r14, %rdi
xorl %esi, %esi
callq 0x2e4b6
cvttsd2si %xmm0, %eax
cltq
movsd (%rbp,%rax,8), %xmm0
ucomisd 0x72086(%rip), %xmm0    # 0xa2d08
jbe 0x30c8e
movslq %r12d, %r12
movq %r14, (%r15,%r12,8)
incl %r12d
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x30c40
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_O1/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 0x74ea6(%rip), %rbp     # 0xa5b76
movq %r13, %rdi
movq %rbp, %rsi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r12
movq %r13, %rdi
movq %rbp, %rsi
movl $0x5, %edx
callq 0x390f5
movq %rax, %r13
testl %ebx, %ebx
jle 0x30d1f
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 0x30d0a
testq %r15, %r15
je 0x30dbc
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 0x2f4ea
movsd (%r13,%rbp,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x30db3
movq $-0x1, %rcx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %rbx, %rax
ucomisd 0x8(%r13,%rcx,8), %xmm0
leaq 0x1(%rcx), %rcx
ja 0x30d68
cmpl %ecx, 0x4(%rsp)
jle 0x30da8
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 0x30d85
movq %r15, (%r12,%rcx,8)
movsd %xmm0, (%r13,%rcx,8)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x30d3f
movq %r13, %rdi
callq 0x39194
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_O1/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 0x74d75(%rip), %rbp     # 0xa5b76
movq %r13, %rdi
movq %rbp, %rsi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r12
movq %r13, %rdi
movq %rbp, %rsi
movl $0x5, %edx
callq 0x390f5
movq %rax, %r13
testl %ebx, %ebx
jle 0x30e4f
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 0x30e3a
testq %r15, %r15
je 0x30f42
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 0x2f2e5
movq 0x68(%rsp), %rax
movsd (%r13,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x30f35
movq $-0x1, %rcx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %r14, %rax
ucomisd 0x8(%r13,%rcx,8), %xmm0
leaq 0x1(%rcx), %rcx
ja 0x30ee8
cmpl %ecx, 0x64(%rsp)
jle 0x30f2a
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 0x30f07
movq %r15, (%r12,%rcx,8)
movsd %xmm0, (%r13,%rcx,8)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x30e82
movq %r13, %rdi
callq 0x39194
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_O1/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 0x30fd6
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x2eaca
movl %eax, %ebp
movslq (%rbx), %rax
movl $0x0, %r12d
testq %rax, %rax
jle 0x30fa6
movl %eax, %ecx
xorl %r12d, %r12d
cmpl (%r15,%r12,4), %ebp
je 0x30fa6
incq %r12
cmpq %r12, %rcx
jne 0x30f95
movl %ecx, %r12d
cmpl %eax, %r12d
jne 0x30fcb
leaq 0x1(%rax), %rdx
movl %edx, (%rbx)
leaq 0x4(,%rax,4), %rsi
movq %r15, %rdi
callq 0x390c8
movq %rax, %r15
movl %r12d, %eax
movl %ebp, (%r15,%rax,4)
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x30f78
jmp 0x30fd9
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x74b3d(%rip), %rsi     # 0xa5b76
movl $0x5, %edx
callq 0x390f5
movq %rax, %r12
movq %r13, (%rsp)
testl %r13d, %r13d
jle 0x31069
movl %ebx, %eax
xorl %ecx, %ecx
movabsq $0x43e0000000000000, %rdx # imm = 0x43E0000000000000
movq %rdx, (%r12,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x3105d
testq %r15, %r15
je 0x310e4
decl %ebx
movslq %ebx, %rbp
movabsq $0x100000000, %r13      # imm = 0x100000000
movq %r15, %rdi
movq %r14, %rsi
callq 0x2f4ea
movsd (%r12,%rbp,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x310db
movq $-0x1, %rcx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %r13, %rax
ucomisd 0x8(%r12,%rcx,8), %xmm0
leaq 0x1(%rcx), %rcx
ja 0x310a5
cmpl %ecx, %ebx
jle 0x310d5
sarq $0x20, %rax
movq %rbp, %rdx
movsd -0x8(%r12,%rdx,8), %xmm1
movsd %xmm1, (%r12,%rdx,8)
decq %rdx
cmpq %rax, %rdx
jg 0x310c0
movsd %xmm0, (%r12,%rcx,8)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x3107d
movq (%rsp), %rax
movsd -0x8(%r12,%rax,8), %xmm0
movsd %xmm0, (%rsp)
movq %r12, %rdi
callq 0x39194
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3119f
movq %rbx, %rdi
movl $0x2d, %esi
callq 0x4220
testq %rax, %rax
jne 0x3119f
movq %rbx, %rdi
callq 0x3992c
testl %eax, %eax
je 0x3128a
leaq 0x75713(%rip), %rsi     # 0xa68b9
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rcx
callq 0x3a431
cmpl $0x0, (%r14)
jle 0x31275
xorl %ebp, %ebp
leaq 0x74de4(%rip), %r14     # 0xa5fb2
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 0x7498d(%rip), %rsi     # 0xa5b8d
movl $0xc, %edx
callq 0x390f5
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 0x3123a
movq %rax, %rdi
callq 0x4200
jmp 0x3123e
movl (%r12), %eax
movl %eax, 0x4(%r12)
movq %r12, %r13
testq %rbp, %rbp
je 0x31252
movq %r12, 0x8(%r15)
movq %rbx, %r13
movq 0x10(%rsp,%rbp,8), %rdi
callq 0x39194
incq %rbp
movslq 0xc(%rsp), %rax
movq %r12, %r15
movq %r13, %rbx
cmpq %rax, %rbp
jl 0x311d1
jmp 0x31275
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 0x31275
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1b5c4
leaq 0x37dde2(%rip), %r14    # 0x3af090
movq %rax, (%r14)
movq %rsp, %rdi
callq 0x4340
movl %eax, %edi
callq 0x39f5b
movq 0x9fd31(%rip), %r15     # 0xd0ff8
movq (%r15), %rax
leaq 0x37ddd7(%rip), %r12    # 0x3af0a8
movq %rax, (%r12)
leaq 0x748cc(%rip), %rdi     # 0xa5ba8
callq 0x4090
xorl %eax, %eax
callq 0x2dc68
xorl %eax, %eax
callq 0xe473
xorl %eax, %eax
callq 0xe827
leaq 0x37ddb3(%rip), %r13    # 0x3af0b0
movq %rax, (%r13)
xorl %eax, %eax
callq 0x538ec
leaq 0xa1559(%rip), %rdi     # 0xd2868
leaq 0xa11ee(%rip), %rsi     # 0xd2504
callq 0x33309
leaq 0x7487c(%rip), %rdi     # 0xa5b9e
leaq 0x77566(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x31357
movq %rax, %rdi
callq 0x42a0
leaq 0x7485c(%rip), %rdi     # 0xa5b9e
callq 0x33510
testl %eax, %eax
je 0x31357
leaq 0x7484c(%rip), %rdi     # 0xa5b9e
callq 0x619fb
cmpl $0x2, %ebp
jl 0x31372
movq 0x8(%rbx), %rdi
callq 0x33510
testl %eax, %eax
je 0x31372
movq 0x8(%rbx), %rdi
callq 0x619fb
xorl %eax, %eax
callq 0x5c4f0
leaq 0xa11a8(%rip), %rbx     # 0xd2528
movq (%rbx), %rdi
callq 0xe0e0
testl %eax, %eax
je 0x3139c
movl %eax, %edi
callq 0x61e3f
xorl %eax, %eax
callq 0x5c4f0
jmp 0x31380
movq (%r12), %rdi
cmpq (%r15), %rdi
je 0x313aa
callq 0x42a0
xorl %eax, %eax
callq 0x53d18
movq (%r13), %rdi
callq 0xe9c9
xorl %eax, %eax
callq 0x6c9af
movq (%r14), %rdi
callq 0x1b623
leaq 0x74807(%rip), %rdi     # 0xa5bd7
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_O1/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 0x3143c
leaq 0xa145a(%rip), %rdx     # 0xd2870
movl $0x30f08, %eax          # imm = 0x30F08
addq (%rdx), %rax
movl (%rcx), %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 0x31422
movl (%rcx), %edx
leaq 0x747a7(%rip), %r8      # 0xa5bec
movl $0x8, %edi
movl $0x4, %esi
movl $0x2, %ecx
movl $0x7, %r9d
callq 0x39245
movq %rax, %r12
testq %r15, %r15
je 0x314d1
movq %r15, %rdi
callq 0x2eaca
testl %ebp, %ebp
jle 0x314bb
movq (%r15), %rcx
leaq 0xa13f3(%rip), %rdx     # 0xd2870
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 0x31492
movslq %r8d, %rcx
jmp 0x314bd
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 0x31462
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_O1/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 0x3873a
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 0x314e3
movl (%r12), %esi
movq %rbp, %rdi
callq 0x38c67
testl %eax, %eax
jne 0x316ab
movq %rbp, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/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 0x3873a
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 0x3873a
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 0x314e3
movl 0x4(%r12), %esi
movq 0x10(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x31763
movq 0x10(%rsp), %rdi
callq 0x39194
movl (%r12), %esi
movq 0x8(%rsp), %rdi
callq 0x38c67
testl %eax, %eax
jne 0x3174f
movq 0x8(%rsp), %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194