LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x3a8dd
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 0x3a8cb
movl $0x1, %r11d
movsd (%rdi,%r10,8), %xmm0
movsd (%rdx,%r11,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3a8c3
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 0x3a895
addq $0x4, %r8
addq $0x8, %rdx
decq %rcx
cmpq %rax, %r9
jne 0x3a884
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3a92f
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 0x3a927
xorl %ecx, %ecx
addl $-0x2b, %edi
cmpl $0x3a, %edi
ja 0x3a934
btq %rdi, %rsi
jae 0x3a934
incq %rdx
cmpq %rdx, %rax
jne 0x3a90b
movl $0x1, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3a938
testl %eax, %eax
je 0x3a9c5
movq %r12, %rdi
callq 0x4200
cmpl %r14d, %eax
jge 0x3a9da
leaq 0x6f0ac(%rip), %rdi     # 0xa9a68
xorl %ebp, %ebp
movl %eax, %esi
movl %r14d, %edx
jmp 0x3a9eb
leaq 0x6f13f(%rip), %rdi     # 0xa9b0b
xorl %ebp, %ebp
movq %r12, %rsi
xorl %eax, %eax
callq 0x4030
jmp 0x3a9fc
cmpl %ebx, %eax
jle 0x3a9f4
leaq 0x6f0d5(%rip), %rdi     # 0xa9aba
xorl %ebp, %ebp
movl %eax, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4030
jmp 0x3a9fc
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_O3/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 0x3a8ed
testl %eax, %eax
je 0x3aa46
movq %r14, %rdi
callq 0x4130
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3aa5b
leaq 0x6f0dd(%rip), %rdi     # 0xa9b21
jmp 0x3aa6e
leaq 0x6f17f(%rip), %rdi     # 0xa9bcc
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x4030
jmp 0x3aa82
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3aa79
leaq 0x6f109(%rip), %rdi     # 0xa9b77
movb $0x2, %al
callq 0x4030
xorl %ebx, %ebx
jmp 0x3aa82
movsd %xmm0, (%rbx)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3aad0
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 0x3ab35
movl -0x80(%rsp), %ecx
movq -0x70(%rsp), %rdx
movq -0x78(%rsp), %r8
cmpl $0x28, %ecx
ja 0x3ab19
movq %r8, %r9
movl %ecx, %r8d
addq %rdx, %r8
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x3ab22
leaq 0x8(%r8), %r9
movq %r9, -0x78(%rsp)
cmpl %edi, (%r8)
je 0x3ab30
movq %r9, %r8
decl %esi
jne 0x3ab02
jmp 0x3ab35
movl $0x1, %eax
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3ab92
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 0x3ac2b
movl (%rsp), %eax
cmpq $0x28, %rax
ja 0x3abd4
movq %rax, %rsi
addq 0x10(%rsp), %rsi
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x3abe2
movq 0x8(%rsp), %rsi
leaq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rsp)
testl %edi, %edi
jle 0x3ac18
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
cmpl $0x28, %eax
ja 0x3ac05
movq %rdx, %r8
movl %eax, %edx
addq %rcx, %rdx
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x3ac0e
leaq 0x8(%rdx), %r8
movq %r8, 0x8(%rsp)
movq %rdx, %rsi
movq %r8, %rdx
decl %edi
jne 0x3abf0
movq (%rsi), %rsi
leaq 0x6d32e(%rip), %rdi     # 0xa7f50
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4030
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6ed44(%rip), %rsi     # 0xa9bf0
movl $0x1, %edx
callq 0x3a0e1
movq %rax, %rcx
testl %r14d, %r14d
jle 0x3af15
movl %ebx, %edi
xorl %r8d, %r8d
movabsq $0x200000005, %r9       # imm = 0x200000005
movslq 0x9a5e0(%rip), %rax     # 0xd54b4
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, 0x9a5af(%rip)     # 0xd54b4
xorl %edx, %edx
divl %ebx
movl %edx, (%rcx,%r8,4)
incq %r8
cmpq %r8, %rdi
jne 0x3aecd
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9a543(%rip), %rax     # 0xd54b4
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, 0x9a4fe(%rip)     # 0xd54b4
movl $0xd1b1b919, %ecx       # imm = 0xD1B1B919
imulq %rax, %rcx
shrq $0x2d, %rcx
imull $0x2711, %ecx, %ecx     # imm = 0x2711
subl %ecx, %eax
subsd %xmm0, %xmm1
divsd 0x6ec11(%rip), %xmm1    # 0xa9be8
cvtsi2sd %eax, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6ec04(%rip), %rsi     # 0xa9c00
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %rcx
testl %r14d, %r14d
jle 0x3b105
movl %ebx, %edi
leal 0x1(%rbx), %eax
andl $-0x2, %eax
leaq -0x1(%rdi), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x6b410(%rip), %xmm1    # 0xa6440
xorl %edx, %edx
movdqa 0x6b416(%rip), %xmm2    # 0xa6450
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x6b446(%rip), %xmm4    # 0xa6490
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x3b07f
movl %edx, (%rcx,%rdx,4)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x3b095
leal 0x1(%rdx), %esi
movl %esi, 0x4(%rcx,%rdx,4)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rax
jne 0x3b04a
testl %ebx, %ebx
jle 0x3b105
xorl %r8d, %r8d
movabsq $0x200000005, %r9       # imm = 0x200000005
movslq 0x9a3fa(%rip), %rax     # 0xd54b4
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, 0x9a3c9(%rip)     # 0xd54b4
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 0x3b0b3
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6ead6(%rip), %rsi     # 0xa9c0d
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %rcx
testl %r14d, %r14d
jle 0x3b1ef
movl 0x9a361(%rip), %eax     # 0xd54b4
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm1
divsd 0x6ea7d(%rip), %xmm1    # 0xa9be8
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 0x3b180
movl %eax, 0x9a2c5(%rip)     # 0xd54b4
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b259
movl %edx, %ecx
incl %ecx
movl %esi, %r8d
xorl %r9d, %r9d
movabsq $0x200000005, %r10      # imm = 0x200000005
movslq 0x9a29b(%rip), %rax     # 0xd54b4
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, 0x9a26a(%rip)     # 0xd54b4
cltd
idivl %ecx
movl %edx, (%rdi,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x3b212
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b2c1
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 0x3b2ab
jmp 0x3b2c3
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b347
movq %rsi, %r14
movq %rdi, %r15
callq 0x4190
movq %rax, %r12
movq %r14, %rdi
callq 0x4190
cmpl %eax, %r12d
jl 0x3b347
subl %eax, %r12d
incl %r12d
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movl $0x0, %esi
testl %eax, %eax
jle 0x3b334
xorl %esi, %esi
movb (%r15,%rsi), %dil
cmpb (%r14,%rsi), %dil
jne 0x3b334
incq %rsi
cmpq %rsi, %rdx
jne 0x3b320
jmp 0x3b345
cmpl %eax, %esi
je 0x3b345
incq %rcx
incq %r15
cmpq %r12, %rcx
jne 0x3b315
jmp 0x3b347
movl %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b392
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %edx, %edx
jle 0x3b39c
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %r13d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rsi
movq %r15, %rdi
callq 0x3b3a8
testl %eax, %eax
je 0x3b399
incq %r12
cmpq %r12, %r13
jne 0x3b378
jmp 0x3b39c
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x3b39c
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b412
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 0x3b424
jg 0x3b42b
incq %rdx
cmpq %rdx, %rcx
jne 0x3b3d4
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %eax, %r15d
jl 0x3b430
setg %al
movzbl %al, %ecx
jmp 0x3b430
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x3b430
movl $0x1, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b4fa
movq %rax, %rsi
callq 0x3b494
movq %rax, (%r14,%r12,8)
incq %r12
xorl %edi, %edi
movq %r15, %rsi
callq 0x4280
jmp 0x3b4da
movl %r12d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3d79d
movq %rax, 0x8(%rsp)
movq %rdx, %r12
testl %ebp, %ebp
jle 0x3b58d
movl %ebp, %eax
movq %rax, 0x10(%rsp)
movl 0x4(%rsp), %r15d
shlq $0x3, %r15
leaq 0x6e725(%rip), %r13     # 0xa9c80
xorl %ebx, %ebx
cmpl $0x0, 0x4(%rsp)
jle 0x3b583
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 0x3b566
incq %rbx
cmpq 0x10(%rsp), %rbx
jne 0x3b55d
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_O3/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 0x6e67a(%rip), %rsi     # 0xa9c40
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %r14
testl %r15d, %r15d
jle 0x3b5fe
movl %ebp, %r13d
leaq 0x6e69e(%rip), %r15     # 0xa9c80
movq %r14, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
addq $0x8, %r12
decq %r13
jne 0x3b5e5
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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 0x6e619(%rip), %rsi     # 0xa9c4b
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r14
testl %r15d, %r15d
jle 0x3b66a
movl %ebp, %r13d
leaq 0x755a7(%rip), %r15     # 0xb0bf5
movq %r14, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
addq $0x4, %r12
decq %r13
jne 0x3b651
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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 0x6e5c2(%rip), %r8      # 0xa9c5a
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl %ecx, 0xc(%rsp)
movl $0x3, %r9d
callq 0x3a3ac
movq %rax, %r15
testl %ebp, %ebp
jle 0x3b703
movl %ebp, %eax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %ebp
shlq $0x3, %rbp
leaq 0x6e5b0(%rip), %r12     # 0xa9c80
xorl %ebx, %ebx
cmpl $0x0, 0xc(%rsp)
jle 0x3b6f9
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 0x3b6dc
incq %rbx
cmpq 0x10(%rsp), %rbx
jne 0x3b6d2
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_O3/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 0x6e531(%rip), %rsi     # 0xa9c69
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %rbx
cmpl $0x0, 0x1c0(%r14)
jle 0x3b790
leaq 0x8(%rbx), %rbp
xorl %r13d, %r13d
xorl %r12d, %r12d
leaq (%rbx,%r13), %rdx
movq %rbp, %rcx
addq %r13, %rcx
movq %r15, %rdi
leaq 0x6e510(%rip), %rsi     # 0xa9c7d
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, (%rbx,%r13)
je 0x3b7ba
incq %r12
movslq 0x1c0(%r14), %rax
addq $0x10, %r13
cmpq %rax, %r12
jl 0x3b759
jmp 0x3b793
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 0x3a0b4
// File: /workspace/github_c_makefile_star2_O3/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 0x6e482(%rip), %rsi     # 0xa9c84
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %r15
testl %r12d, %r12d
jle 0x3b831
movl %ebp, %r12d
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b715
movq %rax, (%r15,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x3b81a
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_O3/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 0x6e421(%rip), %rsi     # 0xa9c9e
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %r12
movq %rax, (%r14)
xorl %eax, %eax
movq %rax, 0x28(%r14)
movq %rax, 0x8(%r14)
cmpl $0x0, 0x1c0(%rbx)
jle 0x3b8e9
leaq 0x6e3d9(%rip), %r13     # 0xa9c80
xorl %ebp, %ebp
movl 0x1407128(%rbx), %eax
cmpq %rax, %rbp
jne 0x3b8c6
cmpl $0x0, 0x10(%rbx)
je 0x3b8c6
movq %r15, %rdi
leaq 0x75331(%rip), %rsi     # 0xb0bf5
jmp 0x3b8cc
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 0x3b8a9
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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 0x6e38b(%rip), %rsi     # 0xa9cac
movl $0x3, %edx
callq 0x3a0e1
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 0x3b9af
leaq 0x30f08(%rbx), %r13
movl $0x15, %r14d
xorl %ebp, %ebp
movl (%r13), %esi
cmpl $0x4, %esi
ja 0x3b99f
movq %r15, %rdi
btl %esi, %r14d
jae 0x3b972
leaq 0x6e310(%rip), %rsi     # 0xa9c80
jmp 0x3b979
leaq 0x7527c(%rip), %rsi     # 0xb0bf5
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 0x3b957
jmp 0x3b9af
leaq 0x6a9c8(%rip), %rdi     # 0xa636e
xorl %eax, %eax
callq 0x4030
jmp 0x3b983
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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 0x6e2ef(%rip), %rsi     # 0xa9cc3
movl $0x10, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r15
leaq 0x75208(%rip), %rsi     # 0xb0bf5
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3b5a4
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6e2ab(%rip), %rsi     # 0xa9cd8
movl $0x18, %edi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r15
xorl %ebp, %ebp
xorl %r12d, %r12d
movq %rbp, %r13
movl $0x30, %edi
leaq 0x6e285(%rip), %rsi     # 0xa9cd8
movl $0x7, %edx
callq 0x3a0e1
movq %rax, %rbp
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3b857
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 0x3ba44
movq $0x0, 0x10(%rbp)
movq %rbx, %rdi
callq 0x3b5a4
movq %rax, 0x8(%r15)
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x3b5a4
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_O3/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 0x750ff(%rip), %rsi     # 0xb0bf5
xorl %ebp, %ebp
leaq 0x4(%rsp), %rdx
xorl %eax, %eax
callq 0x4070
xorl %r15d, %r15d
movl $0x30, %edi
leaq 0x6e1d9(%rip), %rsi     # 0xa9cec
movl $0x6, %edx
callq 0x3a0e1
movq %rax, %r13
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3b8fb
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 0x3bb5d
movq %r13, 0x10(%rbp)
movq %r12, %rax
incl %r15d
movq %rax, %r12
movq %r13, %rbp
cmpl 0x4(%rsp), %r15d
jl 0x3bb07
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_O3/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 0x7503a(%rip), %rsi     # 0xb0bf5
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, 0x30(%rbx)
je 0x3bc43
movl 0x1c0(%r15), %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x3b518
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
leaq 0x6e110(%rip), %r12     # 0xa9cfb
movl $0x160, %edi            # imm = 0x160
movq %r12, %rsi
movl $0x14, %edx
callq 0x3a0e1
movq %rax, (%rbx)
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3bb84
movq (%rbx), %rax
movq %rbx, 0x18(%rax)
movl $0x160, %edi            # imm = 0x160
movq %r12, %rsi
movl $0x17, %edx
callq 0x3a0e1
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3bb84
movq 0x8(%rbx), %rax
movq %rbx, 0x18(%rax)
jmp 0x3bc9d
leaq 0x74fab(%rip), %rsi     # 0xb0bf5
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 0x3bc85
movl 0x1c0(%r15), %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x3b518
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
jmp 0x3bc9d
addq $0x48, %rbx
leaq 0x6dff0(%rip), %rsi     # 0xa9c80
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_O3/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 0x3bef8
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 0x6de60(%rip), %r12     # 0xa9d1e
movl $0x160, %edi            # imm = 0x160
movq %r12, %rsi
movl $0x1e, %edx
callq 0x3a0e1
movq %rax, (%rbx,%rbp,8)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3bca9
incq %rbp
cmpq %rbp, %r13
jne 0x3bebe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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 0x6de11(%rip), %rsi     # 0xa9d31
movl $0x40, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x4(%rax), %rcx
leaq 0x6ca21(%rip), %rsi     # 0xa895e
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4070
movl (%rbx), %esi
movl 0x1c0(%r15), %edx
decl %edx
movq %r14, %rdi
callq 0x3b518
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movl (%rbx), %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x3b518
movq %rax, 0x20(%rbx)
movq %rdx, 0x28(%rbx)
movl (%rbx), %edx
movl 0x4(%rbx), %esi
incl %edx
movq %r14, %rdi
callq 0x3b518
movq %rax, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6dd8c(%rip), %rsi     # 0xa9d40
movl $0x98, %edi
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x8(%rax), %rcx
leaq 0xc(%rax), %r15
leaq 0x5c(%rax), %r12
leaq 0x6c982(%rip), %rsi     # 0xa895b
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %r8
xorl %eax, %eax
callq 0x4070
movl 0x5c(%rbx), %eax
testl %eax, %eax
movq %r15, (%rsp)
jle 0x3c026
leaq 0x50(%rbx), %r13
leaq 0x74bf6(%rip), %rbp     # 0xb0bf5
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4070
incq %r15
movslq (%r12), %rax
addq $0x4, %r13
cmpq %rax, %r15
jl 0x3c002
movq (%rsp), %r15
movq %r14, 0x8(%rsp)
movslq %eax, %rdi
shlq $0x4, %rdi
addq $0x10, %rdi
leaq 0x6dd03(%rip), %rsi     # 0xa9d40
movl $0x7, %edx
callq 0x3a0e1
movq %rax, (%rbx)
movl 0x5c(%rbx), %eax
testl %eax, %eax
jle 0x3c0af
leaq 0x50(%rbx), %r12
movl $0x8, %r13d
xorl %ebp, %ebp
movq %r12, 0x10(%rsp)
movq 0x8(%rsp), %r15
leaq -0x4(%r12), %rax
testq %rbp, %rbp
cmoveq (%rsp), %rax
movq %r12, %rcx
cmoveq 0x10(%rsp), %rcx
movq (%rbx), %r14
movl (%rcx), %esi
movl (%rax), %edx
incl %edx
movq %r15, %rdi
callq 0x3b518
movq %rax, -0x8(%r14,%r13)
movq %rdx, (%r14,%r13)
incq %rbp
movslq 0x5c(%rbx), %rax
addq $0x4, %r12
addq $0x10, %r13
cmpq %rax, %rbp
jl 0x3c067
movq (%rsp), %r15
cltq
movq %rax, %r14
shlq $0x4, %r14
subl $0x1, %eax
cltq
leaq 0x50(%rbx,%rax,4), %rax
cmovbq %r15, %rax
movq (%rbx), %r15
movl 0x8(%rbx), %esi
movl (%rax), %edx
incl %edx
movq 0x8(%rsp), %rdi
callq 0x3b518
movq %rax, (%r15,%r14)
movq %rdx, 0x8(%r15,%r14)
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_O3/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 0x6dc08(%rip), %rsi     # 0xa9d0f
movl $0x160, %edi            # imm = 0x160
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %rbx
xorl %eax, %eax
movq %rax, 0x58(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movq %rax, 0x20(%rbx)
movl $0x1, 0x98(%rbx)
leaq 0x30(%rbx), %rdx
leaq 0x74ab3(%rip), %rsi     # 0xb0bf5
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, 0x30(%rbx)
je 0x3c1ba
movq %rbx, %rdx
addq $0x48, %rdx
leaq 0x6db20(%rip), %rsi     # 0xa9c80
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x1c0(%r15), %edx
decl %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x3b518
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
movq $0x0, 0xa0(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c0f5
movq %rax, (%rbx)
movq %rbx, 0x18(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c0f5
movq %rax, 0x8(%rbx)
movq %rbx, 0x18(%rax)
jmp 0x3c1e5
movq %rbx, %rdx
addq $0x34, %rdx
leaq 0x74a2d(%rip), %rsi     # 0xb0bf5
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x10(%r15), %esi
movq %r14, %rdi
callq 0x3b610
movq %rax, 0xa0(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6db53(%rip), %rsi     # 0xa9d56
movl $0x160, %edi            # imm = 0x160
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r15
xorl %eax, %eax
movq %rax, 0x58(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
movl $0x2, 0x98(%r15)
leaq 0x30(%r15), %rdx
leaq 0x749b4(%rip), %rsi     # 0xb0bf5
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x30(%r15), %eax
movq %r15, %rdx
cmpl $-0x3, %eax
je 0x3c2b4
cmpl $-0x2, %eax
je 0x3c28a
cmpl $-0x1, %eax
jne 0x3c2ed
addq $0x34, %rdx
leaq 0x74985(%rip), %rsi     # 0xb0bf5
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3b610
movq %rax, %r12
jmp 0x3c305
addq $0x48, %rdx
leaq 0x6d9eb(%rip), %rsi     # 0xa9c80
xorl %r12d, %r12d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movl 0x1c0(%rbx), %edx
decl %edx
movq %r14, %rdi
movl $0x1, %esi
jmp 0x3c2de
addq $0x48, %rdx
leaq 0x6d9c1(%rip), %rsi     # 0xa9c80
xorl %r12d, %r12d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movq %rbx, %rdi
callq 0x1372c
movq %r14, %rdi
movl $0x1, %esi
movl %eax, %edx
callq 0x3b518
movq %rax, 0x38(%r15)
movq %rdx, 0x40(%r15)
jmp 0x3c305
addq $0x28, %rdx
leaq 0x6d988(%rip), %rsi     # 0xa9c80
xorl %r12d, %r12d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4070
movq %r12, 0xa0(%r15)
cmpl $-0x1, 0x30(%r15)
je 0x3c330
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c1ee
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c1ee
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_O3/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 %r15d, %r15d
movl $0x30, %edi
leaq 0x6d974(%rip), %rsi     # 0xa9cd8
movl $0x7, %edx
callq 0x3a0e1
movq %rax, %r13
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3b8fb
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 0x3c3ae
movq %r13, 0x10(%rbp)
movq %r12, %rax
incl %r15d
movq %r13, %rbp
movq %rax, %r12
cmpl 0x10(%rbx), %r15d
jl 0x3c358
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_O3/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_naivebayes
void* load_model_naivebayes(FILE* infile, Datasetptr d)
{
 /*!Last Changed 11.08.2007*/
	int i, j;
 Model_naivebayesptr m;
 m = safemalloc(sizeof(Model_naivebayes), "load_model_naivebayes", 3);
	m->m = load_array_two(infile, d->classno, d->featurecount);
	m->priors = load_array(infile, d->classno);
	m->s = load_array(infile, d->classno);
	m->p = safemalloc(d->classno * sizeof(double **), "load_model_naivebayes", 7);
 for (i = 0; i < d->classno; i++)
	 {
		 m->p[i] = safemalloc(d->featurecount * sizeof(double *), "load_model_naivebayes", 10);
		 for (j = 0; j < d->featurecount; j++)
				 if (d->features[j].type == STRING)
						 m->p[i][j] = load_array(infile, d->features[j].valuecount);
	 }
 return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6d985(%rip), %r12     # 0xa9d71
movl $0x20, %edi
movq %r12, %rsi
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %r15
movl 0x10(%rbx), %esi
movl 0x1bc(%rbx), %edx
movq %r14, %rdi
callq 0x3b67c
movq %rax, (%r15)
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3b5a4
movq %rax, 0x10(%r15)
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x3b5a4
movq %rax, 0x8(%r15)
movslq 0x10(%rbx), %rdi
shlq $0x3, %rdi
movq %r12, %rsi
movl $0x7, %edx
callq 0x3a0e1
movq %rax, 0x18(%r15)
cmpl $0x0, 0x10(%rbx)
jle 0x3c4dd
movl 0x1bc(%rbx), %eax
leaq 0x30f20(%rbx), %rcx
movq %rcx, (%rsp)
xorl %ebp, %ebp
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x6d8fa(%rip), %rsi     # 0xa9d71
movl $0xa, %edx
callq 0x3a0e1
movq 0x18(%r15), %rcx
movq %rax, (%rcx,%rbp,8)
movl 0x1bc(%rbx), %eax
testl %eax, %eax
jle 0x3c4d1
movq (%rsp), %r13
xorl %r12d, %r12d
cmpl $0x1, -0x18(%r13)
jne 0x3c4bf
movl (%r13), %esi
movq %r14, %rdi
callq 0x3b5a4
movq 0x18(%r15), %rcx
movq (%rcx,%rbp,8), %rcx
movq %rax, (%rcx,%r12,8)
movl 0x1bc(%rbx), %eax
incq %r12
movslq %eax, %rcx
addq $0x340, %r13            # imm = 0x340
cmpq %rcx, %r12
jl 0x3c49a
incq %rbp
movslq 0x10(%rbx), %rcx
cmpq %rcx, %rbp
jl 0x3c469
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq