LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmisc.c
// Function: findmincounts
int* findmincounts(char** names, int count)
{
 /*!Last Changed 25.01.2005*/
 int i, j, length, *result = safecalloc(count, sizeof(int), "findmincounts", 1);
 double** data, min;
 FILE* infile;
 length = file_length(names[0]);
 data = (double**) safemalloc_2d(sizeof(double*), sizeof(double), count, length, "findmincounts", 5);
 for (i = 0; i < count; i++)
  {
   infile = fopen(names[i], "r");
   if (!infile)
    {
     printf(m1274, names[i]);
     return NULL;
    }
   for (j = 0; j < length; j++)
     fscanf(infile, "%lf", &(data[i][j]));
   fclose(infile);
  }
 for (j = 0; j < length; j++)
  {
   min = data[0][j];
   for (i = 1; i < count; i++)
     if (data[i][j] < min)
       min = data[i][j];
   for (i = 0; i < count; i++)
     if (data[i][j] == min)
       (result[i])++;
  }
 free_2d((void**)data, count);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r12
movslq %esi, %r14
leaq 0x644d0(%rip), %r15     # 0x99982
pushq $0x4
popq %rsi
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0x35067
movq %rax, 0x20(%rsp)
movq %r12, 0x8(%rsp)
movq (%r12), %rdi
callq 0x33f62
movl %eax, %r13d
pushq $0x8
popq %rdi
pushq $0x5
popq %r9
movq %rdi, %rsi
movl %r14d, %edx
movl %eax, %ecx
movq %r15, %r8
callq 0x351c3
movq %rax, %r15
xorl %eax, %eax
testl %r13d, %r13d
cmovlel %eax, %r13d
movq %r14, 0x18(%rsp)
testl %r14d, %r14d
movl $0x0, %r12d
movl %ebx, 0x4(%rsp)
cmovgl %ebx, %r12d
movq %r13, 0x10(%rsp)
leaq (,%r13,8), %rbx
xorl %r14d, %r14d
cmpq %r12, %r14
je 0x3557b
movq 0x8(%rsp), %rax
movq (%rax,%r14,8), %rdi
leaq 0x66348(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x355ec
movq %rax, %rbp
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x3556e
movq (%r15,%r14,8), %rdx
addq %r13, %rdx
movq %rbp, %rdi
leaq 0x64647(%rip), %rsi     # 0x99ba8
xorl %eax, %eax
callq 0x4070
addq $0x8, %r13
jmp 0x3554b
movq %rbp, %rdi
callq 0x42a0
incq %r14
jmp 0x35522
movl 0x10(%rsp), %eax
xorl %ecx, %ecx
pushq $0x1
popq %rdx
movq 0x20(%rsp), %rbx
movq 0x18(%rsp), %r8
cmpq %rax, %rcx
je 0x355de
movq (%r15), %rsi
movsd (%rsi,%rcx,8), %xmm0
movq %rdx, %rsi
cmpq %r8, %rsi
jge 0x355b9
movq (%r15,%rsi,8), %rdi
movsd (%rdi,%rcx,8), %xmm1
minsd %xmm0, %xmm1
incq %rsi
movapd %xmm1, %xmm0
jmp 0x3559e
xorl %esi, %esi
cmpq %rsi, %r12
je 0x355d9
movq (%r15,%rsi,8), %rdi
movsd (%rdi,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x355d4
jp 0x355d4
incl (%rbx,%rsi,4)
incq %rsi
jmp 0x355bb
incq %rcx
jmp 0x3558e
movq %r15, %rdi
movl 0x4(%rsp), %esi
callq 0x34fc3
jmp 0x35605
movq 0x8(%rsp), %rax
movq (%rax,%r14,8), %rsi
leaq 0x60c0e(%rip), %rdi     # 0x9620a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4030
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmisc.c
// Function: sort_two_arrays
void sort_two_arrays(double* array1, int* array2, int size)
{
 /*!Last Changed 21.10.2004*/
 int i, j, tmpi;
 double tmp;
 for (i = 0; i < size; i++)
   for (j = i + 1; j < size; j++)
     if (array1[i] > array1[j])
      {
       tmpi = array2[i];
       array2[i] = array2[j];
       array2[j] = tmpi;
       tmp = array1[i];
       array1[i] = array1[j];
       array1[j] = tmp;
      }
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
pushq $0x1
popq %r8
cmpq %rcx, %rax
je 0x3566d
movq %r8, %r9
cmpl %edx, %r9d
jge 0x35665
movsd (%rdi,%rax,8), %xmm0
movsd (%rdi,%r9,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x35660
movl (%rsi,%rax,4), %r10d
movl (%rsi,%r9,4), %r11d
movl %r11d, (%rsi,%rax,4)
movl %r10d, (%rsi,%r9,4)
movsd %xmm1, (%rdi,%rax,8)
movsd %xmm0, (%rdi,%r9,8)
incq %r9
jmp 0x3562f
incq %rax
incq %r8
jmp 0x35627
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmisc.c
// Function: isfloat
int isfloat(char* st)
{
 /*!Last Changed 29.09.2004 added - sign*/
 /*!Last Changed 29.01.2004*/
 int i, len = strlen(st);
 for (i = 0; i < len; i++)
   if ((st[i] < '0' || st[i] > '9') && st[i] != '.' && st[i] != '-' && st[i] != 'E' && st[i] != 'e' && st[i] != '+')
     return 0;
 return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4190
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
pushq $0x1
popq %rsi
movabsq $0x40000000400000d, %rdi # imm = 0x40000000400000D
cmpq %rdx, %rax
je 0x356c4
movzbl (%rbx,%rdx), %r8d
leal -0x3a(%r8), %ecx
cmpb $-0xb, %cl
ja 0x356bf
xorl %ecx, %ecx
addl $-0x2b, %r8d
cmpl $0x3a, %r8d
ja 0x356c6
btq %r8, %rdi
jae 0x356c6
incq %rdx
jmp 0x3569a
movl %esi, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmisc.c
// Function: atoi_check
int atoi_check(char* st, int* value, int min, int max)
{
 /*!Last Changed 25.07.2006*/
 int tmp;
 if (isinteger(st))
  {
   tmp = atoi(st);
   if (tmp < min)
    {
     printf(m1405, tmp, min);
     return NO;
    }
   else
     if (tmp > max)
      {
       printf(m1406, tmp, max);
       return NO;
      }
     else
      {
       *value = tmp;
       return YES;
      }
  }
 else
   printf(m1341, st);
 return NO;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
callq 0x356ca
testl %eax, %eax
je 0x3574f
movq %r12, %rdi
callq 0x4200
cmpl %r14d, %eax
jge 0x35764
leaq 0x6424a(%rip), %rdi     # 0x99990
xorl %ebp, %ebp
movl %eax, %esi
movl %r14d, %edx
jmp 0x35775
leaq 0x642dd(%rip), %rdi     # 0x99a33
xorl %ebp, %ebp
movq %r12, %rsi
xorl %eax, %eax
callq 0x4030
jmp 0x35784
cmpl %ebx, %eax
jle 0x3577e
leaq 0x64273(%rip), %rdi     # 0x999e2
xorl %ebp, %ebp
movl %eax, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4030
jmp 0x35784
movl %eax, (%r15)
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmisc.c
// Function: atof_check
int atof_check(char* st, double* value, double min, double max)
{
 /*!Last Changed 25.07.2006*/
 double tmp;
 if (isfloat(st))
  {
   tmp = atof(st);
   if (tmp < min)
    {
     printf(m1407, tmp, min);
     return NO;
    }
   else
     if (tmp > max)
      {
       printf(m1408, tmp, max);
       return NO;
      }
     else
      {
       *value = tmp;
       return YES;
      }
  }
 else
   printf(m1340, st);
 return NO;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3567d
testl %eax, %eax
je 0x357ce
movq %r14, %rdi
callq 0x4130
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x357e3
leaq 0x6427d(%rip), %rdi     # 0x99a49
jmp 0x357f6
leaq 0x6431f(%rip), %rdi     # 0x99af4
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x4030
jmp 0x35808
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x35801
leaq 0x642a9(%rip), %rdi     # 0x99a9f
movb $0x2, %al
callq 0x4030
xorl %ebx, %ebx
jmp 0x35808
movsd %xmm0, (%rbx)
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmisc.c
// Function: in_list
int in_list(int searchvalue, int count, ...)
{
 /*!Last Changed 29.08.2005*/
 int i, compvalue;
 va_list ap;
 va_start(ap, count);
 for (i = 0; i < count; i++)
  {
   compvalue = va_arg(ap, int);
   if (searchvalue == compvalue)
     return 1;
  }
 return 0;
}

// Assembly:
subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x35856
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %r10, -0x70(%rsp)
leaq 0x60(%rsp), %rdx
movq %rdx, -0x78(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x80(%rsp)
movl $0x10, %ecx
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
incl %esi
movl $0x1, %r8d
decl %esi
je 0x358b5
cmpl $0x28, %ecx
ja 0x358a2
movq %rdx, %r9
movl %ecx, %edx
addq %r10, %rdx
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x358ab
leaq 0x8(%rdx), %r9
movq %r9, -0x78(%rsp)
cmpl %edi, (%rdx)
movq %r9, %rdx
jne 0x35888
movl %r8d, %eax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmisc.c
// Function: checkparams
int checkparams(int paramcount, int must, ...)
{
 int i;
 char* line;
 va_list ap;
 va_start(ap, must);
 if (paramcount < must)
  {
   i=0;
   line = va_arg(ap,char *);
   while (i < paramcount)
    {
     line=va_arg(ap,char *);
     i++;
    }
   printf("%s",line);
   return 0;
  }
 return 1;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x35912
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r10, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
cmpl %esi, %edi
jge 0x35957
movl (%rsp), %eax
cmpq $0x28, %rax
ja 0x3595c
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rax, %rsi
addq %rcx, %rsi
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x3596f
pushq $0x1
popq %rbx
jmp 0x359b1
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
leaq 0x8(%rsi), %rdx
movq %rdx, 0x8(%rsp)
xorl %r8d, %r8d
testl %edi, %edi
cmovgl %edi, %r8d
subl $0x1, %r8d
jb 0x3599e
cmpl $0x28, %eax
ja 0x35990
movl %eax, %esi
addq %rcx, %rsi
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x35978
movq %rdx, %rsi
addq $0x8, %rdx
movq %rdx, 0x8(%rsp)
jmp 0x35978
movq (%rsi), %rsi
leaq 0x62528(%rip), %rdi     # 0x97ed0
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4030
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/librandom.c
// Function: bootstrap_array
int* bootstrap_array(int size)
{
 /*!Last Changed 19.02.2005*/
 int i, *result = safemalloc(size * sizeof(int), "bootstrap_array", 1);
 for (i = 0; i < size; i++)
   result[i] = myrand() % size;
 return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %edi, %r14
leaq (,%r14,4), %rdi
leaq 0x63ef4(%rip), %rsi     # 0x99b18
pushq $0x1
popq %rdx
callq 0x34f59
movq %rax, %rcx
xorl %esi, %esi
testl %r14d, %r14d
movl $0x0, %edi
cmovgl %ebx, %edi
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
cmpq %rsi, %rdi
je 0x35c74
movslq 0x97866(%rip), %rax     # 0xcd4b4
imulq $0x19660d, %rax, %rax   # imm = 0x19660D
addq $0x3c6ef35f, %rax       # imm = 0x3C6EF35F
xorl %edx, %edx
divq %r8
movq %rdx, %rax
movl %eax, 0x9784b(%rip)     # 0xcd4b4
cltd
idivl %ebx
movl %edx, (%rcx,%rsi,4)
incq %rsi
jmp 0x35c42
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/librandom.c
// Function: produce_random_value
double produce_random_value(double start, double end)
{
 /*!Last Changed 26.01.2005*/
 double part;
 long int x;
 x = myrand() % 10001;
 part = (end - start)/10000.0;
 return start + part * x;
}

// Assembly:
movslq 0x977ff(%rip), %rax     # 0xcd4b4
imulq $0x19660d, %rax, %rax   # imm = 0x19660D
addq $0x3c6ef35f, %rax       # imm = 0x3C6EF35F
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movl %eax, 0x977df(%rip)     # 0xcd4b4
movl $0x2711, %ecx           # imm = 0x2711
subsd %xmm0, %xmm1
divsd 0x63e2a(%rip), %xmm1    # 0x99b10
xorl %edx, %edx
divl %ecx
cvtsi2sd %edx, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/librandom.c
// Function: random_array
int *random_array(int size)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 31.10.2003*/
 int i,tmp,j;
 int *myarray;
 myarray = (int *) safemalloc(size * sizeof(int), "random_array", 3);
 for (i = 0; i < size; i++)
   myarray[i] = i;
 for (i = 0; i < size; i++)
  {
   j = myrand() % size;
   tmp = myarray[i];
   myarray[i] = myarray[j];
   myarray[j] = tmp;
  }
 return myarray;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %edi, %r14
leaq (,%r14,4), %rdi
leaq 0x63e19(%rip), %rsi     # 0x99b28
pushq $0x3
popq %rdx
callq 0x34f59
movq %rax, %rcx
xorl %eax, %eax
testl %r14d, %r14d
movl $0x0, %esi
cmovgl %ebx, %esi
cmpq %rax, %rsi
je 0x35d34
movl %eax, (%rcx,%rax,4)
incq %rax
jmp 0x35d27
xorl %edi, %edi
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
cmpq %rdi, %rsi
je 0x35d79
movslq 0x9776c(%rip), %rax     # 0xcd4b4
imulq $0x19660d, %rax, %rax   # imm = 0x19660D
addq $0x3c6ef35f, %rax       # imm = 0x3C6EF35F
xorl %edx, %edx
divq %r8
movq %rdx, %rax
movl %eax, 0x97751(%rip)     # 0xcd4b4
cltd
idivl %ebx
movl (%rcx,%rdi,4), %eax
movl (%rcx,%rdx,4), %r9d
movl %r9d, (%rcx,%rdi,4)
movl %eax, (%rcx,%rdx,4)
incq %rdi
jmp 0x35d3c
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/librandom.c
// Function: random_array_double
double* random_array_double(int size, double start, double end)
{
 /*!Last Changed 27.03.2006*/
 double* myarray;
 int i;
 myarray = (double *) safemalloc(size * sizeof(double), "random_identity_array", 2);
 for (i = 0; i < size; i++)
   myarray[i] = produce_random_value(start, end);
 return myarray;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movslq %edi, %r14
leaq (,%r14,8), %rdi
leaq 0x63d8b(%rip), %rsi     # 0x99b35
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %rbx
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x35ddf
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x35cae
movsd %xmm0, (%rbx,%r15,8)
incq %r15
jmp 0x35dbf
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/librandom.c
// Function: random_combination
BOOLEAN random_combination(int* combination, int size, int range)
{
 /*!Last Changed 19.03.2008*/
 int i;
 for (i = 0; i < size; i++)
   combination[i] = myrand() % (range + 1);
 return BOOLEAN_TRUE;
}

// Assembly:
movl %edx, %ecx
incl %ecx
xorl %r8d, %r8d
testl %esi, %esi
cmovlel %r8d, %esi
movl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
cmpq %r8, %rsi
je 0x35e32
movslq 0x976a9(%rip), %rax     # 0xcd4b4
imulq $0x19660d, %rax, %rax   # imm = 0x19660D
addq $0x3c6ef35f, %rax       # imm = 0x3C6EF35F
xorl %edx, %edx
divq %r9
movq %rdx, %rax
movl %eax, 0x9768e(%rip)     # 0xcd4b4
cltd
idivl %ecx
movl %edx, (%rdi,%r8,4)
incq %r8
jmp 0x35dff
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libstring.c
// Function: char_count
int char_count(char* st, char ch)
{
 /*!Last Changed 10.10.2004*/
 int result = 0, i, len = strlen(st);
 for (i = 0; i < len; i++)
   if (st[i] == ch)
     result++;
 return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x4190
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
xorl %ecx, %ecx
cmpq %rdx, %rax
je 0x35e91
xorl %esi, %esi
cmpb %bl, (%r14,%rdx)
sete %sil
addl %esi, %ecx
incq %rdx
jmp 0x35e7b
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libstring.c
// Function: instr
int instr(char* st, char* searchst)
{
 /*!Last Changed 19.01.2005 returns -1 if not found returns position if found*/
 /*!Last Changed 03.02.2004*/
 int i, j, len1, len2;
 if (!st || !searchst)
   return -1;
 len1 = strlen(st);
 len2 = strlen(searchst);
 for (i = 0; i < len1 - len2 + 1; i++)
  {
   for (j = 0; j < len2; j++)
     if (st[i + j] != searchst[j])
       break;
   if (j == len2)
     return i;
  }
 return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
pushq $-0x1
popq %rbx
orb %al, %cl
jne 0x35f09
movq %rsi, %r14
movq %rdi, %r15
callq 0x4190
movq %rax, %r12
movq %r14, %rdi
callq 0x4190
subl %eax, %r12d
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
movslq %r12d, %rsi
cmpq %rsi, %rcx
jg 0x35f09
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x35ef9
movb (%r15,%rdi), %r8b
cmpb (%r14,%rdi), %r8b
jne 0x35efb
incq %rdi
jmp 0x35ee5
movl %edx, %edi
cmpl %eax, %edi
je 0x35f07
incq %rcx
incq %r15
jmp 0x35ede
movl %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libstring.c
// Function: listindex
int listindex(char *element, char *array[], int elementcount)
{
 /*!Last Changed 10.04.2002*/
 int i;
 if (!element)
   return -2;
 for (i = 0; i < elementcount; i++)
   if (strIcmp(element, array[i]) == 0)
     return i;
 return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x35f52
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %ebx
pushq $-0x1
popq %rbp
cmpq %r12, %rbx
je 0x35f5a
movq (%r14,%r12,8), %rsi
movq %r15, %rdi
callq 0x35f65
testl %eax, %eax
je 0x35f57
incq %r12
jmp 0x35f38
pushq $-0x2
popq %rbp
jmp 0x35f5a
movl %r12d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libstring.c
// Function: strIcmp
int strIcmp(const char *s1, const char *s2)
{
/*!Last Changed 12.04.2002*/
 int len1=strlen(s1),len2=strlen(s2),i,min;
 if (len1<len2)
   min=len1;
 else
   min=len2;
 for (i=0;i<min;i++)
  {
   if (upper(s1[i])<upper(s2[i]))
     return -1;
   if (upper(s1[i])>upper(s2[i]))
     return 1;
  }
 if (len1<len2)
   return -1;
 if (len1>len2)
   return 1;
 return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4190
movq %rax, %r15
movq %rbx, %rdi
callq 0x4190
movq %rax, %rcx
cmpl %ecx, %r15d
movl %ecx, %edx
cmovll %r15d, %edx
xorl %esi, %esi
testl %edx, %edx
cmovlel %esi, %edx
pushq $-0x1
popq %rax
pushq $0x1
popq %rdi
cmpq %rsi, %rdx
je 0x35fe1
movzbl (%r14,%rsi), %r9d
leal -0x61(%r9), %r8d
leal -0x20(%r9), %r10d
cmpb $0x1a, %r8b
movzbl %r10b, %r8d
cmovael %r9d, %r8d
movzbl (%rbx,%rsi), %r10d
leal -0x61(%r10), %r9d
leal -0x20(%r10), %r11d
cmpb $0x1a, %r9b
movzbl %r11b, %r9d
cmovael %r10d, %r9d
cmpb %r9b, %r8b
jl 0x35fec
incq %rsi
cmpb %r9b, %r8b
jle 0x35f99
movl %edi, %eax
jmp 0x35fec
cmpl %ecx, %r15d
jl 0x35fec
setg %al
movzbl %al, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libstring.c
// Function: listindexc
int listindexc(char element, char array[], int elementcount)
{
 /*!Last Changed 03.01.2006*/
 int i;
 for (i = 0; i < elementcount; i++)
   if (element == array[i])
     return i;
 return -1;
}

// Assembly:
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
pushq $-0x1
popq %rax
cmpq %rcx, %rdx
je 0x3600e
cmpb %dil, (%rsi,%rcx)
je 0x3600c
incq %rcx
jmp 0x35ffc
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libstring.c
// Function: stringlist
void stringlist(char* st, char* separator, char* list[], int* count)
{
 /*!Last Changed 29.01.2004*/
 char* p;
 int c = 0;
 p = strtok(st, separator);
 while (p)
  {
   list[c] = strcopy(list[c], p);
   c++;
   p = strtok(NULL, separator);
  }
 *count = c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
xorl %r12d, %r12d
movq %r15, %rsi
callq 0x4280
testq %rax, %rax
je 0x360ab
movq %rax, %rsi
callq 0x3604c
movq %rax, (%r14,%r12,8)
incq %r12
xorl %edi, %edi
jmp 0x3608b
movl %r12d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_matrix
matrix load_matrix(FILE* infile, int size1, int size2)
{
 /*!Last Changed 25.12.2005*/
	matrix result;
	int i, j;
	result = matrix_alloc(size1, size2);
 for (i = 0; i < size1; i++)
		 for (j = 0; j < size2; j++)
				 fscanf(infile, "%lf", &(result.values[i][j]));
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movl %esi, %edi
movl %edx, %esi
callq 0x380d3
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
movq %rax, 0x8(%rsp)
testl %r14d, %r14d
cmovlel %ecx, %r14d
movq %r14, 0x10(%rsp)
movq %rdx, %r13
shlq $0x3, %rbx
leaq 0x63a97(%rip), %rbp     # 0x99ba8
xorl %r12d, %r12d
cmpq 0x10(%rsp), %r12
je 0x36143
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x3613e
movq (%r13,%r12,8), %rdx
addq %r14, %rdx
movq %r15, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %r14
jmp 0x3611e
incq %r12
jmp 0x36114
movq 0x8(%rsp), %rax
movq %r13, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_array
double* load_array(FILE* infile, int size)
{
 /*!Last Changed 22.12.2005*/
 int i;
 double* result;
 result = safemalloc(size * sizeof(double), "load_array", 3);
 for (i = 0; i < size; i++) 
   fscanf(infile, "%lf", &(result[i]));
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq %esi, %r12
leaq (,%r12,8), %rdi
leaq 0x639f0(%rip), %rsi     # 0x99b68
pushq $0x3
popq %rdx
callq 0x34f59
xorl %ecx, %ecx
testl %r12d, %r12d
cmovlel %ecx, %r12d
movq %rax, %r14
shlq $0x3, %r12
leaq 0x63a11(%rip), %r15     # 0x99ba8
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x361b6
leaq (%r14,%r13), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %r13
jmp 0x3619a
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_array_int
int* load_array_int(FILE* infile, int size)
{
 /*!Last Changed 22.12.2005*/
 int i, *result;
 result = safemalloc(size * sizeof(int), "load_array_int", 2);
 for (i = 0; i < size; i++) 
   fscanf(infile, "%d", &(result[i]));
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq %esi, %r12
leaq (,%r12,4), %rdi
leaq 0x63992(%rip), %rsi     # 0x99b73
pushq $0x2
popq %rdx
callq 0x34f59
xorl %ecx, %ecx
testl %r12d, %r12d
cmovlel %ecx, %r12d
movq %rax, %r14
shlq $0x2, %r12
leaq 0x6a959(%rip), %r15     # 0xa0b59
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x3621f
leaq (%r14,%r13), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x4, %r13
jmp 0x36203
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_array_two
double** load_array_two(FILE* infile, int size1, int size2)
{
 /*!Last Changed 25.12.2005*/
 int i, j;
 double** result;
 result = (double**) safemalloc_2d(sizeof(double*), sizeof(double), size1, size2, "load_array_two", 3);
 for (i = 0; i < size1; i++) 
		 for (j = 0; j < size2; j++)
     fscanf(infile, "%lf", &(result[i][j]));
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x6393c(%rip), %r8      # 0x99b82
pushq $0x8
popq %rdi
pushq $0x3
popq %r9
movq %rdi, %rsi
movl %r14d, %edx
movl %ebx, %ecx
callq 0x351c3
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
testl %r14d, %r14d
cmovlel %ecx, %r14d
movq %r14, (%rsp)
movq %rax, %r12
shlq $0x3, %rbx
leaq 0x6392e(%rip), %r13     # 0x99ba8
xorl %ebp, %ebp
cmpq (%rsp), %rbp
je 0x362a9
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x362a4
movq (%r12,%rbp,8), %rdx
addq %r14, %rdx
movq %r15, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %r14
jmp 0x36285
incq %rbp
jmp 0x3627c
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_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_support_vector
Svm_nodeptr load_support_vector(FILE* infile, Datasetptr d)
{
 /*!Last Changed 26.12.2005*/
 Svm_nodeptr result;
 int i;
 result = safemalloc(d->multifeaturecount * sizeof(Svm_node), "load_support_vector", 3);
 for (i = 0; i < d->multifeaturecount; i++)
  {
   fscanf(infile, "%d %lf", &(result[i].index), &(result[i].value));
   if (result[i].index == -1)
    {
     result = alloc(result, (i + 1) * sizeof(Svm_node), i + 1);
     return result;
    }
  }
 result[i].index = -1;
 result[i].value = 0.0;
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x1c0(%rsi), %rdi
shlq $0x4, %rdi
leaq 0x638b3(%rip), %rsi     # 0x99b91
pushq $0x3
popq %rdx
callq 0x34f59
movq %rax, %rbp
pushq $0x10
popq %r12
leaq 0x638b1(%rip), %r15     # 0x99ba5
movq %rax, (%rsp)
xorl %r13d, %r13d
movslq 0x1c0(%rbx), %rax
cmpq %rax, %r13
jge 0x3632e
leaq 0x8(%rbp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, (%rbp)
je 0x3634a
incq %r13
addq $0x10, %rbp
addq $0x10, %r12
jmp 0x362fb
orl $-0x1, (%rbp)
andq $0x0, 0x8(%rbp)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl %r13d
movq (%rsp), %rdi
movq %r12, %rsi
movl %r13d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34f30
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_array_support_vector
Svm_nodeptr* load_array_support_vector(FILE* infile, Datasetptr d, int size)
{
 /*!Last Changed 26.12.2005*/
 int i;
 Svm_nodeptr* result;
 result = safemalloc(size * sizeof(Svm_nodeptr), "load_array_support_vector", 3);
 for (i = 0; i < size; i++)
   result[i] = load_support_vector(infile, d);
 return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %r12
leaq (,%r12,8), %rdi
leaq 0x63821(%rip), %rsi     # 0x99bac
pushq $0x3
popq %rdx
callq 0x34f59
movq %rax, %r15
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x363b9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x362bb
movq %rax, (%r15,%r13,8)
incq %r13
jmp 0x363a0
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_instance
Instance load_instance(FILE* infile, Datasetptr d, int class_loaded)
{
 /*!Last Changed 15.01.2009 added loading class or regression information*/
 /*!Last Changed 22.12.2005*/
 Instance inst;
 int i;
 inst.values = safemalloc(d->multifeaturecount * sizeof(union value), "load_instance", 3);
 inst.sublist = NULL;
 inst.class_labels = NULL;
 for (i = 0; i < d->multifeaturecount; i++)
   if (i != d->classdefno)
     fscanf(infile, "%lf", &(inst.values[i].floatvalue));
   else
     if (d->classno == 0)
       fscanf(infile, "%lf", &(inst.values[i].floatvalue));
     else
       fscanf(infile, "%d", &(inst.values[i].stringindex));
 return inst; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq 0x1c0(%rdx), %rdi
shlq $0x3, %rdi
leaq 0x637c6(%rip), %rsi     # 0x99bc6
pushq $0x3
popq %rdx
callq 0x34f59
movq %rax, %r12
movq %rax, (%r14)
andq $0x0, 0x28(%r14)
movq %r14, (%rsp)
andq $0x0, 0x8(%r14)
leaq 0x63785(%rip), %r13     # 0x99ba8
leaq 0x6a72f(%rip), %rbp     # 0xa0b59
xorl %r14d, %r14d
movslq 0x1c0(%rbx), %rax
cmpq %rax, %r14
jge 0x3646b
movl 0x1407128(%rbx), %eax
cmpq %rax, %r14
jne 0x36452
cmpl $0x0, 0x10(%rbx)
je 0x36452
movq %r15, %rdi
movq %rbp, %rsi
jmp 0x36458
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
incq %r14
addq $0x8, %r12
jmp 0x3642d
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_instance_discrete
Instance load_instance_discrete(FILE* infile, Datasetptr d)
{
 /*!Last Changed 22.12.2005*/
 Instance inst;
 int i;
 inst.values = safemalloc(d->featurecount * sizeof(union value), "load_instance_discrete", 3);
 inst.sublist = NULL;
 inst.class_labels = NULL;
 for (i = 0; i < d->featurecount; i++)
   switch (d->features[i].type)
    {
     case INTEGER :
     case REAL    :
					case REGDEF  :fscanf(infile, "%lf", &(inst.values[i].floatvalue));
                   break;
     case STRING  :
     case CLASSDEF:fscanf(infile, "%d", &(inst.values[i].stringindex));
                   break;
     default      :printf(m1238, d->features[i].type);
                   break;
    }
 return inst; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq 0x1bc(%rdx), %rdi
shlq $0x3, %rdi
leaq 0x63730(%rip), %rsi     # 0x99bd4
pushq $0x3
popq %rdx
callq 0x34f59
movq %rax, %r12
movq %rax, (%r14)
andq $0x0, 0x28(%r14)
movq %r14, (%rsp)
andq $0x0, 0x8(%r14)
leaq 0x30f08(%rbx), %r14
pushq $0x15
popq %r13
xorl %ebp, %ebp
movslq 0x1bc(%rbx), %rax
cmpq %rax, %rbp
jge 0x36524
movl (%r14), %esi
cmpl $0x4, %esi
ja 0x36514
movq %r15, %rdi
btl %esi, %r13d
jae 0x364f3
leaq 0x636b7(%rip), %rsi     # 0x99ba8
jmp 0x364fa
leaq 0x6a65f(%rip), %rsi     # 0xa0b59
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
incq %rbp
addq $0x8, %r12
addq $0x340, %r14            # imm = 0x340
jmp 0x364cd
leaq 0x5fe53(%rip), %rdi     # 0x9636e
xorl %eax, %eax
callq 0x4030
jmp 0x36504
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_selectmax
void* load_model_selectmax(FILE* infile, Datasetptr d)
{
 /*!Last Changed 19.12.2005*/
 Model_selectmaxptr m;
 m = safemalloc(sizeof(Model_selectmax), "load_model_selectmax", 2);
 fscanf(infile, "%d", &(m->classno));
 m->priors = load_array(infile, d->classno);
 return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x636a2(%rip), %rsi     # 0x99beb
pushq $0x10
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %r15
leaq 0x6a5fb(%rip), %rsi     # 0xa0b59
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3615a
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_gaussian
void* load_model_gaussian(FILE* infile, Datasetptr d)
{
 /*!Last Changed 22.12.2005*/
 Model_gaussianptr m;
 int i;
 Instanceptr tmp, tmpbefore = NULL;
 m = safemalloc(sizeof(Model_gaussian), "load_model_gaussian", 4);
 for (i = 0; i < d->classno; i++)
  {
   tmp = safemalloc(sizeof(Instance), "load_model_gaussian", 7);
   *tmp = load_instance(infile, d, BOOLEAN_FALSE);
   if (tmpbefore)
     tmpbefore->next = tmp;
   else
     m->mean = tmp;
   tmpbefore = tmp;
  }
 tmp->next = NULL;
 m->variance = load_array(infile, d->classno);
 m->priors = load_array(infile, d->classno); 
 return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x63662(%rip), %rsi     # 0x99c00
pushq $0x18
popq %rdi
pushq $0x4
popq %rdx
callq 0x34f59
movq %rax, %r15
xorl %ebp, %ebp
xorl %r12d, %r12d
movl 0x10(%r14), %esi
cmpl %esi, %ebp
jge 0x36612
pushq $0x30
popq %rdi
leaq 0x6363d(%rip), %rsi     # 0x99c00
pushq $0x7
popq %rdx
callq 0x34f59
movq %rax, %r13
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x363da
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups %xmm2, 0x20(%r13)
movups %xmm1, 0x10(%r13)
leaq 0x10(%r12), %rax
testq %r12, %r12
cmoveq %r15, %rax
movups %xmm0, (%r13)
movq %r13, (%rax)
incl %ebp
movq %r13, %r12
jmp 0x365b1
andq $0x0, 0x10(%r13)
movq %rbx, %rdi
callq 0x3615a
movq %rax, 0x8(%r15)
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x3615a
movq %rax, 0x10(%r15)
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_knn
void* load_model_knn(FILE* infile, Datasetptr d)
{
 /*!Last Changed 22.12.2005*/
 int size, i;
 Instanceptr tmp, tmpbefore = NULL, head;
 fscanf(infile, "%d", &size);
 for (i = 0; i < size; i++)
  {
   tmp = safemalloc(sizeof(Instance), "load_model_knn", 6);
   *tmp = load_instance_discrete(infile, d);
   if (tmpbefore)
     tmpbefore->next = tmp;
   else
     head = tmp;
   tmpbefore = tmp;
  }
 tmp->next = NULL;
 return head;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6a4f9(%rip), %rsi     # 0xa0b59
xorl %ebp, %ebp
leaq 0x4(%rsp), %rdx
xorl %eax, %eax
callq 0x4070
xorl %r13d, %r13d
cmpl 0x4(%rsp), %ebp
jge 0x366d2
pushq $0x30
popq %rdi
leaq 0x63593(%rip), %rsi     # 0x99c14
pushq $0x6
popq %rdx
callq 0x34f59
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3647e
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq %r15, %rax
testq %r13, %r13
je 0x366c8
movq %r15, 0x10(%r13)
movq %r12, %rax
incl %ebp
movq %r15, %r13
movq %rax, %r12
jmp 0x36671
andq $0x0, 0x10(%r15)
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_softtree
void load_model_softtree(FILE* infile, Datasetptr d, Decisionnodeptr rootnode)
{
	int leaftype;
 rootnode->left = NULL;
 rootnode->parent = NULL;
 rootnode->right = NULL;
 rootnode->string = NULL;
	rootnode->instances = NULL;
 rootnode->counts = NULL;
 rootnode->rule = NULL;
 fscanf(infile, "%d", &(rootnode->featureno));
	if (rootnode->featureno == LEAF_NODE)
  {
   fscanf(infile, "%d", &leaftype);
   rootnode->leaftype = leaftype;
   if (rootnode->leaftype == CONSTANTLEAF)
     fscanf(infile, "%lf", &(rootnode->w0));
   else
     rootnode->w = load_matrix(infile, d->multifeaturecount, 1);  
  }
	else
  {
   rootnode->w = load_matrix(infile, d->multifeaturecount, 1);  
   rootnode->left = safemalloc(sizeof(Decisionnode), "load_model_softtree", 20);
   load_model_softtree(infile, d, rootnode->left);
   rootnode->left->parent = rootnode;
   rootnode->right = safemalloc(sizeof(Decisionnode), "load_model_softtree", 23);
   load_model_softtree(infile, d, rootnode->right);
   rootnode->right->parent = rootnode;   
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
andq $0x0, 0xa0(%rdx)
movq %rsi, %r15
andq $0x0, 0x58(%rdx)
movq %rdi, %r14
addq $0x30, %rdx
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
leaq 0x6a438(%rip), %rsi     # 0xa0b59
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, 0x30(%rbx)
je 0x367a3
movl 0x1c0(%r15), %esi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x360cc
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
leaq 0x634d4(%rip), %r12     # 0x99c23
pushq $0x14
popq %rdx
movl $0x160, %edi            # imm = 0x160
movq %r12, %rsi
callq 0x34f59
movq %rax, (%rbx)
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x366e9
movq (%rbx), %rax
movq %rbx, 0x18(%rax)
pushq $0x17
popq %rdx
movl $0x160, %edi            # imm = 0x160
movq %r12, %rsi
callq 0x34f59
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x366e9
movq 0x8(%rbx), %rax
movq %rbx, 0x18(%rax)
jmp 0x367fb
leaq 0x6a3af(%rip), %rsi     # 0xa0b59
leaq 0x4(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
movl (%r12), %eax
movl %eax, 0x60(%rbx)
testl %eax, %eax
je 0x367e3
movl 0x1c0(%r15), %esi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x360cc
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
jmp 0x367fb
addq $0x48, %rbx
leaq 0x633ba(%rip), %rsi     # 0x99ba8
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x4070
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_svmtree
void load_model_svmtree(FILE* infile, Datasetptr d, Decisionnodeptr* forest, int treecount)
{
 int i;
 for (i = 0; i < treecount; i++)
  {
   forest[i] = safemalloc(sizeof(Decisionnode), "load_model_svmtree", 30);
   load_model_c45(infile, d, forest[i]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
testl %ecx, %ecx
cmovlel %r13d, %ebx
pushq $0x1e
popq %rbp
cmpq %r13, %rbx
je 0x36a28
movl $0x160, %edi            # imm = 0x160
leaq 0x6323c(%rip), %rsi     # 0x99c46
movl %ebp, %edx
callq 0x34f59
movq %rax, (%r14,%r13,8)
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x36807
incq %r13
jmp 0x369f9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_rbf
void* load_model_rbf(FILE* infile, Datasetptr d)
{
	/*!Last Changed 19.08.2007*/
	Rbfnetworkptr m;
	m = safemalloc(sizeof(Rbfnetwork), "load_model_rbf", 2);
	fscanf(infile, "%d %d", &(m->hidden), &(m->output));
	m->weights.m = load_matrix(infile, m->hidden, d->multifeaturecount - 1);
	m->weights.s = load_matrix(infile, 1, m->hidden);
	m->weights.w = load_matrix(infile, m->output, m->hidden + 1);
	return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x631fb(%rip), %rsi     # 0x99c59
pushq $0x40
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %r14
leaq 0x4(%rax), %rcx
leaq 0x61e67(%rip), %rsi     # 0x988de
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movl (%r14), %esi
movl 0x1c0(%r15), %edx
decl %edx
movq %rbx, %rdi
callq 0x360cc
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movl (%r14), %edx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x360cc
movq %rax, 0x20(%r14)
movq %rdx, 0x28(%r14)
movl (%r14), %edx
movl 0x4(%r14), %esi
incl %edx
movq %rbx, %rdi
callq 0x360cc
movq %rax, 0x30(%r14)
movq %rdx, 0x38(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_mlpgeneric
void* load_model_mlpgeneric(FILE* infile, Datasetptr d)
{
 /*!Last Changed 25.12.2005*/
	int i;
 Mlpnetworkptr m;
	m = safemalloc(sizeof(Mlpnetwork), "load_model_mlpgeneric", 3);
	fscanf(infile, "%d %d %d", &(m->P.dimnum), &(m->P.classnum), &(m->P.layernum));
	for (i = 0; i < m->P.layernum; i++)
		 fscanf(infile, "%d", &(m->P.hidden[i]));
	m->weights = safemalloc((m->P.layernum + 1) * sizeof(matrix), "load_model_mlpgeneric", 7);
	for (i = 0; i < m->P.layernum; i++)
			if (i == 0)
	 			m->weights[i] = load_matrix(infile, m->P.hidden[i], m->P.dimnum + 1);
			else
			 	m->weights[i] = load_matrix(infile, m->P.hidden[i], m->P.hidden[i-1] + 1);
	if (m->P.layernum == 0)
			m->weights[m->P.layernum] = load_matrix(infile, m->P.classnum, m->P.dimnum + 1);
	else
			m->weights[m->P.layernum] = load_matrix(infile, m->P.classnum, m->P.hidden[m->P.layernum - 1] + 1);	
	return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x63178(%rip), %rsi     # 0x99c68
pushq $0x3
popq %rdx
movl $0x98, %edi
callq 0x34f59
movq %rax, %rbx
leaq 0x8(%rax), %rcx
leaq 0xc(%rax), %rdx
leaq 0x5c(%rax), %r12
leaq 0x61dc8(%rip), %rsi     # 0x988db
movq %r14, %rdi
movq %rdx, 0x10(%rsp)
movq %r12, %r8
xorl %eax, %eax
callq 0x4070
leaq 0x50(%rbx), %rbp
leaq 0x6a029(%rip), %r13     # 0xa0b59
movq %rbp, 0x8(%rsp)
xorl %r15d, %r15d
movslq (%r12), %rdi
cmpq %rdi, %r15
jge 0x36b5a
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x4070
incq %r15
addq $0x4, %rbp
jmp 0x36b38
shlq $0x4, %rdi
addq $0x10, %rdi
leaq 0x630ff(%rip), %rsi     # 0x99c68
pushq $0x7
popq %rdx
callq 0x34f59
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x4c, %rax
pushq $0x2
popq %r13
xorl %ebp, %ebp
movslq 0x5c(%rbx), %rcx
movq (%rbx), %r12
cmpq %rcx, %rbp
jge 0x36bc6
leaq 0x4(%rax), %r15
testq %rbp, %rbp
cmoveq 0x10(%rsp), %rax
movq %r15, %rcx
cmoveq 0x8(%rsp), %rcx
movl (%rcx), %esi
movl (%rax), %edx
incl %edx
movq %r14, %rdi
callq 0x360cc
movq %rax, -0x8(%r12,%r13,4)
movq %rdx, (%r12,%r13,4)
incq %rbp
addq $0x4, %r13
movq %r15, %rax
jmp 0x36b81
movq 0x8(%rsp), %rax
leaq (%rax,%rcx,4), %rax
addq $-0x4, %rax
movq %rcx, %r15
shlq $0x4, %r15
testl %ecx, %ecx
cmoveq 0x10(%rsp), %rax
movl 0x8(%rbx), %esi
movl (%rax), %edx
incl %edx
movq %r14, %rdi
callq 0x360cc
movq %rax, (%r12,%r15)
movq %rdx, 0x8(%r12,%r15)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_multildt
void* load_model_multildt(FILE* infile, Datasetptr d)
{
 /*!Last Changed 25.12.2005*/
 Decisionnodeptr tmp;
 tmp = safemalloc(sizeof(Decisionnode), "load_model_c45", 2);
 tmp->left = NULL;
 tmp->parent = NULL;
 tmp->right = NULL;
 tmp->string = NULL;
	tmp->rule = NULL;
	tmp->instances = NULL;
	tmp->conditiontype = MULTIVARIATE_CONDITION;
 fscanf(infile, "%d", &(tmp->featureno));
	if (tmp->featureno == LEAF_NODE)
	 {
		 fscanf(infile, "%d", &(tmp->classno));
			tmp->counts = load_array_int(infile, d->classno);
	 }
	else
	 {
  	fscanf(infile, "%lf", &(tmp->w0));
			tmp->w = load_matrix(infile, 1, d->multifeaturecount - 1);
		 tmp->counts = NULL;
 		tmp->left = load_model_multildt(infile, d);
   tmp->left->parent = tmp;
			tmp->right = load_model_multildt(infile, d);
   tmp->right->parent = tmp;
	 }
 return tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x63019(%rip), %rsi     # 0x99c37
pushq $0x2
popq %rdx
movl $0x160, %edi            # imm = 0x160
callq 0x34f59
movq %rax, %rbx
andq $0x0, 0x58(%rax)
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movl $0x1, 0x98(%rax)
leaq 0x30(%rax), %rdx
leaq 0x69f02(%rip), %rsi     # 0xa0b59
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, 0x30(%rbx)
je 0x36cca
movq %rbx, %rdx
addq $0x48, %rdx
leaq 0x62f33(%rip), %rsi     # 0x99ba8
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x1c0(%r15), %edx
decl %edx
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x360cc
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
andq $0x0, 0xa0(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x36c0c
movq %rax, (%rbx)
movq %rbx, 0x18(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x36c0c
movq %rax, 0x8(%rbx)
movq %rbx, 0x18(%rax)
jmp 0x36cf5
movq %rbx, %rdx
addq $0x34, %rdx
leaq 0x69e81(%rip), %rsi     # 0xa0b59
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x10(%r15), %esi
movq %r14, %rdi
callq 0x361c3
movq %rax, 0xa0(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_nodeboundedtree
void* load_model_nodeboundedtree(FILE* infile, Datasetptr d)
{
 /*!Last Changed 25.12.2005*/
 Decisionnodeptr tmp;
 tmp = safemalloc(sizeof(Decisionnode), "load_model_nodeboundedtree", 2);
 tmp->left = NULL;
 tmp->parent = NULL;
 tmp->right = NULL;
 tmp->string = NULL;
	tmp->rule = NULL;
	tmp->instances = NULL;
	tmp->conditiontype = HYBRID_CONDITION;
 fscanf(infile, "%d", &(tmp->featureno));
	switch (tmp->featureno)
	 {
	  case LEAF_NODE:fscanf(infile, "%d", &(tmp->classno));
				              tmp->counts = load_array_int(infile, d->classno);
																		break;
			case LINEAR   :fscanf(infile, "%lf", &(tmp->w0));
               			tmp->w = load_matrix(infile, 1, d->multifeaturecount - 1);
		                tmp->counts = NULL;
                  break;
			case QUADRATIC:fscanf(infile, "%lf", &(tmp->w0));
				              tmp->w = load_matrix(infile, 1, multifeaturecount_2d(d));
		                tmp->counts = NULL;
                  break;
			default       :fscanf(infile, "%lf", &(tmp->split));
		                tmp->counts = NULL;
																		break;
	 }
	if (tmp->featureno != LEAF_NODE)
	 {
 		tmp->left = load_model_nodeboundedtree(infile, d);
			tmp->right = load_model_nodeboundedtree(infile, d);
	 }
 return tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x62f6b(%rip), %rsi     # 0x99c7e
pushq $0x2
popq %rdx
movl $0x160, %edi            # imm = 0x160
callq 0x34f59
movq %rax, %r15
andq $0x0, 0x58(%rax)
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movl $0x2, 0x98(%rax)
leaq 0x30(%rax), %rdx
leaq 0x69e0d(%rip), %rsi     # 0xa0b59
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x30(%r15), %eax
movq %r15, %rdx
cmpl $-0x3, %eax
je 0x36dbd
cmpl $-0x2, %eax
je 0x36d95
cmpl $-0x1, %eax
jne 0x36df4
addq $0x34, %rdx
leaq 0x69dde(%rip), %rsi     # 0xa0b59
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x361c3
movq %rax, %r12
jmp 0x36e0c
addq $0x48, %rdx
leaq 0x62e08(%rip), %rsi     # 0x99ba8
xorl %r12d, %r12d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x1c0(%rbx), %edx
decl %edx
pushq $0x1
popq %rsi
movq %r14, %rdi
jmp 0x36de5
addq $0x48, %rdx
leaq 0x62de0(%rip), %rsi     # 0x99ba8
xorl %r12d, %r12d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movq %rbx, %rdi
callq 0x126ea
pushq $0x1
popq %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x360cc
movq %rax, 0x38(%r15)
movq %rdx, 0x40(%r15)
jmp 0x36e0c
addq $0x28, %rdx
leaq 0x62da9(%rip), %rsi     # 0x99ba8
xorl %r12d, %r12d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movq %r12, 0xa0(%r15)
cmpl $-0x1, 0x30(%r15)
je 0x36e37
movq %r14, %rdi
movq %rbx, %rsi
callq 0x36cfe
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x36cfe
movq %rax, 0x8(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_nearestmean
void* load_model_nearestmean(FILE* infile, Datasetptr d)
{
 /*!Last Changed 25.12.2005*/
 Instanceptr m;
 int i;
 Instanceptr tmp, tmpbefore = NULL;
 for (i = 0; i < d->classno; i++)
  {
   tmp = safemalloc(sizeof(Instance), "load_model_gaussian", 7);
   *tmp = load_instance_discrete(infile, d);
   if (tmpbefore)
     tmpbefore->next = tmp;
   else
     m = tmp;
   tmpbefore = tmp;
  }
 tmp->next = NULL;
 return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
xorl %r13d, %r13d
cmpl 0x10(%rbx), %ebp
jge 0x36ec2
pushq $0x30
popq %rdi
leaq 0x62d92(%rip), %rsi     # 0x99c00
pushq $0x7
popq %rdx
callq 0x34f59
movq %rax, %r12
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3647e
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups %xmm2, 0x20(%r12)
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
movq %r12, %rax
testq %r13, %r13
je 0x36eb8
movq %r12, 0x10(%r13)
movq %r15, %rax
incl %ebp
movq %rax, %r15
movq %r12, %r13
jmp 0x36e5f
andq $0x0, 0x10(%r12)
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq