LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x45bff
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x43530
cmpl -0x1c(%rbp), %eax
jne 0x45bcd
cmpq $0x0, -0x38(%rbp)
jne 0x45bb7
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x45bc3
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x45bf5
cmpq $0x0, -0x40(%rbp)
jne 0x45be1
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x45bed
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x45b82
cmpq $0x0, -0x38(%rbp)
je 0x45c12
movq -0x38(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x40(%rbp)
je 0x45c25
movq -0x40(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xbfa0d(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x9f888(%rip), %rsi     # 0xe56cd
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
leaq 0xbf9e6(%rip), %rax     # 0x105840
movq (%rax), %rax
movslq 0x10(%rax), %rdi
movl $0x8, %esi
leaq 0x9f860(%rip), %rdx     # 0xe56cd
movl $0x4, %ecx
callq 0x52f40
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x45ef4
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x43530
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x45ec6
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x45eda
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x45e86
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq 0xbf93b(%rip), %rcx     # 0x105840
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
jge 0x45f3d
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x45f30
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq $0x0, 0x10(%rax)
jmp 0x45f32
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x45efb
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rdi
callq 0x52e80
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x1, -0x48(%rbp)
movl $0x1, -0x4c(%rbp)
movl $0x0, -0x44(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x4d(%rbp)
je 0x46177
movl -0x44(%rbp), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x4d(%rbp)
movb -0x4d(%rbp), %al
testb $0x1, %al
jne 0x46183
jmp 0x4623d
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
movslq -0x44(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x461d3
cmpl $0x0, -0x4c(%rbp)
je 0x461b1
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4c(%rbp)
jmp 0x461bd
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x46238
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
movslq -0x44(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x4622f
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0x46212
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x48(%rbp)
jmp 0x46227
cmpq $0x0, -0x38(%rbp)
je 0x46225
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x46227
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x4615f
cmpq $0x0, -0x30(%rbp)
je 0x46250
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpl $0x0, -0x4c(%rbp)
je 0x46263
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
jmp 0x46278
cmpq $0x0, -0x40(%rbp)
je 0x46276
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x46278
movq -0x20(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x46520
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x465cd
jmp 0x46522
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x41(%rbp)
je 0x46539
cmpq $0x0, -0x30(%rbp)
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x46542
jmp 0x465b2
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x46568
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x465ad
cmpq $0x0, -0x38(%rbp)
je 0x4657d
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x46585
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x46522
cmpq $0x0, -0x28(%rbp)
jne 0x465c5
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x449f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movslq (%rax), %rdi
shlq $0x2, %rdi
leaq 0x9f0d3(%rip), %rsi     # 0xe56ee
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x46660
movq -0x28(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x46630
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x46711
leaq 0xbf19c(%rip), %rax     # 0x105840
movq (%rax), %rax
movq 0x1407210(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x42c40
movq -0x40(%rbp), %rax
cvttsd2si %xmm0, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x42c40
movq -0x38(%rbp), %rax
cvttsd2si %xmm0, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x46703
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x46696
movq -0x18(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
leaq 0x9efec(%rip), %rsi     # 0xe570f
movl $0xa, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x467d0
leaq 0xbf0ee(%rip), %rax     # 0x105840
movq (%rax), %rax
movq 0x1407210(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x42c40
movq -0x50(%rbp), %rax
cvttsd2si %xmm0, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x42c40
movq -0x48(%rbp), %rax
cvttsd2si %xmm0, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x467bf
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x46740
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x46c35
movq -0x28(%rbp), %rdi
callq 0x43530
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x46be2
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x46bd5
jmp 0x46be2
jmp 0x46bd7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x46bb8
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x46c24
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
shlq $0x2, %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
callq 0x52d10
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x46b9a
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/instancelist.c
// Function: data_x
Instanceptr data_x(Instanceptr myptr, int index)
{
 Instanceptr tmp = myptr;
 int i = 0;
 while (tmp)
   if (index == i)
     return tmp;
   else
    {
     i++;
     tmp = tmp->next;
    }
 return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x46c8a
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jne 0x46c73
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x46c92
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x46c5a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/instancelist.c
// Function: last_element_of_list
Instanceptr last_element_of_list(Instanceptr list)
{
 /*!Last Changed 18.03.2004*/
 Instanceptr tmp;
 tmp = list;
 if (!tmp)
   return NULL;
 while (tmp->next)
   tmp = tmp->next;
 return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x46cc1
movq $0x0, -0x8(%rbp)
jmp 0x46ce4
jmp 0x46cc3
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x46cdc
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x46cc3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x9ea10(%rip), %rsi     # 0xe5722
movl $0x5, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x46d4f
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd 0x9c271(%rip), %xmm0    # 0xe2fb0
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x46d27
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x46e19
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x442e0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm1
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x46e08
movl $0x0, -0x34(%rbp)
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x46dbb
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x46d98
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jle 0x46df6
movq -0x28(%rbp), %rax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x46dc4
movsd -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x46d57
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x52e80
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/interval.c
// Function: free_intervals
void free_intervals(Intervalptr intervals)
{
 /*!Last Changed 09.05.2005*/
 Intervalptr tmp, myptr = intervals;
 if (myptr)
  {
   while (myptr)
    {
     tmp = myptr->next;
     safe_free(myptr);
     myptr = tmp;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x46e95
jmp 0x46e6d
cmpq $0x0, -0x18(%rbp)
je 0x46e93
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x46e6d
jmp 0x46e95
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/interval.c
// Function: interval_length
int interval_length(Intervalptr interval)
{
 /*!Last Changed 22.12.2006*/
 int result = 0;
 Intervalptr tmp = interval;
 while (tmp)
  {
   result += tmp->max - tmp->min + 1;
   tmp = tmp->next;
  } 
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x46ee2
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
addl $0x1, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x46eb7
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/interval.c
// Function: is_in_interval
BOOLEAN is_in_interval(Intervalptr interval, int fno)
{
 /*!Last Changed 09.05.2005*/
 Intervalptr tmp;
 tmp = interval;
 while (tmp)
  {
   if (fno >= tmp->min && fno <= tmp->max)
     return BOOLEAN_TRUE;
   tmp = tmp->next;
  }
 return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x46f38
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x46f2a
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x46f2a
movl $0x1, -0x4(%rbp)
jmp 0x46f3f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x46f03
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x7c0a0, %rsp          # imm = 0x7C0A0
movq %rdi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3b, %esi
callq 0x41d0
cmpq $0x0, %rax
jne 0x46faa
movq -0x10(%rbp), %rdi
movl $0x2d, %esi
callq 0x41d0
cmpq $0x0, %rax
jne 0x46faa
movq -0x10(%rbp), %rdi
callq 0x53bd0
cmpl $0x0, %eax
jne 0x46faa
movq $0x0, -0x8(%rbp)
jmp 0x470c5
movq -0x10(%rbp), %rdi
leaq -0x7c0a0(%rbp), %rdx
leaq 0x9f4ee(%rip), %rsi     # 0xe64aa
leaq -0x30(%rbp), %rcx
callq 0x54bf0
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x470bd
leaq -0x7a160(%rbp), %rdi
movslq -0x2c(%rbp), %rax
movq -0x7c0a0(%rbp,%rax,8), %rsi
callq 0x4220
leaq -0x7a160(%rbp), %rdi
leaq 0x9eb84(%rip), %rsi     # 0xe5b82
callq 0x4230
movq %rax, -0x38(%rbp)
movl $0x10, %edi
leaq 0x9e726(%rip), %rsi     # 0xe5739
movl $0xc, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x38(%rbp), %rdi
callq 0x41c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
movl %eax, %edi
leaq 0x9eb39(%rip), %rsi     # 0xe5b82
callq 0x4230
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4706d
movq -0x38(%rbp), %rdi
callq 0x41c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x4707a
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
cmpl $0x0, -0x2c(%rbp)
je 0x4708e
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x47096
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0x2c(%rbp), %rax
movq -0x7c0a0(%rbp,%rax,8), %rdi
callq 0x52e80
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x46fcc
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x7c0a0, %rsp          # imm = 0x7C0A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x47309
leaq 0xbe56d(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movq -0x10(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl 0x18(%rax), %ecx
movq -0x20(%rbp), %rax
imull (%rax), %ecx
movl %ecx, (%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x472c4
movq -0x20(%rbp), %rax
movl (%rax), %edx
movl $0x8, %edi
movl $0x4, %esi
movl $0x2, %ecx
leaq 0x9e477(%rip), %r8      # 0xe579c
movl $0x7, %r9d
callq 0x52fa0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x47406
movq -0x48(%rbp), %rdi
callq 0x43530
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x473c3
movl -0x34(%rbp), %eax
movq -0x48(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rdx
movslq -0x28(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
imull (%rcx,%rdx,8), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq 0xbe4b1(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movq -0x10(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl 0x18(%rax), %eax
imull -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x47360
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jne 0x473e0
movq -0x40(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x473f5
movq -0x40(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x47334
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x51c90
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x47410
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x476d3
movq -0x38(%rbp), %rdi
callq 0x52e80
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x51c90
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x51c90
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x47410
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x47763
movq -0x38(%rbp), %rdi
callq 0x52e80
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x47753
movq -0x40(%rbp), %rdi
callq 0x52e80
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x51c90
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x51c90
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x51c90
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x47410
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x47823
movq -0x40(%rbp), %rdi
callq 0x52e80
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x47813
movq -0x48(%rbp), %rdi
callq 0x52e80
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x47803
movq -0x50(%rbp), %rdi
callq 0x52e80
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x51c90
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x51c90
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x51c90
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x51c90
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x47410
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x47913
movq -0x38(%rbp), %rdi
callq 0x52e80
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x47903
movq -0x40(%rbp), %rdi
callq 0x52e80
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x478f3
movq -0x48(%rbp), %rdi
callq 0x52e80
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x478e3
movq -0x50(%rbp), %rdi
callq 0x52e80
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
leaq 0x9dde8(%rip), %rdi     # 0xe57d0
callq 0x78f10
movl %eax, -0x3c(%rbp)
movslq -0x3c(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x9dddd(%rip), %rsi     # 0xe57dc
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x47a6a
movq -0x8(%rbp), %rdi
movl -0x38(%rbp), %esi
addl $0x1, %esi
movl -0xc(%rbp), %edx
leaq -0x20(%rbp), %rcx
callq 0x47b20
movq %rax, %rdx
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movsd -0x20(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x47a5d
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x47a5f
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x47a14
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x47ae9
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
je 0x47adc
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movups 0x60(%rcx), %xmm0
movq %rsp, %rax
movups %xmm0, 0x60(%rax)
movups 0x50(%rcx), %xmm0
movups %xmm0, 0x50(%rax)
movups 0x40(%rcx), %xmm0
movups %xmm0, 0x40(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups 0x30(%rcx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xadc90
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x52e80
jmp 0x47ade
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x47a71
cmpl $-0x1, -0x34(%rbp)
je 0x47b01
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
jmp 0x47b09
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x52e80
movq -0x30(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movl %eax, (%rdi)
movslq (%rdi), %rdi
shlq $0x2, %rdi
leaq 0x9d92b(%rip), %rsi     # 0xe5818
movl $0x4, %edx
callq 0x52d70
movq -0x10(%rbp), %rdi
movq %rax, 0x10(%rdi)
movslq (%rdi), %rdi
shlq $0x2, %rdi
leaq 0x9d90b(%rip), %rsi     # 0xe5818
movl $0x5, %edx
callq 0x52d70
movq -0x10(%rbp), %rdi
movq %rax, 0x8(%rdi)
movslq (%rdi), %rdi
shlq $0x3, %rdi
leaq 0x9d8eb(%rip), %rsi     # 0xe5818
movl $0x6, %edx
callq 0x52d70
movq -0x18(%rbp), %rcx
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq %rdx, 0x18(%rax)
movq 0x10(%rax), %rdi
movq 0x10(%rcx), %rsi
movslq (%rax), %rdx
shlq $0x2, %rdx
callq 0x42b0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rcx), %rsi
movslq (%rax), %rdx
shlq $0x2, %rdx
callq 0x42b0
movl $0x0, -0x4(%rbp)
movq -0x10(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl (%rcx), %eax
jge 0x4801f
movq -0x10(%rbp), %rcx
leaq 0xbd8a9(%rip), %rax     # 0x105840
movq (%rax), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movq 0x8(%rcx), %rcx
movslq -0x4(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl 0x18(%rax), %eax
movl %eax, -0x8(%rbp)
movslq -0x8(%rbp), %rdi
shlq $0x2, %rdi
leaq 0x9d84d(%rip), %rsi     # 0xe5818
movl $0xc, %edx
callq 0x52d70
movq -0x10(%rbp), %rcx
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rcx), %rdx
movslq -0x4(%rbp), %rsi
movq %rdi, (%rdx,%rsi,8)
movq 0x18(%rcx), %rcx
movslq -0x4(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x18(%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movslq -0x8(%rbp), %rdx
shlq $0x2, %rdx
callq 0x42b0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x47f7d
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/ktree.c
// Function: create_kordering_condition
Decisioncondition create_kordering_condition(Korderingsplit ksplit, char comparison)
{
 Decisioncondition rule;
 rule.featureindex = DISCRETEMIX;
 rule.ksplit = copy_of_korderingsplit(ksplit);
	rule.comparison = comparison;
 return rule;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movb %sil, %cl
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movb %cl, -0x1(%rbp)
movl $0xfffffffb, (%rdi)     # imm = 0xFFFFFFFB
leaq -0x28(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x47ec0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x50(%rdi)
movq -0x20(%rbp), %rcx
movq %rcx, 0x58(%rdi)
movq -0x18(%rbp), %rcx
movq %rcx, 0x60(%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x68(%rdi)
movb -0x1(%rbp), %cl
movb %cl, 0x4(%rdi)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x51c90
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
movq %rax, (%rsp)
callq 0x48140
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x480ef
movq -0x38(%rbp), %rdi
callq 0x52e80
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x51c90
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x51c90
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
movq %rax, (%rsp)
callq 0x48140
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x4845f
movq -0x38(%rbp), %rdi
callq 0x52e80
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x4844f
movq -0x40(%rbp), %rdi
callq 0x52e80
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x51c90
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x51c90
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x51c90
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
movq %rax, (%rsp)
callq 0x48140
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x4851f
movq -0x40(%rbp), %rdi
callq 0x52e80
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x4850f
movq -0x48(%rbp), %rdi
callq 0x52e80
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x484ff
movq -0x50(%rbp), %rdi
callq 0x52e80
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/ktree.c
// Function: find_best_discrete_split_4
void find_best_discrete_split_4(Korderingsplit* ksplit, int* rangelist, int* iter, int** featurecounts, int* nodecounts, 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_split(ksplit, perm, rangelist, iter, featurecounts, nodecounts, 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x51c90
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x51c90
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x51c90
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x51c90
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
movq %rax, (%rsp)
callq 0x48140
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x4860f
movq -0x38(%rbp), %rdi
callq 0x52e80
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x485ff
movq -0x40(%rbp), %rdi
callq 0x52e80
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x485ef
movq -0x48(%rbp), %rdi
callq 0x52e80
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x524e0
cmpl $0x0, %eax
jne 0x485df
movq -0x50(%rbp), %rdi
callq 0x52e80
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)