LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4230
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x54c67
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
callq 0x54ba0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x4230
movq %rax, -0x28(%rbp)
jmp 0x54c20
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x57fc0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x54d54
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x54d47
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movslq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x91a93(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x54d0b
jmp 0x54d49
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x54cfc
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x919fa(%rip), %rsi     # 0xe6788
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x54dd7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movslq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x91a03(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x54da3
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
leaq 0x91985(%rip), %rsi     # 0xe6793
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x54e57
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x98420(%rip), %rsi     # 0xed265
movb $0x0, %al
callq 0x4070
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x54e23
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movl $0x8, %esi
leaq 0x9190e(%rip), %r8      # 0xe67a2
movl $0x3, %r9d
movq %rsi, %rdi
callq 0x53120
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x54f05
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x54ef8
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x918e2(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x54ebc
jmp 0x54efa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x54ead
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq 0x1c0(%rax), %rdi
shlq $0x4, %rdi
leaq 0x9187b(%rip), %rsi     # 0xe67b1
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1c0(%rcx), %eax
jge 0x54fe0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movslq -0x24(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
addq $0x8, %rcx
leaq 0x9183a(%rip), %rsi     # 0xe67c5
movb $0x0, %al
callq 0x4070
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
jne 0x54fd0
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x4, %rsi
movl -0x24(%rbp), %edx
addl $0x1, %edx
callq 0x52d10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x55014
jmp 0x54fd2
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x54f4b
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x9178a(%rip), %rsi     # 0xe67cc
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x55086
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x54f10
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x55057
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq 0x1c0(%rax), %rdi
shlq $0x3, %rdi
leaq 0x916e5(%rip), %rsi     # 0xe67e6
movl $0x3, %edx
callq 0x52d70
movq -0x20(%rbp), %rdi
movq %rax, (%rdi)
movq $0x0, 0x28(%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c0(%rcx), %eax
jge 0x551d7
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1407128(%rcx), %eax
je 0x55171
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq (%rax), %rdx
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x91660(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
jmp 0x551c7
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x551a1
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq (%rax), %rdx
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x91630(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
jmp 0x551c5
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq (%rax), %rdx
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x980a7(%rip), %rsi     # 0xed265
movb $0x0, %al
callq 0x4070
jmp 0x551c7
jmp 0x551c9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x55129
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq 0x1bc(%rax), %rdi
shlq $0x3, %rdi
leaq 0x915d6(%rip), %rsi     # 0xe67f4
movl $0x3, %edx
callq 0x52d70
movq -0x20(%rbp), %rdi
movq %rax, (%rdi)
movq $0x0, 0x28(%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x55324
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x552a0
jmp 0x55278
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x552c6
jmp 0x55282
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x552a0
jmp 0x5528c
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0x552c6
jmp 0x55296
movl -0x2c(%rbp), %eax
subl $0x4, %eax
jne 0x552ec
jmp 0x552a0
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq (%rax), %rdx
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x9150b(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
jmp 0x55314
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq (%rax), %rdx
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x97f82(%rip), %rsi     # 0xed265
movb $0x0, %al
callq 0x4070
jmp 0x55314
movq -0x10(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x14(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl (%rax), %esi
leaq 0x8dce1(%rip), %rdi     # 0xe2fee
movb $0x0, %al
callq 0x4030
jmp 0x55316
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x55246
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
leaq 0x914bf(%rip), %rsi     # 0xe680b
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x97efc(%rip), %rsi     # 0xed265
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x54d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x18, %edi
leaq 0x9145c(%rip), %rsi     # 0xe6820
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x55462
movl $0x30, %edi
leaq 0x9142f(%rip), %rsi     # 0xe6820
movl $0x7, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
xorl %ecx, %ecx
callq 0x550d0
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x30, %edx
callq 0x42b0
cmpq $0x0, -0x30(%rbp)
je 0x55441
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5544c
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x553d9
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x54d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x54d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x97d92(%rip), %rsi     # 0xed265
leaq -0x14(%rbp), %rdx
movb $0x0, %al
callq 0x4070
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x55562
movl $0x30, %edi
leaq 0x9133b(%rip), %rsi     # 0xe6834
movl $0x6, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x551f0
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x30, %edx
callq 0x42b0
cmpq $0x0, -0x28(%rbp)
je 0x55547
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5554f
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x554e5
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_svmtree
void load_model_svmtree(FILE* infile, Datasetptr d, Decisionnodeptr* forest, int treecount)
{
 int i;
 for (i = 0; i < treecount; i++)
  {
   forest[i] = safemalloc(sizeof(Decisionnode), "load_model_svmtree", 30);
   load_model_c45(infile, d, forest[i]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x55a9f
movl $0x160, %edi            # imm = 0x160
leaq 0x90e04(%rip), %rsi     # 0xe6866
movl $0x1e, %edx
callq 0x52d70
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x55770
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x55a4e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x40, %edi
leaq 0x90d3d(%rip), %rsi     # 0xe6879
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
leaq 0x8f92d(%rip), %rsi     # 0xe548e
movb $0x0, %al
callq 0x4070
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %edx
subl $0x1, %edx
callq 0x54cc0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl $0x1, %esi
callq 0x54cc0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x18(%rbp), %rax
movl (%rax), %edx
addl $0x1, %edx
callq 0x54cc0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x160, %edi            # imm = 0x160
leaq 0x9098b(%rip), %rsi     # 0xe6857
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x98(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x30, %rdx
leaq 0x97323(%rip), %rsi     # 0xed265
movb $0x0, %al
callq 0x4070
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0x55f90
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x34, %rdx
leaq 0x972ff(%rip), %rsi     # 0xed265
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x54df0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xa0(%rax)
jmp 0x56049
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x48, %rdx
leaq 0x90825(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %edx
subl $0x1, %edx
movl $0x1, %esi
callq 0x54cc0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x55eb0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x55eb0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x56363
movl $0x30, %edi
leaq 0x90529(%rip), %rsi     # 0xe6820
movl $0x7, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x551f0
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x30, %edx
callq 0x42b0
cmpq $0x0, -0x30(%rbp)
je 0x56345
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5634d
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x562df
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, %edi
leaq 0x9051d(%rip), %rsi     # 0xe68b9
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x1bc(%rax), %edx
callq 0x54e70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x54d70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x54d70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x904a2(%rip), %rsi     # 0xe68b9
movl $0x7, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x56505
movq -0x10(%rbp), %rax
movslq 0x1bc(%rax), %rdi
shlq $0x3, %rdi
leaq 0x90460(%rip), %rsi     # 0xe68b9
movl $0xa, %edx
callq 0x52d70
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1bc(%rcx), %eax
jge 0x564f5
movq -0x10(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x18(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x564e8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x30f08, %rax          # imm = 0x30F08
movslq -0x18(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
addq %rcx, %rax
movl 0x18(%rax), %esi
callq 0x54d70
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x564ea
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5647d
jmp 0x564f7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x56433
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_qdaclass
void* load_model_qdaclass(FILE* infile, Datasetptr d)
{
 /*!Last Changed 05.08.2007*/
 Model_qdaclassptr m;
 int i;
 m = safemalloc(sizeof(Model_qdaclass), "load_model_qdaclass", 3);
 m->w0 = load_array(infile, d->classno);
 m->priors = load_array(infile, d->classno);
 m->W = safemalloc(d->classno * sizeof(matrix), "load_model_qdaclass", 5);
 for (i = 0; i < d->classno; i++)
   m->W[i] = load_matrix(infile, d->multifeaturecount - 1, d->multifeaturecount - 1);
 m->w = safemalloc(d->classno * sizeof(matrix), "load_model_qdaclass", 8);
 for (i = 0; i < d->classno; i++)
   m->w[i] = load_matrix(infile, 1, d->multifeaturecount - 1);
 return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, %edi
leaq 0x903a3(%rip), %rsi     # 0xe68cf
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x54d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x54d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x4, %rdi
leaq 0x9034c(%rip), %rsi     # 0xe68cf
movl $0x5, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x5660c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %esi
subl $0x1, %esi
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %edx
subl $0x1, %edx
callq 0x54cc0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5659e
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x4, %rdi
leaq 0x902b0(%rip), %rsi     # 0xe68cf
movl $0x8, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x566a2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %edx
subl $0x1, %edx
movl $0x1, %esi
callq 0x54cc0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5663b
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_ldaclass
void* load_model_ldaclass(FILE* infile, Datasetptr d)
{
 /*!Last Changed 26.12.2005*/
 Model_ldaclassptr m;
 int i;
 m = safemalloc(sizeof(Model_ldaclass), "load_model_ldaclass", 2);
 fscanf(infile, "%d %d", &(m->newfeaturecount), &(m->oldfeaturecount));
 m->w0 = load_array(infile, d->classno);
 m->w = safemalloc(d->classno * sizeof(matrix), "load_model_ldaclass", 5);
 for (i = 0; i < d->classno; i++)
   m->w[i] = load_matrix(infile, 1, m->newfeaturecount - 1);
 m->eigenvectors = load_matrix(infile, d->multifeaturecount - 1, d->multifeaturecount - 1);
 m->eigenvalues = NULL;
 return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x30, %edi
leaq 0x90217(%rip), %rsi     # 0xe68e3
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
leaq 0x8ed9d(%rip), %rsi     # 0xe548e
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x54d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x4, %rdi
leaq 0x901bd(%rip), %rsi     # 0xe68e3
movl $0x5, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x567a5
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
subl $0x1, %edx
movl $0x1, %esi
callq 0x54cc0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x56742
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %esi
subl $0x1, %esi
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %edx
subl $0x1, %edx
callq 0x54cc0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/loadmodel.c
// Function: load_condition
Decisionconditionptr load_condition(FILE* infile, Datasetptr d)
{
 /*!Last Changed 26.12.2005*/
 Decisionconditionptr condition;
 condition = safemalloc(sizeof(Decisioncondition), "load_condition", 2);
 fscanf(infile, "%d %c", &(condition->featureindex), &(condition->comparison));
 if (condition->featureindex >= 0)
  {
   if (condition->comparison != '*')
     fscanf(infile, "%lf", &(condition->value));
   else
    {
     fscanf(infile, "%lf", &(condition->lowerlimit));
     fscanf(infile, "%lf", &(condition->upperlimit));
    }
  }
 else
  {
   fscanf(infile, "%lf", &(condition->w0));
   condition->w = load_matrix(infile, 1, d->multifeaturecount - 1);
  }
 condition->next = NULL;
 return condition;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x70, %edi
leaq 0x8feaa(%rip), %rsi     # 0xe6906
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
leaq 0x8fe94(%rip), %rsi     # 0xe6915
movb $0x0, %al
callq 0x4070
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x56af0
movq -0x18(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x2a, %eax
je 0x56aba
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
leaq 0x8fd17(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
jmp 0x56aee
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x18, %rdx
leaq 0x8fcfb(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x10, %rdx
leaq 0x8fce1(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
jmp 0x56b4c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x30, %rdx
leaq 0x8fcc5(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %edx
subl $0x1, %edx
movl $0x1, %esi
callq 0x54cc0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/loadmodel.c
// Function: load_rule
Decisionruleptr load_rule(FILE* infile, Datasetptr d)
{
 /*!Last Changed 26.12.2005*/
 int i;
 Decisionruleptr rule;
 Decisionconditionptr tmp, tmpbefore;
 rule = safemalloc(sizeof(Decisionrule), "load_rule", 4);
 fscanf(infile, "%d%d%d%d", &(rule->classno), &(rule->decisioncount), &(rule->falsepositives), &(rule->covered));
 rule->counts = load_array_int(infile, d->classno);
 rule->start = load_condition(infile, d);
 tmpbefore = rule->start;
 tmp = rule->start;
 for (i = 1; i < rule->decisioncount; i++)
  {
   tmp = load_condition(infile, d);
   tmpbefore->next = tmp;
   tmpbefore = tmp;
  }
 rule->end = tmp;
 rule->next = NULL;
 return rule;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x38, %edi
leaq 0x8fd8f(%rip), %rsi     # 0xe691b
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x28, %rcx
movq -0x20(%rbp), %r8
addq $0x8, %r8
movq -0x20(%rbp), %r9
addq $0x4, %r9
leaq 0x8fd64(%rip), %rsi     # 0xe6925
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x54df0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x56a40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x56c56
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x56a40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x56c1a
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_ripper
void* load_model_ripper(FILE* infile, Datasetptr d)
{
 /*!Last Changed 26.12.2005*/
 int i;
 Rulesetptr m;
 Decisionruleptr tmp, tmpbefore;
 m = safemalloc(sizeof(Ruleset), "load_model_ripper", 4);
 fscanf(infile, "%d%d", &(m->defaultclass), &(m->rulecount));
 m->counts = load_array_int(infile, d->classno);
 if (m->rulecount > 0)
  {
   m->start = load_rule(infile, d);
   tmpbefore = m->start;
   tmp = m->start;
   for (i = 1; i < m->rulecount; i++)
    {
     tmp = load_rule(infile, d);
     tmpbefore->next = tmp;
     tmpbefore = tmp;
    }
   m->end = tmp;
  }
 else
  {
   m->start = NULL;
   m->end = NULL;
  }
 return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x28, %edi
leaq 0x8fc92(%rip), %rsi     # 0xe692e
movl $0x4, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
addq $0x14, %rdx
movq -0x20(%rbp), %rcx
addq $0x10, %rcx
leaq 0x8fc64(%rip), %rsi     # 0xe6929
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x54df0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x56d6f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x56b70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x56d61
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x56b70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x56d25
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x56d86
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_linearreg
void* load_model_linearreg(FILE* infile, Datasetptr d)
{
 /*!Last Changed 27.12.2005*/
	Model_linearregressionptr m;
	m = safemalloc(sizeof(Model_linearregression), "load_model_linearreg", 2);
	fscanf(infile, "%lf", &(m->b));
	m->w = load_matrix(infile, 1, d->multifeaturecount - 1);
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
leaq 0x8f6d7(%rip), %rsi     # 0xe69a3
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x8f4df(%rip), %rsi     # 0xe67c8
movb $0x0, %al
callq 0x4070
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %edx
subl $0x1, %edx
movl $0x1, %esi
callq 0x54cc0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_quantizereg
void* load_model_quantizereg(FILE* infile, Datasetptr d)
{
 /*!Last Changed 27.12.2005*/
	Model_quantizeregptr m;
	m = safemalloc(sizeof(Model_quantizereg), "load_model_quantizereg", 2);
	fscanf(infile, "%d", &(m->partitioncount));
	if (d->multifeaturecount == 2)
	 {
		 fscanf(infile, "%lf%lf", &(m->binx), &(m->minx));
			m->meansone = load_array(infile, m->partitioncount);
	 }
	else
	 {
		 fscanf(infile, "%lf%lf%lf%lf", &(m->binx), &(m->minx), &(m->biny), &(m->miny));
			m->meanstwo = load_array_two(infile, m->partitioncount, m->partitioncount);
			m->eigenvectors = load_matrix(infile, d->multifeaturecount - 1, d->multifeaturecount - 1);
	 }
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x48, %edi
leaq 0x8f65c(%rip), %rsi     # 0xe69b8
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x40, %rdx
leaq 0x95ee8(%rip), %rsi     # 0xed265
movb $0x0, %al
callq 0x4070
movq -0x10(%rbp), %rax
cmpl $0x2, 0x1c0(%rax)
jne 0x573cf
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
movq -0x18(%rbp), %rcx
leaq 0x8f5db(%rip), %rsi     # 0xe6983
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x40(%rax), %esi
callq 0x54d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x57469
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %r8
addq $0x18, %r8
movq -0x18(%rbp), %r9
addq $0x10, %r9
leaq 0x8f5d9(%rip), %rsi     # 0xe69cf
movb $0x0, %al
callq 0x4070
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x40(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x40(%rax), %edx
callq 0x54e70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %esi
subl $0x1, %esi
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %edx
subl $0x1, %edx
callq 0x54cc0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/loadmodel.c
// Function: load_model_gprocessreg
void* load_model_gprocessreg(FILE* infile, Datasetptr d)
{
 /*!Last Changed 15.01.2009*/
 int i;
 Model_gprocessregressionptr m;
 Instanceptr tmp, tmpbefore = NULL, head;
 m = safemalloc(sizeof(Model_gprocessregression), "load_model_gprocessreg", 2);
 fscanf(infile, "%d", &(m->size));
 for (i = 0; i < m->size; i++)
  {
   tmp = safemalloc(sizeof(Instance), "load_model_gprocessreg", 6);
   *tmp = load_instance(infile, d, BOOLEAN_TRUE);
   if (tmpbefore)
     tmpbefore->next = tmp;
   else
     head = tmp;
   tmpbefore = tmp;
  }
 tmp->next = NULL;
 m->data = head;
 m->weights = load_array(infile, m->size);
 return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x18, %edi
leaq 0x8ecaa(%rip), %rsi     # 0xe69fe
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x954f4(%rip), %rsi     # 0xed265
movb $0x0, %al
callq 0x4070
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x57e07
movl $0x30, %edi
leaq 0x8ec68(%rip), %rsi     # 0xe69fe
movl $0x6, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x68(%rbp), %rdi
movl $0x1, %ecx
callq 0x550d0
movq -0x70(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x30, %edx
callq 0x42b0
cmpq $0x0, -0x30(%rbp)
je 0x57de9
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x57df1
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x57d7f
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x54d70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/matrix.c
// Function: matrix_merge_rows
matrix matrix_merge_rows(matrix a, matrix b)
{
 /*!Last Changed 13.02.2005*/
	int mincol, i, j;
	matrix result;
	mincol = imin(a.col, b.col);
	result = matrix_alloc(a.row + b.row, mincol);
 for (i = 0; i < a.row; i++)
		 for (j = 0; j < mincol; j++)
				 result.values[i][j] = a.values[i][j];
	for (i = a.row; i < a.row + b.row; i++)
		 for (j = 0; j < mincol; j++)
				 result.values[i][j] = b.values[i - a.row][j];
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %edi
movl -0x2c(%rbp), %esi
callq 0x528e0
movl %eax, -0x34(%rbp)
movl -0x20(%rbp), %edi
addl -0x30(%rbp), %edi
movl -0x34(%rbp), %esi
callq 0x57fc0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x57f3c
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x57f2f
movq -0x18(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x57ef2
jmp 0x57f31
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x57ee3
movl -0x20(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl -0x20(%rbp), %ecx
addl -0x30(%rbp), %ecx
cmpl %ecx, %eax
jge 0x57fa5
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x57f98
movq -0x28(%rbp), %rax
movl -0x38(%rbp), %ecx
subl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x3c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x57f56
jmp 0x57f9a
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x57f42
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)