LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libmemory.c
// Function: free_3d
void free_3d(void ***p,int size1,int size2)
{
/*!Last Changed 23.02.2001*/
 int i,j;
 for (i = 0; i < size1; i++)
   for (j = 0; j < size2; j++)
     safe_free(p[i][j]);
 for (i = 0; i < size1; i++)
   safe_free(p[i]);
 safe_free(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r15d
movl %esi, 0x4(%rsp)
testl %esi, %esi
jle 0x391df
movl %edx, %r14d
movl %edx, %r12d
xorl %r13d, %r13d
testl %r14d, %r14d
jle 0x391d7
xorl %ebp, %ebp
movq (%rbx,%r13,8), %rax
movq (%rax,%rbp,8), %rdi
callq 0x4170
incq %rbp
cmpq %rbp, %r12
jne 0x391c2
incq %r13
cmpq %r15, %r13
jne 0x391bb
cmpl $0x0, 0x4(%rsp)
jle 0x391fa
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x4170
incq %r14
cmpq %r14, %r15
jne 0x391e9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4170
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libmemory.c
// Function: safecalloc
void* safecalloc(size_t elementcount, size_t elementsize, char* functionname, int line)
{
 /*!Last Changed 02.02.2004*/
 void* result;
 result = calloc(elementcount, elementsize);
 if (!result)
  {
   printf(m1305, functionname, line);
   exit(0);
  }
 else
  {
   #ifdef HEAP_DEBUG
     heap_debug_insert_data(result, elementcount * elementsize, functionname, line);
   #endif
   return result;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
callq 0x4290
testq %rax, %rax
je 0x3922b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6d786(%rip), %rdi     # 0xa69b8
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4030
xorl %edi, %edi
callq 0x40c0
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libmemory.c
// Function: safecalloc_2d
void** safecalloc_2d(size_t elementsize1, size_t elementsize2, int elementcount1, int elementcount2, char* functionname, int line)
{
 /*!Last Changed 06.02.2005*/
 void** result;
 int i;
 result = safemalloc(elementsize1 * elementcount1, functionname, line);
 for (i = 0; i < elementcount1; i++)
   result[i] = safecalloc(elementcount2, elementsize2, functionname, line);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %r13d
movl %edx, %ebp
movq %rsi, (%rsp)
movslq %edx, %rbx
imulq %rbx, %rdi
movq %r8, %rsi
movl %r9d, %r15d
movl %r9d, %edx
callq 0x390f5
movq %rax, %r12
testl %ebx, %ebx
jle 0x3929d
movslq %r13d, %r13
movl %ebp, %ebp
xorl %ebx, %ebx
movq %r13, %rdi
movq (%rsp), %rsi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x39210
movq %rax, (%r12,%rbx,8)
incq %rbx
cmpq %rbx, %rbp
jne 0x3927f
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libmemory.c
// Function: safecalloc_3d
void*** safecalloc_3d(size_t elementsize1, size_t elementsize2, size_t elementsize3, int elementcount1, int elementcount2, int elementcount3, char* functionname, int line)
{
 /*!Last Changed 06.02.2005*/
 void*** result;
 int i, j;
 result = safemalloc(elementsize1 * elementcount1, functionname, line);
 for (i = 0; i < elementcount1; i++)
   result[i] = safemalloc(elementsize2 * elementcount2, functionname, line);
 for (i = 0; i < elementcount1; i++)
   for (j = 0; j < elementcount2; j++)
     result[i][j] = safecalloc(elementcount3, elementsize3, functionname, line);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, 0x1c(%rsp)
movl %r8d, 0xc(%rsp)
movl %ecx, %r12d
movq %rdx, 0x30(%rsp)
movq %rsi, %r13
movl 0x78(%rsp), %ebp
movq 0x70(%rsp), %r14
movslq %ecx, %rbx
imulq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x390f5
movq %rax, %r15
movl %r12d, 0x10(%rsp)
movl %r12d, %r12d
testl %ebx, %ebx
jle 0x39322
movq %r13, %rax
movslq 0xc(%rsp), %r13
imulq %rax, %r13
xorl %ebx, %ebx
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x390f5
movq %rax, (%r15,%rbx,8)
incq %rbx
cmpq %rbx, %r12
jne 0x39309
movq %r15, 0x20(%rsp)
cmpl $0x0, 0x10(%rsp)
jle 0x393a1
movslq 0x1c(%rsp), %rbx
movl 0xc(%rsp), %eax
xorl %r8d, %r8d
movq %r12, 0x28(%rsp)
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rbp
cmpl $0x0, 0xc(%rsp)
movl 0x78(%rsp), %r13d
movq 0x30(%rsp), %rsi
movq 0x70(%rsp), %rdx
jle 0x39394
xorl %r15d, %r15d
movq %rbx, %rdi
movq %rsi, %r14
movq %r8, %r12
movl %r13d, %ecx
callq 0x39210
movq %r14, %rsi
movq %r12, %r8
movq (%rbp,%r12,8), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x70(%rsp), %rdx
movq 0x10(%rsp), %rax
incq %r15
cmpq %r15, %rax
jne 0x39362
incq %r8
movq 0x28(%rsp), %r12
cmpq %r12, %r8
jne 0x39349
movq 0x20(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libmemory.c
// Function: safemalloc_2d
void** safemalloc_2d(size_t elementsize1, size_t elementsize2, int elementcount1, int elementcount2, char* functionname, int line)
{
 /*!Last Changed 06.02.2005*/
 void** result;
 int i;
 result = safemalloc(elementsize1 * elementcount1, functionname, line);
 for (i = 0; i < elementcount1; i++)
   result[i] = safemalloc(elementsize2 * elementcount2, functionname, line);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r14
movl %ecx, 0x4(%rsp)
movl %edx, %ebp
movq %rsi, %r13
movslq %edx, %r12
imulq %r12, %rdi
movq %r8, %rsi
movl %r9d, %edx
callq 0x390f5
movq %rax, %r15
testl %r12d, %r12d
jle 0x39410
movslq 0x4(%rsp), %r12
imulq %r13, %r12
movl %ebp, %r13d
xorl %ebp, %ebp
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x390f5
movq %rax, (%r15,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x393f7
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libmemory.c
// Function: safemalloc_3d
void*** safemalloc_3d(size_t elementsize1, size_t elementsize2, size_t elementsize3, int elementcount1, int elementcount2, int elementcount3, char* functionname, int line)
{
 /*!Last Changed 06.02.2005*/
 void*** result;
 int i, j;
 result = safemalloc(elementsize1 * elementcount1, functionname, line);
 for (i = 0; i < elementcount1; i++)
   result[i] = safemalloc(elementsize2 * elementcount2, functionname, line);
 for (i = 0; i < elementcount1; i++)
   for (j = 0; j < elementcount2; j++)
     result[i][j] = safemalloc(elementsize3 * elementcount3, functionname, line);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movl %ecx, %r12d
movq %rdx, 0x20(%rsp)
movq %rsi, %r13
movl 0x68(%rsp), %ebp
movq 0x60(%rsp), %r14
movslq %ecx, %rbx
imulq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x390f5
movq %rax, %r15
movl %r12d, %eax
movq %rax, 0x18(%rsp)
testl %ebx, %ebx
jle 0x39497
movq %r13, %rax
movslq 0x4(%rsp), %r13
imulq %rax, %r13
xorl %ebx, %ebx
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x390f5
movq %rax, (%r15,%rbx,8)
incq %rbx
cmpq %rbx, 0x18(%rsp)
jne 0x3947c
movq %r15, 0x10(%rsp)
testl %r12d, %r12d
jle 0x39504
movslq 0x8(%rsp), %r13
imulq 0x20(%rsp), %r13
movl 0x4(%rsp), %eax
xorl %esi, %esi
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rbx
cmpl $0x0, 0x4(%rsp)
movl 0x68(%rsp), %edx
movq 0x60(%rsp), %r12
jle 0x394fa
xorl %ebp, %ebp
movq %r13, %rdi
movq %rsi, %r14
movq %r12, %rsi
movl %edx, %r15d
callq 0x390f5
movq %r14, %rsi
movl %r15d, %edx
movq (%rbx,%r14,8), %rcx
movq %rax, (%rcx,%rbp,8)
movq 0x8(%rsp), %rax
incq %rbp
cmpq %rbp, %rax
jne 0x394ce
incq %rsi
cmpq 0x18(%rsp), %rsi
jne 0x394bc
movq 0x10(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libmisc.c
// Function: set_precision
void set_precision(char* precisionst, char* before, char* after)
{
 /*!Last Changed 05.07.2005*/
 char st[10];
 strcpy(precisionst, "");
 if (before)
   strcat(precisionst, before);
 sprintf(st, "%%4.%dlf", get_parameter_i("precision"));
 strcat(precisionst, st);
 if (after)
   strcat(precisionst, after);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movb $0x0, (%rdi)
testq %rsi, %rsi
je 0x39548
movq %r14, %rdi
callq 0x41e0
leaq 0x6d491(%rip), %rdi     # 0xa69e0
callq 0x5341c
leaq 0x6d47c(%rip), %rsi     # 0xa69d7
leaq 0x6(%rsp), %r15
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x41b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x41e0
testq %rbx, %rbx
je 0x39590
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x41e0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r15
leaq 0x6d303(%rip), %r14     # 0xa69ea
movl $0x4, %esi
movq %r15, %rdi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x39210
movq %rax, 0x18(%rsp)
movq %r12, 0x10(%rsp)
movq (%r12), %rdi
callq 0x37e22
movl %eax, %ebp
movl $0x8, %edi
movl $0x8, %esi
movl %r15d, %edx
movl %eax, %ecx
movq %r14, %r8
movl $0x5, %r9d
callq 0x393b5
movq %rax, %r14
movl %ebx, 0x4(%rsp)
movl %ebx, %r13d
movl %ebp, (%rsp)
movl %ebp, %eax
movq %rax, 0x8(%rsp)
testl %r15d, %r15d
jle 0x397be
movq 0x8(%rsp), %rax
leaq (,%rax,8), %r12
leaq 0x6d4b5(%rip), %rbp     # 0xa6c10
xorl %ebx, %ebx
movq %r13, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq (%rax,%rbx,8), %rdi
leaq 0x6f11d(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x39839
movq %rax, %r15
cmpl $0x0, (%rsp)
jle 0x397a9
xorl %r13d, %r13d
movq (%r14,%rbx,8), %rdx
addq %r13, %rdx
movq %r15, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %r13
cmpq %r13, %r12
jne 0x3978c
movq %r15, %rdi
callq 0x42a0
incq %rbx
movq 0x20(%rsp), %r13
cmpq %r13, %rbx
jne 0x39762
cmpl $0x0, (%rsp)
movq 0x18(%rsp), %rbx
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %r8
jle 0x3982f
movq (%r14), %rax
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm1
cmpl $0x2, %esi
jl 0x39801
movl $0x1, %edx
movq (%r14,%rdx,8), %rdi
movsd (%rdi,%rcx,8), %xmm0
minsd %xmm1, %xmm0
incq %rdx
movapd %xmm0, %xmm1
cmpq %rdx, %r13
jne 0x397e6
jmp 0x39805
movapd %xmm1, %xmm0
testl %esi, %esi
jle 0x39827
xorl %edx, %edx
movq (%r14,%rdx,8), %rdi
movsd (%rdi,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x3981f
jp 0x3981f
incl (%rbx,%rdx,4)
incq %rdx
cmpq %rdx, %r13
jne 0x3980b
incq %rcx
cmpq %r8, %rcx
jne 0x397d7
movq %r14, %rdi
callq 0x3915f
jmp 0x39852
movq 0x10(%rsp), %rax
movq (%rax,%rbx,8), %rsi
leaq 0x699c1(%rip), %rdi     # 0xa320a
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_O1/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:
testl %edx, %edx
jle 0x398d1
pushq %rbp
pushq %rbx
movl %edx, %eax
xorl %r9d, %r9d
movq %rax, %rcx
movq %rdi, %rdx
movq %rsi, %r8
movq %r9, %r10
incq %r9
cmpq %rax, %r9
jae 0x398bf
movl $0x1, %r11d
movsd (%rdi,%r10,8), %xmm0
movsd (%rdx,%r11,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x398b7
movl (%rsi,%r10,4), %ebx
movl (%r8,%r11,4), %ebp
movl %ebp, (%rsi,%r10,4)
movl %ebx, (%r8,%r11,4)
movsd %xmm1, (%rdi,%r10,8)
movsd %xmm0, (%rdx,%r11,8)
incq %r11
cmpq %r11, %rcx
jne 0x39889
addq $0x4, %r8
addq $0x8, %rdx
decq %rcx
cmpq %rax, %r9
jne 0x39878
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
testl %eax, %eax
jle 0x39923
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
movabsq $0x40000000400000d, %rsi # imm = 0x40000000400000D
movzbl (%rbx,%rdx), %edi
leal -0x3a(%rdi), %ecx
cmpb $-0xb, %cl
ja 0x3991b
xorl %ecx, %ecx
addl $-0x2b, %edi
cmpl $0x3a, %edi
ja 0x39928
btq %rdi, %rsi
jae 0x39928
incq %rdx
cmpq %rdx, %rax
jne 0x398ff
movl $0x1, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3992c
testl %eax, %eax
je 0x399b9
movq %r12, %rdi
callq 0x4200
cmpl %r14d, %eax
jge 0x399ce
leaq 0x6d048(%rip), %rdi     # 0xa69f8
xorl %ebp, %ebp
movl %eax, %esi
movl %r14d, %edx
jmp 0x399df
leaq 0x6d0db(%rip), %rdi     # 0xa6a9b
xorl %ebp, %ebp
movq %r12, %rsi
xorl %eax, %eax
callq 0x4030
jmp 0x399f0
cmpl %ebx, %eax
jle 0x399e8
leaq 0x6d071(%rip), %rdi     # 0xa6a4a
xorl %ebp, %ebp
movl %eax, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4030
jmp 0x399f0
movl %eax, (%r15)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x398e1
testl %eax, %eax
je 0x39a3a
movq %r14, %rdi
callq 0x4130
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x39a4f
leaq 0x6d079(%rip), %rdi     # 0xa6ab1
jmp 0x39a62
leaq 0x6d11b(%rip), %rdi     # 0xa6b5c
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x4030
jmp 0x39a76
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x39a6d
leaq 0x6d0a5(%rip), %rdi     # 0xa6b07
movb $0x2, %al
callq 0x4030
xorl %ebx, %ebx
jmp 0x39a76
movsd %xmm0, (%rbx)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x39ac4
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), %rax
movq %rax, -0x78(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x80(%rsp)
xorl %eax, %eax
testl %esi, %esi
jle 0x39b29
movl -0x80(%rsp), %ecx
movq -0x70(%rsp), %rdx
movq -0x78(%rsp), %r8
cmpl $0x28, %ecx
ja 0x39b0d
movq %r8, %r9
movl %ecx, %r8d
addq %rdx, %r8
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x39b16
leaq 0x8(%r8), %r9
movq %r9, -0x78(%rsp)
cmpl %edi, (%r8)
je 0x39b24
movq %r9, %r8
decl %esi
jne 0x39af6
jmp 0x39b29
movl $0x1, %eax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x39b86
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)
movl $0x1, %ebx
cmpl %esi, %edi
jge 0x39c22
movl (%rsp), %eax
cmpq $0x28, %rax
ja 0x39bc8
movq %rax, %rsi
addq 0x10(%rsp), %rsi
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x39bd6
movq 0x8(%rsp), %rsi
leaq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
testl %edi, %edi
jle 0x39c0f
movl (%rsp), %eax
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdx
cmpl $0x28, %eax
ja 0x39bfc
movq %rdx, %r8
movl %eax, %edx
addq %rcx, %rdx
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x39c05
leaq 0x8(%rdx), %r8
movq %r8, 0x8(%rsp)
movq %rdx, %rsi
movq %r8, %rdx
decl %edi
jne 0x39be7
movq (%rsi), %rsi
leaq 0x6b2df(%rip), %rdi     # 0xa4ef8
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4030
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6ccdc(%rip), %rsi     # 0xa6b80
movl $0x1, %edx
callq 0x390f5
movq %rax, %rcx
testl %r14d, %r14d
jle 0x39f0d
movl %ebx, %edi
xorl %r8d, %r8d
movabsq $0x200000005, %r9       # imm = 0x200000005
movslq 0x985e8(%rip), %rax     # 0xd24b4
imulq $0x19660d, %rax, %rsi   # imm = 0x19660D
addq $0x3c6ef35f, %rsi       # imm = 0x3C6EF35F
movq %rsi, %rax
mulq %r9
movq %rsi, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1e, %rax
addl %eax, %esi
shll $0x1f, %eax
addl %esi, %eax
movl %eax, 0x985b7(%rip)     # 0xd24b4
xorl %edx, %edx
divl %ebx
movl %edx, (%rcx,%r8,4)
incq %r8
cmpq %r8, %rdi
jne 0x39ec5
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9854b(%rip), %rax     # 0xd24b4
imulq $0x19660d, %rax, %rsi   # imm = 0x19660D
leaq 0x3c6ef35f(%rsi), %rcx
movabsq $0x200000005, %rdx      # imm = 0x200000005
movq %rcx, %rax
mulq %rdx
subq %rdx, %rcx
shrq %rcx
addq %rdx, %rcx
shrq $0x1e, %rcx
movq %rcx, %rax
shlq $0x1f, %rax
subq %rax, %rcx
leaq (%rsi,%rcx), %rax
addq $0x3c6ef35f, %rax       # imm = 0x3C6EF35F
movl %eax, 0x98506(%rip)     # 0xd24b4
movl $0xd1b1b919, %ecx       # imm = 0xD1B1B919
imulq %rax, %rcx
shrq $0x2d, %rcx
imull $0x2711, %ecx, %ecx     # imm = 0x2711
subl %ecx, %eax
subsd %xmm0, %xmm1
divsd 0x6cba9(%rip), %xmm1    # 0xa6b78
cvtsi2sd %eax, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6cb9c(%rip), %rsi     # 0xa6b90
movl $0x3, %edx
callq 0x390f5
movq %rax, %rcx
movl %ebx, %edi
testl %r14d, %r14d
jle 0x3a015
xorl %eax, %eax
movl %eax, (%rcx,%rax,4)
incq %rax
cmpq %rax, %rdi
jne 0x3a00a
testl %ebx, %ebx
jle 0x3a078
xorl %r8d, %r8d
movabsq $0x200000005, %r9       # imm = 0x200000005
movslq 0x98487(%rip), %rax     # 0xd24b4
imulq $0x19660d, %rax, %rsi   # imm = 0x19660D
addq $0x3c6ef35f, %rsi       # imm = 0x3C6EF35F
movq %rsi, %rax
mulq %r9
movq %rsi, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1e, %rax
addl %eax, %esi
shll $0x1f, %eax
addl %esi, %eax
movl %eax, 0x98456(%rip)     # 0xd24b4
xorl %edx, %edx
divl %ebx
movl (%rcx,%r8,4), %eax
movl (%rcx,%rdx,4), %esi
movl %esi, (%rcx,%r8,4)
movl %eax, (%rcx,%rdx,4)
incq %r8
cmpq %r8, %rdi
jne 0x3a026
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %edi, %ebx
movslq %edi, %r14
leaq (,%r14,8), %rdi
leaq 0x6caf3(%rip), %rsi     # 0xa6b9d
movl $0x2, %edx
callq 0x390f5
movq %rax, %rcx
testl %r14d, %r14d
jle 0x3a162
movl 0x983ee(%rip), %eax     # 0xd24b4
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm1
divsd 0x6ca9a(%rip), %xmm1    # 0xa6b78
movl %ebx, %edi
xorl %r8d, %r8d
movabsq $0x200000005, %r9       # imm = 0x200000005
movl $0xd1b1b919, %r10d      # imm = 0xD1B1B919
imull $0x19660d, %eax, %eax   # imm = 0x19660D
movslq %eax, %r11
leaq 0x3c6ef35f(%r11), %rsi
movq %rsi, %rax
mulq %r9
subq %rdx, %rsi
shrq %rsi
addq %rdx, %rsi
shrq $0x1e, %rsi
movq %rsi, %rax
shlq $0x1f, %rax
subq %rax, %rsi
leaq (%r11,%rsi), %rax
addq $0x3c6ef35f, %rax       # imm = 0x3C6EF35F
movq %rax, %rdx
imulq %r10, %rdx
shrq $0x2d, %rdx
imull $0x2711, %edx, %edx     # imm = 0x2711
movl %eax, %esi
subl %edx, %esi
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movsd %xmm0, (%rcx,%r8,8)
incq %r8
cmpq %r8, %rdi
jne 0x3a0f3
movl %eax, 0x98352(%rip)     # 0xd24b4
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
jle 0x3a1cc
movl %edx, %ecx
incl %ecx
movl %esi, %r8d
xorl %r9d, %r9d
movabsq $0x200000005, %r10      # imm = 0x200000005
movslq 0x98328(%rip), %rax     # 0xd24b4
imulq $0x19660d, %rax, %rsi   # imm = 0x19660D
addq $0x3c6ef35f, %rsi       # imm = 0x3C6EF35F
movq %rsi, %rax
mulq %r10
movq %rsi, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1e, %rax
addl %eax, %esi
shll $0x1f, %eax
addl %esi, %eax
movl %eax, 0x982f7(%rip)     # 0xd24b4
cltd
idivl %ecx
movl %edx, (%rdi,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x3a185
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
testl %eax, %eax
jle 0x3a231
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
xorl %ecx, %ecx
xorl %esi, %esi
cmpb %bl, (%r14,%rdx)
sete %sil
addl %esi, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x3a21b
jmp 0x3a233
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
orb %al, %cl
jne 0x3a2b7
movq %rsi, %r14
movq %rdi, %r15
callq 0x4190
movq %rax, %r12
movq %r14, %rdi
callq 0x4190
cmpl %eax, %r12d
jl 0x3a2b7
subl %eax, %r12d
incl %r12d
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
movl $0x0, %esi
testl %eax, %eax
jle 0x3a2a4
xorl %esi, %esi
movb (%r15,%rsi), %dil
cmpb (%r14,%rsi), %dil
jne 0x3a2a4
incq %rsi
cmpq %rsi, %rcx
jne 0x3a290
movl %eax, %esi
cmpl %eax, %esi
je 0x3a2b5
incq %rdx
incq %r15
cmpq %r12, %rdx
jne 0x3a285
jmp 0x3a2b7
movl %edx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x3a302
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %edx, %edx
jle 0x3a30c
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r13d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rsi
movq %r15, %rdi
callq 0x3a318
testl %eax, %eax
je 0x3a309
incq %r12
cmpq %r12, %r13
jne 0x3a2e8
jmp 0x3a30c
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x3a30c
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl %eax, %r15d
movl %eax, %ecx
cmovll %r15d, %ecx
testl %ecx, %ecx
jle 0x3a382
movl %ecx, %ecx
xorl %edx, %edx
movzbl (%r14,%rdx), %esi
leal -0x61(%rsi), %edi
leal -0x20(%rsi), %r8d
cmpb $0x1a, %dil
movzbl %r8b, %edi
cmovael %esi, %edi
movzbl (%rbx,%rdx), %esi
leal -0x61(%rsi), %r8d
leal -0x20(%rsi), %r9d
cmpb $0x1a, %r8b
movzbl %r9b, %r8d
cmovael %esi, %r8d
cmpb %r8b, %dil
jl 0x3a394
jg 0x3a39b
incq %rdx
cmpq %rdx, %rcx
jne 0x3a344
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %eax, %r15d
jl 0x3a3a0
setg %al
movzbl %al, %ecx
jmp 0x3a3a0
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x3a3a0
movl $0x1, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
callq 0x4280
xorl %r12d, %r12d
testq %rax, %rax
je 0x3a46a
movq %rax, %rsi
callq 0x3a404
movq %rax, (%r14,%r12,8)
incq %r12
xorl %edi, %edi
movq %r15, %rsi
callq 0x4280
jmp 0x3a44a
movl %r12d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movl %edx, 0x4(%rsp)
movl %edx, %esi
callq 0x3c6e5
movq %rax, 0x8(%rsp)
movq %rdx, %r12
testl %ebp, %ebp
jle 0x3a4fd
movl %ebp, %eax
movq %rax, 0x10(%rsp)
movl 0x4(%rsp), %r15d
shlq $0x3, %r15
leaq 0x6c745(%rip), %r13     # 0xa6c10
xorl %ebx, %ebx
cmpl $0x0, 0x4(%rsp)
jle 0x3a4f3
xorl %ebp, %ebp
movq (%r12,%rbx,8), %rdx
addq %rbp, %rdx
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %rbp
cmpq %rbp, %r15
jne 0x3a4d6
incq %rbx
cmpq 0x10(%rsp), %rbx
jne 0x3a4cd
movq 0x8(%rsp), %rax
movq %r12, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r15
leaq (,%r15,8), %rdi
leaq 0x6c69a(%rip), %rsi     # 0xa6bd0
movl $0x3, %edx
callq 0x390f5
movq %rax, %r14
testl %r15d, %r15d
jle 0x3a56e
movl %ebp, %r13d
leaq 0x6c6be(%rip), %r15     # 0xa6c10
movq %r14, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
addq $0x8, %r12
decq %r13
jne 0x3a555
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r15
leaq (,%r15,4), %rdi
leaq 0x6c639(%rip), %rsi     # 0xa6bdb
movl $0x2, %edx
callq 0x390f5
movq %rax, %r14
testl %r15d, %r15d
jle 0x3a5da
movl %ebp, %r13d
leaq 0x7359f(%rip), %r15     # 0xadb5d
movq %r14, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
addq $0x4, %r12
decq %r13
jne 0x3a5c1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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
subq $0x18, %rsp
movl %edx, %ecx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x6c5e2(%rip), %r8      # 0xa6bea
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl %ecx, 0xc(%rsp)
movl $0x3, %r9d
callq 0x393b5
movq %rax, %r15
testl %ebp, %ebp
jle 0x3a673
movl %ebp, %eax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %ebp
shlq $0x3, %rbp
leaq 0x6c5d0(%rip), %r12     # 0xa6c10
xorl %ebx, %ebx
cmpl $0x0, 0xc(%rsp)
jle 0x3a669
xorl %r13d, %r13d
movq (%r15,%rbx,8), %rdx
addq %r13, %rdx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %r13
cmpq %r13, %rbp
jne 0x3a64c
incq %rbx
cmpq 0x10(%rsp), %rbx
jne 0x3a642
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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, %r14
movq %rdi, %r15
movslq 0x1c0(%rsi), %rdi
shlq $0x4, %rdi
leaq 0x6c551(%rip), %rsi     # 0xa6bf9
movl $0x3, %edx
callq 0x390f5
movq %rax, %rbx
cmpl $0x0, 0x1c0(%r14)
jle 0x3a700
leaq 0x8(%rbx), %rbp
xorl %r13d, %r13d
xorl %r12d, %r12d
leaq (%rbx,%r13), %rdx
movq %rbp, %rcx
addq %r13, %rcx
movq %r15, %rdi
leaq 0x6c530(%rip), %rsi     # 0xa6c0d
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, (%rbx,%r13)
je 0x3a72a
incq %r12
movslq 0x1c0(%r14), %rax
addq $0x10, %r13
cmpq %rax, %r12
jl 0x3a6c9
jmp 0x3a703
xorl %r12d, %r12d
shlq $0x4, %r12
movl $0xffffffff, (%rbx,%r12) # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rbx,%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl %r12d
addq $0x10, %r13
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x390c8
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %r12
leaq (,%r12,8), %rdi
leaq 0x6c4a2(%rip), %rsi     # 0xa6c14
movl $0x3, %edx
callq 0x390f5
movq %rax, %r15
testl %r12d, %r12d
jle 0x3a7a1
movl %ebp, %r12d
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a685
movq %rax, (%r15,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x3a78a
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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 0x6c441(%rip), %rsi     # 0xa6c2e
movl $0x3, %edx
callq 0x390f5
movq %rax, %r12
movq %rax, (%r14)
xorl %eax, %eax
movq %rax, 0x28(%r14)
movq %rax, 0x8(%r14)
cmpl $0x0, 0x1c0(%rbx)
jle 0x3a859
leaq 0x6c3f9(%rip), %r13     # 0xa6c10
xorl %ebp, %ebp
movl 0x1407128(%rbx), %eax
cmpq %rax, %rbp
jne 0x3a836
cmpl $0x0, 0x10(%rbx)
je 0x3a836
movq %r15, %rdi
leaq 0x73329(%rip), %rsi     # 0xadb5d
jmp 0x3a83c
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
incq %rbp
movslq 0x1c0(%rbx), %rax
addq $0x8, %r12
cmpq %rax, %rbp
jl 0x3a819
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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 0x6c3ab(%rip), %rsi     # 0xa6c3c
movl $0x3, %edx
callq 0x390f5
movq %rax, %r12
movq %rax, (%r14)
xorl %eax, %eax
movq %rax, 0x28(%r14)
movq %r14, (%rsp)
movq %rax, 0x8(%r14)
cmpl $0x0, 0x1bc(%rbx)
jle 0x3a91f
leaq 0x30f08(%rbx), %r13
movl $0x15, %r14d
xorl %ebp, %ebp
movl (%r13), %esi
cmpl $0x4, %esi
ja 0x3a90f
movq %r15, %rdi
btl %esi, %r14d
jae 0x3a8e2
leaq 0x6c330(%rip), %rsi     # 0xa6c10
jmp 0x3a8e9
leaq 0x73274(%rip), %rsi     # 0xadb5d
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
incq %rbp
movslq 0x1bc(%rbx), %rax
addq $0x8, %r12
addq $0x340, %r13            # imm = 0x340
cmpq %rax, %rbp
jl 0x3a8c7
jmp 0x3a91f
leaq 0x68a58(%rip), %rdi     # 0xa336e
xorl %eax, %eax
callq 0x4030
jmp 0x3a8f3
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_O1/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 0x6c30f(%rip), %rsi     # 0xa6c53
movl $0x10, %edi
movl $0x2, %edx
callq 0x390f5
movq %rax, %r15
leaq 0x73200(%rip), %rsi     # 0xadb5d
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3a514
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6c2cb(%rip), %rsi     # 0xa6c68
movl $0x18, %edi
movl $0x4, %edx
callq 0x390f5
movq %rax, %r15
xorl %ebp, %ebp
xorl %r12d, %r12d
movq %rbp, %r13
movl $0x30, %edi
leaq 0x6c2a5(%rip), %rsi     # 0xa6c68
movl $0x7, %edx
callq 0x390f5
movq %rax, %rbp
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3a7c7
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups %xmm2, 0x20(%rbp)
movups %xmm1, 0x10(%rbp)
movups %xmm0, (%rbp)
leaq 0x10(%r13), %rax
testq %r13, %r13
cmoveq %r15, %rax
movq %rbp, (%rax)
incl %r12d
movl 0x10(%r14), %esi
cmpl %esi, %r12d
jl 0x3a9b4
movq $0x0, 0x10(%rbp)
movq %rbx, %rdi
callq 0x3a514
movq %rax, 0x8(%r15)
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x3a514
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_O1/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 0x730f7(%rip), %rsi     # 0xadb5d
xorl %ebp, %ebp
leaq 0x4(%rsp), %rdx
xorl %eax, %eax
callq 0x4070
xorl %r15d, %r15d
movl $0x30, %edi
leaq 0x6c1f9(%rip), %rsi     # 0xa6c7c
movl $0x6, %edx
callq 0x390f5
movq %rax, %r13
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3a86b
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups %xmm2, 0x20(%r13)
movups %xmm1, 0x10(%r13)
movups %xmm0, (%r13)
movq %r13, %rax
testq %rbp, %rbp
je 0x3aacd
movq %r13, 0x10(%rbp)
movq %r12, %rax
incl %r15d
movq %rax, %r12
movq %r13, %rbp
cmpl 0x4(%rsp), %r15d
jl 0x3aa77
movq $0x0, 0x10(%r13)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsi, %r15
movq %rdi, %r14
xorl %eax, %eax
movq %rax, 0xa0(%rdx)
movq %rax, 0x58(%rdx)
addq $0x30, %rdx
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movq %rax, 0x20(%rbx)
leaq 0x73032(%rip), %rsi     # 0xadb5d
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, 0x30(%rbx)
je 0x3abb3
movl 0x1c0(%r15), %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x3a488
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
leaq 0x6c130(%rip), %r12     # 0xa6c8b
movl $0x160, %edi            # imm = 0x160
movq %r12, %rsi
movl $0x14, %edx
callq 0x390f5
movq %rax, (%rbx)
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3aaf4
movq (%rbx), %rax
movq %rbx, 0x18(%rax)
movl $0x160, %edi            # imm = 0x160
movq %r12, %rsi
movl $0x17, %edx
callq 0x390f5
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3aaf4
movq 0x8(%rbx), %rax
movq %rbx, 0x18(%rax)
jmp 0x3ac0d
leaq 0x72fa3(%rip), %rsi     # 0xadb5d
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 0x3abf5
movl 0x1c0(%r15), %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x3a488
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
jmp 0x3ac0d
addq $0x48, %rbx
leaq 0x6c010(%rip), %rsi     # 0xa6c10
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_O1/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:
testl %ecx, %ecx
jle 0x3ae68
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl %ecx, %r13d
xorl %ebp, %ebp
leaq 0x6be80(%rip), %r12     # 0xa6cae
movl $0x160, %edi            # imm = 0x160
movq %r12, %rsi
movl $0x1e, %edx
callq 0x390f5
movq %rax, (%rbx,%rbp,8)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3ac19
incq %rbp
cmpq %rbp, %r13
jne 0x3ae2e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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, %r14
leaq 0x6be31(%rip), %rsi     # 0xa6cc1
movl $0x40, %edi
movl $0x2, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x4(%rax), %rcx
leaq 0x6aa39(%rip), %rsi     # 0xa58e6
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movl (%rbx), %esi
movl 0x1c0(%r15), %edx
decl %edx
movq %r14, %rdi
callq 0x3a488
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl (%rbx), %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x3a488
movq %rax, 0x20(%rbx)
movq %rdx, 0x28(%rbx)
movl (%rbx), %edx
movl 0x4(%rbx), %esi
incl %edx
movq %r14, %rdi
callq 0x3a488
movq %rax, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq