LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: divide_data_file
void divide_data_file(char* datasetname, char* separator, char* infilename, int partcount)
{
 /*!Last Changed 23.02.2007 added minimum partcount and check for datasetname*/
 /*!Last Changed 03.08.2006*/
 FILE* outfile;
 char* exportfname;
 int i;
 Instanceptr* parts;
 if (partcount < 2)
  {
   printf(m1367);
   return;
  }
 current_dataset = search_dataset(Datasets, datasetname);
 if (!current_dataset)
  {
   printf(m1279, datasetname);
   return;
  }
 if (!read_from_data_file(current_dataset, infilename, &traindata)) 
   return;
 parts = divide_instancelist_into_parts(&traindata, partcount);
 for (i = 0; i < partcount; i++)
  { 
   exportfname = export_file_name(current_dataset, 4, -1, -1, i + 1);
   outfile = fopen(exportfname, "w");
   print_instance_list(outfile, *separator, current_dataset, parts[i]);
   fclose(outfile);
  }
 traindata = NULL;
 for (i = 0; i < partcount; i++)
   deallocate(parts[i]);
 safe_free(parts);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x1, %ecx
jg 0x5d544
leaq 0x51200(%rip), %rdi     # 0xae731
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x78322(%rip), %rdi     # 0xd5878
movq %r15, %rsi
callq 0x14fb7
movq %rax, 0x7830b(%rip)     # 0xd5870
testq %rax, %rax
je 0x5d62d
leaq 0x2da8bb(%rip), %rdx    # 0x337e30
movq %rax, %rdi
movq %r14, %rsi
callq 0x5d65b
testl %eax, %eax
je 0x5d64c
leaq 0x2da8a1(%rip), %rdi    # 0x337e30
movl %ebp, %esi
callq 0x30de3
movq %rax, %r14
movl %ebp, %ebp
xorl %r12d, %r12d
movq 0x782cb(%rip), %rdi     # 0xd5870
leaq 0x1(%r12), %r15
movl $0x4, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %r15d, %r8d
callq 0x5d73a
movq %rax, %rdi
leaq 0x4e3a2(%rip), %rsi     # 0xab96d
callq 0x40f0
movq %rax, %r13
movsbl (%rbx), %esi
movq 0x78293(%rip), %rdx     # 0xd5870
movq (%r14,%r12,8), %rcx
movq %rax, %rdi
callq 0x304a2
movq %r13, %rdi
callq 0x42a0
movq %r15, %r12
cmpq %r15, %rbp
jne 0x5d59e
movq $0x0, 0x2da82c(%rip) # 0x337e30
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
callq 0x2ff55
incq %rbx
cmpq %rbx, %rbp
jne 0x5d606
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
leaq 0x4e33b(%rip), %rdi     # 0xab96f
movq %r15, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4030
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/process.c
// Function: read_from_data_file
int read_from_data_file(Datasetptr dataset, char* datafilename, Instanceptr* whereto)
{
 /*!Last Changed 31.10.2005*/
 FILE *myfile;
 char myline[READLINELENGTH];
 int j = 0;
 Instanceptr currentinstance, instancebefore = NULL;
 myfile = fopen(datafilename, "r");
 if (!myfile)
  {
   printf(m1121, datafilename);
   return FAILURE;
  }
 while (fgets(myline, READLINELENGTH, myfile))
  {
   currentinstance = create_instance(dataset, myline, get_parameter_o("runwithclassnoise"));
   if (!currentinstance)
     continue;
   if (instancebefore)
     instancebefore->next = currentinstance;
   else
     *whereto = currentinstance;
   currentinstance->index = j;
   j++;
   instancebefore = currentinstance;
  }
 fclose(myfile);
 if (convert_missing_values)
   handle_missing_values(*whereto, *whereto);
 return SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %r14
leaq 0x4e2dd(%rip), %rsi     # 0xab95b
movq %r12, %rdi
callq 0x40f0
testq %rax, %rax
je 0x5d713
movq %rax, %r15
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
leaq 0x4e31f(%rip), %r13     # 0xab9bf
xorl %ebp, %ebp
movq %r12, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r15, %rdx
callq 0x4120
testq %rax, %rax
je 0x5d6eb
movq %r13, %rdi
callq 0x54bec
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x189eb
testq %rax, %rax
je 0x5d6a2
leaq 0x10(%rbx), %rcx
testq %rbx, %rbx
cmoveq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movl %ebp, 0x18(%rax)
incl %ebp
movq %rax, %rbx
jmp 0x5d6a2
movq %r15, %rdi
callq 0x42a0
movl $0x1, %ebp
cmpl $0x0, 0x77bad(%rip)     # 0xd52ac
je 0x5d726
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq %rdi, %rsi
callq 0x5d42c
jmp 0x5d726
leaq 0x49847(%rip), %rdi     # 0xa6f61
xorl %ebp, %ebp
movq %r12, %rsi
xorl %eax, %eax
callq 0x4030
movl %ebp, %eax
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: export_data_file
void export_data_file(char* datasetname, char* separator, char* infilename, char* outfilename)
{
 /*!Last Changed 21.10.2005 added read_from_data_file*/
 /*!Last Changed 29.09.2004*/
 /*!Last Changed 28.10.2003*/
 FILE* outfile;
 mustnormalize = NO;
 outfile = fopen(outfilename, "w");
 if (!outfile)
   return;
 current_dataset = search_dataset(Datasets, datasetname);
 if (!current_dataset)
  {
   printf(m1279, datasetname);
   return;
  }
 if (!read_from_data_file(current_dataset, infilename, &traindata)) 
   return;
 pre_process();
 print_instance_list(outfile, *separator, current_dataset, traindata);
 post_process(YES);
 deallocate(traindata);
 traindata = NULL;
 fclose(outfile);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movl $0x0, 0x2da588(%rip)    # 0x337e70
leaq 0x4e07e(%rip), %rsi     # 0xab96d
movq %rcx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x5d987
movq %rax, %rbx
movq 0x77f6e(%rip), %rdi     # 0xd5878
movq %r12, %rsi
callq 0x14fb7
movq %rax, 0x77f57(%rip)     # 0xd5870
testq %rax, %rax
je 0x5d993
leaq 0x2da50b(%rip), %rdx    # 0x337e30
movq %rax, %rdi
movq %r15, %rsi
callq 0x5d65b
testl %eax, %eax
je 0x5d987
callq 0x5f670
movsbl (%r14), %esi
movq 0x77f2c(%rip), %rdx     # 0xd5870
movq 0x2da4e5(%rip), %rcx    # 0x337e30
movq %rbx, %rdi
callq 0x304a2
movl $0x1, %edi
callq 0x5d9af
movq 0x2da4cc(%rip), %rdi    # 0x337e30
callq 0x2ff55
movq $0x0, 0x2da4bc(%rip) # 0x337e30
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x42a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4dfd5(%rip), %rdi     # 0xab96f
movq %r12, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4030
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: post_process
void post_process(int free_values)
{
 /*!Last Changed 31.10.2005 added type_restore*/
 /*!Last Changed 11.08.2005*/
 if (mustrealize)
   exchange_classdefno(current_dataset);
 if (mustnormalize)
  {
   if (free_values)
    {
     safe_free(mean.values);
     safe_free(variance.values);
    }
   if (!mustrealize)
     type_restore(current_dataset);
  }
}

// Assembly:
pushq %rbx
movl %edi, %ebx
cmpl $0x0, 0x3545eb(%rip)    # 0x3b1fa4
je 0x5d9c7
movq 0x77eae(%rip), %rdi     # 0xd5870
callq 0x12c28
cmpl $0x0, 0x2da4a2(%rip)    # 0x337e70
je 0x5d9f5
testl %ebx, %ebx
je 0x5d9ec
movq 0x3545cd(%rip), %rdi    # 0x3b1fa8
callq 0x3a180
movq 0x3545f1(%rip), %rdi    # 0x3b1fd8
callq 0x3a180
cmpl $0x0, 0x3545b1(%rip)    # 0x3b1fa4
je 0x5d9f7
popq %rbx
retq
movq 0x77e72(%rip), %rdi     # 0xd5870
popq %rbx
jmp 0x18879
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: getorder
void getorder()
{
 /*!Last Changed 23.02.2007 added maximum parameter exceed message*/
 int i;
 char* p;
 printf(">>");
 fgets(orderst, MAXLENGTH, stdin);
 orderst[strlen(orderst) - 1] = '\0';
 change_according_to_variables(orderst);
 p = strtok(orderst," \t");
 if (p)
  {
   order = strcopy(order, p);
   paramcount = -1;
   do{
     paramcount++;
     p = strtok(NULL, " \t");
     if (p)
       params[paramcount] = strcopy(params[paramcount], p);
   }while(p && (paramcount < MAXPARAMS - 1));
  }
 if (paramcount >= MAXPARAMS - 1)
   printf(m1368);
 for (i = 0; i < paramcount; i++)
   change_special_characters(params[i]);
 params[paramcount] = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4df7b(%rip), %rdi     # 0xab98a
xorl %eax, %eax
callq 0x4030
movq 0x765b3(%rip), %rax     # 0xd3fd0
movq (%rax), %rdx
leaq 0x2da459(%rip), %rbx    # 0x337e80
movq %rbx, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x4120
movq %rbx, %rdi
callq 0x4190
movb $0x0, -0x1(%rax,%rbx)
movq %rbx, %rdi
callq 0x36463
leaq 0x53f6c(%rip), %rsi     # 0xb19bc
movq %rbx, %rdi
callq 0x4280
testq %rax, %rax
je 0x5dac3
movq 0x77ac4(%rip), %rdi     # 0xd5528
movq %rax, %rsi
callq 0x3b494
movq %rax, 0x77ab5(%rip)     # 0xd5528
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
leaq 0x53f3d(%rip), %rbx     # 0xb19bc
leaq 0x77aaa(%rip), %r14     # 0xd5530
incl %ecx
movl %ecx, 0x354512(%rip)    # 0x3b1fa0
xorl %edi, %edi
movq %rbx, %rsi
callq 0x4280
testq %rax, %rax
je 0x5dac3
movslq 0x3544fc(%rip), %rcx    # 0x3b1fa0
movq (%r14,%rcx,8), %rdi
movq %rax, %rsi
callq 0x3b494
movslq 0x3544e9(%rip), %rcx    # 0x3b1fa0
movq %rax, (%r14,%rcx,8)
cmpq $0x63, %rcx
jl 0x5da86
jmp 0x5dace
movl 0x3544d7(%rip), %eax    # 0x3b1fa0
cmpl $0x63, %eax
jl 0x5dae0
leaq 0x50c78(%rip), %rdi     # 0xae74d
callq 0x4090
movl 0x3544c0(%rip), %eax    # 0x3b1fa0
testl %eax, %eax
jle 0x5db0b
leaq 0x77a45(%rip), %rbx     # 0xd5530
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0x35d3c
incq %r14
movslq 0x3544a0(%rip), %rax    # 0x3b1fa0
addq $0x8, %rbx
cmpq %rax, %r14
jl 0x5daee
jmp 0x5db0d
cltq
leaq 0x77a1c(%rip), %rcx     # 0xd5530
movq $0x0, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: read_from_train_file
int read_from_train_file(Datasetptr dataset, Instanceptr* whereto)
{
 /*!Last Changed 31.10.2005*/
 char *fname;
 int returnvalue;
 fname = dataset_file_name(dataset);
 returnvalue = read_from_data_file(dataset, fname, whereto);
 safe_free(fname);
 return returnvalue;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x16542
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x5d65b
movl %eax, %ebx
movq %r15, %rdi
callq 0x3a180
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: read_and_normalize_train_file
void read_and_normalize_train_file(Datasetptr dataset, Instanceptr* whereto)
{
 read_from_train_file(dataset, whereto);
 mustrealize = YES;
 mustnormalize = YES;
 realize(*whereto);
 exchange_classdefno(dataset);
 mean = find_mean(*whereto);
 variance = find_variance(*whereto);
 normalize(*whereto, mean, variance);
 safe_free(mean.values);
 safe_free(variance.values);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5dcbd
movl $0x1, %eax
movl %eax, 0x353f2f(%rip)    # 0x3b1fa4
movl %eax, 0x2d9df5(%rip)    # 0x337e70
movq (%rbx), %rdi
callq 0x10954
movq %r14, %rdi
callq 0x12c28
movq (%rbx), %rsi
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x1247b
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x353f18(%rip)   # 0x3b1fc8
movups %xmm1, 0x353f01(%rip)   # 0x3b1fb8
movups %xmm0, 0x353eea(%rip)   # 0x3b1fa8
movq (%rbx), %rsi
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x127bd
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x353f15(%rip)   # 0x3b1ff8
movups %xmm1, 0x353efe(%rip)   # 0x3b1fe8
movups %xmm0, 0x353ee7(%rip)   # 0x3b1fd8
movq (%rbx), %rdi
movups 0x353efd(%rip), %xmm0   # 0x3b1ff8
movups %xmm0, 0x50(%rsp)
movups 0x353ee1(%rip), %xmm0   # 0x3b1fe8
movups %xmm0, 0x40(%rsp)
movups 0x353ec5(%rip), %xmm0   # 0x3b1fd8
movups %xmm0, 0x30(%rsp)
movups 0x353ea9(%rip), %xmm0   # 0x3b1fc8
movups %xmm0, 0x20(%rsp)
movups 0x353e8d(%rip), %xmm0   # 0x3b1fb8
movups %xmm0, 0x10(%rsp)
movups 0x353e71(%rip), %xmm0   # 0x3b1fa8
movups %xmm0, (%rsp)
callq 0x107b2
movq 0x353e61(%rip), %rdi    # 0x3b1fa8
callq 0x3a180
movq 0x353e85(%rip), %rdi    # 0x3b1fd8
callq 0x3a180
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: prepare_from_files
int prepare_from_files(Datasetptr dataset, char* param1, char* param2, char* param3)
{
 /*!Last Changed 02.11.2005*/
 /*!Last Changed 23.11.2004 added traincount*/
 char *fname1, *fname2;
 if (isinteger(param1))
  {
   fname1 = export_file_name(dataset, 0, atoi(param1), atoi(param2), -1);
   if (!fname1)
     return FAILURE;
   fname2 = export_file_name(dataset, 1, atoi(param1), atoi(param2), -1);
   if (!fname2)
     return FAILURE;
  }
 else
  {
   fname1 = param1;
   fname2 = param2;
  }
 if (!read_from_data_file(dataset, fname1, &traindata))
   return FAILURE;
 if (!read_from_data_file(dataset, fname2, &testdata))
   return FAILURE;
 if (param3 != NULL && !read_from_data_file(dataset, param3, &cvdata))
   return FAILURE;
 if (isinteger(param1))
  {
   safe_free(fname1);
   safe_free(fname2);
  }
 current_dataset->traincount = data_size(traindata);
 return SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, %rdi
callq 0x3a938
testl %eax, %eax
je 0x5e203
movq %r14, %rdi
callq 0x4200
movl %eax, %r13d
movq %rbx, %rdi
callq 0x4200
xorl %ebp, %ebp
movq %r12, %rdi
xorl %esi, %esi
movl %r13d, %edx
movl %eax, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x5d73a
testq %rax, %rax
je 0x5e289
movq %rax, %r13
movq %r14, %rdi
callq 0x4200
movq %r13, (%rsp)
movq %r15, %r13
movl %eax, %r15d
movq %rbx, %rdi
callq 0x4200
movq %r12, %rdi
movl $0x1, %esi
movl %r15d, %edx
movq %r13, %r15
movq (%rsp), %r13
movl %eax, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x5d73a
testq %rax, %rax
je 0x5e289
movq %rax, %rbx
jmp 0x5e206
movq %r14, %r13
leaq 0x2d9c23(%rip), %rdx    # 0x337e30
movq %r12, %rdi
movq %r13, %rsi
callq 0x5d65b
xorl %ebp, %ebp
testl %eax, %eax
je 0x5e289
leaq 0x2d9c13(%rip), %rdx    # 0x337e38
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5d65b
testl %eax, %eax
je 0x5e289
testq %r15, %r15
je 0x5e24f
leaq 0x2d9c00(%rip), %rdx    # 0x337e40
movq %r12, %rdi
movq %r15, %rsi
callq 0x5d65b
testl %eax, %eax
je 0x5e289
movq %r14, %rdi
callq 0x3a938
testl %eax, %eax
je 0x5e26b
movq %r13, %rdi
callq 0x3a180
movq %rbx, %rdi
callq 0x3a180
movq 0x2d9bbe(%rip), %rdi    # 0x337e30
callq 0x30309
movq 0x775f2(%rip), %rcx     # 0xd5870
movl %eax, 0x1407124(%rcx)
movl $0x1, %ebp
movl %ebp, %eax
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/process.c
// Function: get_prior_information
void get_prior_information()
{
 /*!Last Changed 20.06.2008 added deallocate*/
 /*!Last Changed 02.02.2004 added safemalloc*/
 char myline[READLINELENGTH];
 long i;
 Instanceptr currentinstance;
 if (prior_class_information)
   safe_free(prior_class_information); 
 prior_class_information = (int *)safemalloc(current_dataset->datacount * sizeof(int), "get_prior_information", 9);
 if (!open_dataset(current_dataset))
   return;
 i = 0;
 while (get_single_instance(current_dataset, myline))
  {
   currentinstance = create_instance(current_dataset, myline, NO);
   if (!currentinstance)/*If the line does not contain correct instance*/
     continue;
   prior_class_information[i] = give_classno(currentinstance);
   deallocate(currentinstance);
   i++;
  }
 close_dataset(current_dataset);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x7a120, %rsp          # imm = 0x7A120
movq 0x2d9b64(%rip), %rdi    # 0x337e58
testq %rdi, %rdi
je 0x5e2fe
callq 0x3a180
movq 0x7756b(%rip), %rax     # 0xd5870
movslq 0x1407120(%rax), %rdi
shlq $0x2, %rdi
leaq 0x4d6ba(%rip), %rsi     # 0xab9d1
movl $0x9, %edx
callq 0x3a0e1
movq %rax, 0x2d9b30(%rip)    # 0x337e58
movq 0x77541(%rip), %rdi     # 0xd5870
callq 0x5e396
testl %eax, %eax
je 0x5e389
xorl %r15d, %r15d
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x5e29a
movq 0x77523(%rip), %rdi     # 0xd5870
testq %rax, %rax
je 0x5e384
movq %rbx, %rsi
xorl %edx, %edx
callq 0x189eb
testq %rax, %rax
je 0x5e33e
movq %rax, %r14
movq %rax, %rdi
callq 0x2f33a
movq 0x2d9ae5(%rip), %rcx    # 0x337e58
movl %eax, (%rcx,%r15,4)
movq %r14, %rdi
callq 0x2ff55
incq %r15
jmp 0x5e33e
callq 0x5e42c
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: open_dataset
int open_dataset(Datasetptr dataset)
{
 /*!Last Changed 07.04.2007 added STORE_TIME*/
 /*!Last Changed 29.12.2005*/
 char* datafilename;
 if (in_list(dataset->storetype, 3, STORE_TEXT, STORE_SEQUENTIAL, STORE_KERNEL))
  {
   datafilename = dataset_file_name(dataset);
   if ((datafile = fopen(datafilename, "r")) == NULL)
    {
     safe_free(datafilename);
     printf(m1271, dataset->name);
     return FAILURE;
    }
   else
    {
     safe_free(datafilename);
     return SUCCESS;
    }
  }
 else
   return connect_to_database(dataset);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x140713c(%rdi), %edi
movl $0x3, %esi
xorl %edx, %edx
movl $0x2, %ecx
movl $0x3, %r8d
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
je 0x5e41a
movq %rbx, %rdi
callq 0x16542
movq %rax, %r14
leaq 0x4d586(%rip), %rsi     # 0xab95b
movq %rax, %rdi
callq 0x40f0
movq %rax, %r15
movq %rax, 0x353c21(%rip)    # 0x3b2008
movq %r14, %rdi
callq 0x3a180
movl $0x1, %ebp
testq %r15, %r15
jne 0x5e40d
movq 0x8(%rbx), %rsi
leaq 0x4d722(%rip), %rdi     # 0xabb26
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x4030
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x18e41
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: bootstrap_sample_with_stratification
void bootstrap_sample_with_stratification(int *prior_class_information, int* classcounts)
{
 long i, j;
 Instanceptr currentinstance, trainbefore = NULL;
 int* tmpcounts = safemalloc(sizeof(int) * current_dataset->classno, "bootstrap_sample_with_stratification", 2);
 for (i = 0; i < current_dataset->classno; i++)
   tmpcounts[i] = classcounts[i];
 i = 0;
 while (i < trainlinecount)
  {
   j = myrand() % trainlinecount;
   while (tmpcounts[prior_class_information[j]] == 0)
     j = myrand() % trainlinecount;
   (tmpcounts[prior_class_information[j]])--;
   currentinstance = create_instance(current_dataset, trainlines[j], NO);
   if (i != 0)
     trainbefore->next = currentinstance;
   else
     traindata = currentinstance;
   trainbefore = currentinstance;
   currentinstance->index = i;
   i++;
  }
 safe_free(tmpcounts);
 current_dataset->traincount = i;
 if (convert_missing_values)
   handle_missing_values(traindata, traindata);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x773f5(%rip), %rax     # 0xd5870
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
leaq 0x4d55d(%rip), %rsi     # 0xab9e7
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r14
movq 0x773d2(%rip), %rax     # 0xd5870
cmpl $0x0, 0x10(%rax)
jle 0x5e4ba
xorl %ecx, %ecx
movl (%r15,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
movslq 0x10(%rax), %rdx
cmpq %rdx, %rcx
jl 0x5e4a6
cmpl $0x0, 0x7704f(%rip)     # 0xd5510
jle 0x5e533
leaq 0x2d9966(%rip), %r12    # 0x337e30
xorl %r15d, %r15d
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x3af20
cltd
idivl 0x77032(%rip)           # 0xd5510
movslq %edx, %rax
movslq (%rbx,%rax,4), %rcx
movl (%r14,%rcx,4), %edx
testl %edx, %edx
je 0x5e4d0
decl %edx
movl %edx, (%r14,%rcx,4)
movq 0x77376(%rip), %rdi     # 0xd5870
movq 0x7735f(%rip), %rcx     # 0xd5860
movq (%rcx,%rax,8), %rsi
xorl %edx, %edx
callq 0x189eb
addq $0x10, %r13
testq %r15, %r15
cmoveq %r12, %r13
movq %rax, (%r13)
movl %r15d, 0x18(%rax)
incq %r15
movslq 0x76fe7(%rip), %rcx     # 0xd5510
movq %rax, %r13
cmpq %rcx, %r15
jl 0x5e4d0
jmp 0x5e536
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x3a180
movq 0x7732b(%rip), %rax     # 0xd5870
movl %r15d, 0x1407124(%rax)
cmpl $0x0, 0x76d59(%rip)     # 0xd52ac
je 0x5e56d
movq 0x2d98d4(%rip), %rdi    # 0x337e30
movq %rdi, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5d42c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: get_fold
void get_fold(int fold, int* partition)
{
 /*!Last Changed 25.05.2006*/
 /*!Last Changed 30.10.2005*/
 /*!Last Changed 23.11.2004 added traincount*/
 long i, trainindex;
 Instanceptr currentinstance, trainbefore = NULL, testbefore = NULL;
 i = 0;
 trainindex = 0;
 while (i < trainlinecount)
  {
   currentinstance = create_instance(current_dataset, trainlines[i], get_parameter_o("runwithclassnoise"));
   if (!currentinstance)/*If the line does not contain correct instance*/
     continue;
   if (partition[i] % get_parameter_i("foldcount") != fold)
    {
     if (trainbefore)
       trainbefore->next = currentinstance;
     else
       traindata = currentinstance;
     trainbefore = currentinstance;
     currentinstance->index = trainindex;
     trainindex++;
    }
   else
    {
     if (testbefore)
       testbefore->next = currentinstance;
     else
       testdata = currentinstance;
     testbefore = currentinstance;
     currentinstance->index = i;
    }
   i++;
  }
 current_dataset->traincount = trainindex;
 if (convert_missing_values)
  {
   handle_missing_values(traindata, traindata);
   handle_missing_values(traindata, testdata);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movl %edi, 0x4(%rsp)
xorl %r15d, %r15d
leaq 0x4d427(%rip), %r14     # 0xab9bf
xorl %ebx, %ebx
xorl %ebp, %ebp
movq $0x0, 0x8(%rsp)
movslq 0x76f64(%rip), %rax     # 0xd5510
cmpq %rax, %rbx
jge 0x5e655
movq 0x772b4(%rip), %r12     # 0xd5870
movq 0x7729d(%rip), %rax     # 0xd5860
movq (%rax,%rbx,8), %r13
movq %r14, %rdi
callq 0x54bec
movq %r12, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x189eb
testq %rax, %rax
je 0x5e5a5
movq %rax, %r12
movq 0x10(%rsp), %rax
movl (%rax,%rbx,4), %r13d
leaq 0x505f4(%rip), %rdi     # 0xaebe8
callq 0x54920
movl %eax, %ecx
movl %r13d, %eax
cltd
idivl %ecx
cmpl 0x4(%rsp), %edx
jne 0x5e62d
movq 0x8(%rsp), %rcx
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
leaq 0x2d981e(%rip), %rcx    # 0x337e38
cmoveq %rcx, %rax
movq %r12, (%rax)
movl %ebx, 0x18(%r12)
movq %r12, 0x8(%rsp)
jmp 0x5e64d
leaq 0x10(%rbp), %rax
testq %rbp, %rbp
leaq 0x2d97f5(%rip), %rcx    # 0x337e30
cmoveq %rcx, %rax
movq %r12, (%rax)
movl %r15d, 0x18(%r12)
incq %r15
movq %r12, %rbp
incq %rbx
jmp 0x5e5a5
movq 0x77214(%rip), %rax     # 0xd5870
movl %r15d, 0x1407124(%rax)
cmpl $0x0, 0x76c42(%rip)     # 0xd52ac
je 0x5e69c
movq 0x2d97bd(%rip), %rdi    # 0x337e30
movq %rdi, %rsi
callq 0x5d42c
movq 0x2d97ae(%rip), %rdi    # 0x337e30
movq 0x2d97af(%rip), %rsi    # 0x337e38
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5d42c
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/process.c
// Function: export_valdata
void export_valdata(char* separator, int newseed)
{
 /*!Last Changed 13.02.2008 added regression for validation data export*/
 /*!Last Changed 21.04.2007 added export_single_file*/
 /*!Last Changed 24.11.2005*/
 /*!Last Changed 30.10.2005*/
 int *classes, *classcounts = NULL;
 Instanceptr exportdata;
 mustnormalize = NO;
 get_prior_information();
 mysrand(newseed);
 classes = read_train_and_test_lines(&classcounts);
 read_data_from_lines(testlines, testlinecount, &exportdata);
 pre_process_with_mean_and_variance(mean, variance, exportdata);
 export_single_file(separator, 2, -2, -2, exportdata, NULL);
 post_process(NO);
 deallocate(exportdata);
 read_data_from_lines(trainlines, trainlinecount, &exportdata);
 pre_process_with_mean_and_variance(mean, variance, exportdata);
 export_single_file(separator, 3, -2, -2, exportdata, NULL);
 post_process(NO);
 deallocate(exportdata);
 free_train_and_test_lines();
 if (classes)
  {
   safe_free(classes);
   safe_free(classcounts);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x68(%rsp), %r15
movq $0x0, (%r15)
movl $0x0, 0x2d9260(%rip)    # 0x337e70
callq 0x5e2e1
movl %ebx, %edi
callq 0x3af63
movq %r15, %rdi
callq 0x5ed85
movq %rax, %rbx
movq 0x76c2a(%rip), %rdi     # 0xd5858
movl 0x768d8(%rip), %esi     # 0xd550c
leaq 0x70(%rsp), %r15
movq %r15, %rdx
callq 0x5efe0
movq (%r15), %r12
movups 0x3533ad(%rip), %xmm0   # 0x3b1ff8
movups %xmm0, 0x50(%rsp)
movups 0x353391(%rip), %xmm0   # 0x3b1fe8
movups %xmm0, 0x40(%rsp)
movups 0x353375(%rip), %xmm0   # 0x3b1fd8
movups %xmm0, 0x30(%rsp)
movups 0x353359(%rip), %xmm0   # 0x3b1fc8
movups %xmm0, 0x20(%rsp)
movups 0x35333d(%rip), %xmm0   # 0x3b1fb8
movups %xmm0, 0x10(%rsp)
movups 0x353321(%rip), %xmm0   # 0x3b1fa8
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x5f06b
movq %r14, %rdi
movl $0x2, %esi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
movq %r12, %r8
xorl %r9d, %r9d
callq 0x5f22b
xorl %edi, %edi
callq 0x5d9af
movq %r12, %rdi
callq 0x2ff55
movq 0x76b9a(%rip), %rdi     # 0xd5860
movl 0x76844(%rip), %esi     # 0xd5510
movq %r15, %rdx
callq 0x5efe0
movq (%r15), %r15
movups 0x35331a(%rip), %xmm0   # 0x3b1ff8
movups %xmm0, 0x50(%rsp)
movups 0x3532fe(%rip), %xmm0   # 0x3b1fe8
movups %xmm0, 0x40(%rsp)
movups 0x3532e2(%rip), %xmm0   # 0x3b1fd8
movups %xmm0, 0x30(%rsp)
movups 0x3532c6(%rip), %xmm0   # 0x3b1fc8
movups %xmm0, 0x20(%rsp)
movups 0x3532aa(%rip), %xmm0   # 0x3b1fb8
movups %xmm0, 0x10(%rsp)
movups 0x35328e(%rip), %xmm0   # 0x3b1fa8
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x5f06b
movq %r14, %rdi
movl $0x3, %esi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
movq %r15, %r8
xorl %r9d, %r9d
callq 0x5f22b
xorl %edi, %edi
callq 0x5d9af
movq %r15, %rdi
callq 0x2ff55
callq 0x619ea
testq %rbx, %rbx
je 0x5ed79
movq %rbx, %rdi
callq 0x3a180
movq 0x68(%rsp), %rdi
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3a180
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: read_data_from_lines
void read_data_from_lines(char** lines, int linecount, Instanceptr* data)
{
 /*!Last Changed 30.10.2005*/
 int i;
 Instanceptr currentinstance, before;
 *data = create_instance(current_dataset, lines[0], get_parameter_o("runwithclassnoise"));
 before = *data;
 for (i = 1; i < linecount; i++)
  {
   currentinstance = create_instance(current_dataset, lines[i], get_parameter_o("runwithclassnoise"));
   before->next = currentinstance;
   before = currentinstance;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq 0x76876(%rip), %r14     # 0xd5870
movq (%rdi), %r12
leaq 0x4c9bb(%rip), %rdi     # 0xab9bf
callq 0x54bec
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x189eb
movq %rax, (%r15)
cmpl $0x2, %ebp
jl 0x5f05c
movq %rax, %r14
movl %ebp, %ebp
movl $0x1, %r15d
movq 0x76840(%rip), %r12     # 0xd5870
movq (%rbx,%r15,8), %r13
leaq 0x4c984(%rip), %rdi     # 0xab9bf
callq 0x54bec
movq %r12, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x189eb
movq %rax, 0x10(%r14)
incq %r15
movq %rax, %r14
cmpq %r15, %rbp
jne 0x5f029
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/process.c
// Function: pre_process_with_mean_and_variance
void pre_process_with_mean_and_variance(Instance mean, Instance variance, Instanceptr data)
{
 /*!Last Changed 13.03.2007 added selected feature for realization*/
 /*!Last Changed 05.03.2006*/
 int i;
 if (mustrealize)
  {
   for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
     current_dataset->selected[i] = YES;
   realize(data);
   exchange_classdefno(current_dataset);
  }
 if (mustnormalize)
  {
   normalize(data, mean, variance);
   if (!mustrealize)
     type_change(current_dataset);
  }
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x352f2a(%rip)    # 0x3b1fa4
je 0x5f1b4
movq 0x767e9(%rip), %rax     # 0xd5870
movslq 0x1c0(%rax), %rdx
cmpq $0x2, %rdx
jl 0x5f1a0
leaq 0x2(%rdx), %rcx
andq $-0x4, %rcx
addq $-0x2, %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x4737a(%rip), %xmm1    # 0xa6430
movdqa 0x47382(%rip), %xmm2    # 0xa6440
xorl %edx, %edx
movdqa 0x47388(%rip), %xmm3    # 0xa6450
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x47388(%rip), %xmm5    # 0xa6460
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x5f118
movl $0x1, 0x18864(%rax,%rdx,4)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x5f132
movl $0x1, 0x18868(%rax,%rdx,4)
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %esi
testb $0x1, %sil
je 0x5f175
movl $0x1, 0x1886c(%rax,%rdx,4)
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x5f18b
movl $0x1, 0x18870(%rax,%rdx,4)
addq $0x4, %rdx
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
cmpq %rdx, %rcx
jne 0x5f0d8
movq %rbx, %rdi
callq 0x10954
movq 0x766c1(%rip), %rdi     # 0xd5870
callq 0x12c28
cmpl $0x0, 0x2d8cb5(%rip)    # 0x337e70
je 0x5f214
leaq 0xa0(%rsp), %rax
leaq 0x70(%rsp), %rcx
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x50(%rsp)
movups %xmm1, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movdqu (%rcx), %xmm0
movdqu 0x10(%rcx), %xmm1
movdqu 0x20(%rcx), %xmm2
movdqu %xmm2, 0x20(%rsp)
movdqu %xmm1, 0x10(%rsp)
movdqu %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x107b2
cmpl $0x0, 0x352d92(%rip)    # 0x3b1fa4
je 0x5f21a
addq $0x60, %rsp
popq %rbx
retq
movq 0x7664f(%rip), %rdi     # 0xd5870
addq $0x60, %rsp
popq %rbx
jmp 0x1883a
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: export_single_file
void export_single_file(char* separator, int exporttype, int runno, int foldno, Instanceptr data1, Instanceptr data2)
{
 /*!Last Changed 21.04.2007*/
 FILE* outfile;
 char* fname;
 fname = export_file_name(current_dataset, exporttype, runno + 1, foldno + 1, -1);
 if (!fname)
   return;
 outfile = fopen(fname, "w");
 if (!outfile)
   return;
 if (get_parameter_l("namestype") == NAMES_CMU)
  {
   print_cmu_data_header(outfile, current_dataset);
   fprintf(outfile, "$TRAIN\n");
   print_instance_list(outfile, *separator, current_dataset, data1);
   fprintf(outfile, "$TEST\n");
   print_instance_list(outfile, *separator, current_dataset, data2);
  }
 else
   print_instance_list(outfile, *separator, current_dataset, data1);
 fclose(outfile);
 safe_free(fname);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r12
movq %rdi, %r14
movq 0x7662c(%rip), %rdi     # 0xd5870
incl %edx
incl %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x5d73a
testq %rax, %rax
je 0x5f2e0
movq %rax, %r15
leaq 0x4c707(%rip), %rsi     # 0xab96d
movq %rax, %rdi
callq 0x40f0
testq %rax, %rax
je 0x5f2e0
movq %rax, %r13
leaq 0x47e3e(%rip), %rdi     # 0xa70bb
callq 0x54afc
cmpl $0x5, %eax
jne 0x5f2ea
movq 0x765e2(%rip), %rsi     # 0xd5870
movq %r13, %rdi
callq 0x19660
leaq 0x4c76f(%rip), %rdi     # 0xaba0c
movl $0x7, %esi
movl $0x1, %edx
movq %r13, %rcx
callq 0x42c0
movsbl (%r14), %esi
movq 0x765b6(%rip), %rdx     # 0xd5870
movq %r13, %rdi
movq %r12, %rcx
callq 0x304a2
leaq 0x4c748(%rip), %rdi     # 0xaba14
movl $0x6, %esi
movl $0x1, %edx
movq %r13, %rcx
callq 0x42c0
jmp 0x5f2ed
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rbx
movsbl (%r14), %esi
movq 0x76578(%rip), %rdx     # 0xd5870
movq %r13, %rdi
movq %rbx, %rcx
callq 0x304a2
movq %r13, %rdi
callq 0x42a0
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: read_data_from_lines_with_probability
void read_data_from_lines_with_probability(char** lines, int linecount, double* probability, Instanceptr* data)
{
 /*!Last Changed 28.02.2006*/
 int i, bin;
 double val;
 Instanceptr currentinstance, before;
 for (i = 0; i < linecount; i++)
  {
   val = produce_random_value(0.0, 1.0);
   bin = find_bin(probability, linecount, val);
   currentinstance = create_instance(current_dataset, lines[bin], NO);
   if (i == 0)
     *data = currentinstance;
   else
     before->next = currentinstance;
   before = currentinstance;
  }
}

// Assembly:
testl %esi, %esi
jle 0x6199d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
xorl %r12d, %r12d
xorps %xmm0, %xmm0
movsd 0x43bce(%rip), %xmm1    # 0xa5520
callq 0x3af6a
movq %r14, %rdi
movl %ebp, %esi
callq 0x37fdb
movq 0x73f08(%rip), %rdi     # 0xd5870
cltq
movq (%r15,%rax,8), %rsi
xorl %edx, %edx
callq 0x189eb
addq $0x10, %r13
testl %r12d, %r12d
cmoveq %rbx, %r13
movq %rax, (%r13)
incl %r12d
movq %rax, %r13
cmpl %r12d, %ebp
jne 0x61947
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/process.c
// Function: free_train_and_test_lines
void free_train_and_test_lines()
{
 /*!Last Changed 05.03.2006*/
 free_2d((void**)trainlines, trainlinecount);
 trainlinecount = 0;
 trainlines = NULL;
 if (get_parameter_f("testpercentage") > 0.0)
  {
   free_2d((void**)testlines, testlinecount);
   testlinecount = 0;
   testlines = NULL;
  }
}

// Assembly:
pushq %rax
movq 0x73e6e(%rip), %rdi     # 0xd5860
movl 0x73b18(%rip), %esi     # 0xd5510
callq 0x3a14b
movl $0x0, 0x73b09(%rip)     # 0xd5510
movq $0x0, 0x73e4e(%rip) # 0xd5860
leaq 0x4a136(%rip), %rdi     # 0xabb4f
callq 0x549ba
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x61a4f
movq 0x73e29(%rip), %rdi     # 0xd5858
movl 0x73ad7(%rip), %esi     # 0xd550c
callq 0x3a14b
movl $0x0, 0x73ac8(%rip)     # 0xd550c
movq $0x0, 0x73e09(%rip) # 0xd5858
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: read_train_lines
void read_train_lines()
{
 /*!Last Changed 08.01.2009*/
 char myline[READLINELENGTH];
 if (!open_dataset(current_dataset))
   return;  
 while (get_single_instance(current_dataset, myline))
  {
   if (is_line_comment(myline))
     continue;
   add_single_data_line(&trainlines, &trainlinecount, myline);
  }
 close_dataset(current_dataset);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x7a120, %rsp          # imm = 0x7A120
movq 0x73e0c(%rip), %rdi     # 0xd5870
callq 0x5e396
testl %eax, %eax
je 0x61abe
movq %rsp, %rsi
callq 0x5e29a
testq %rax, %rax
je 0x61ab2
movq %rsp, %rbx
leaq 0x73ddc(%rip), %r14     # 0xd5860
leaq 0x73a85(%rip), %r15     # 0xd5510
movq %rbx, %rdi
callq 0x3a52c
testl %eax, %eax
jne 0x61aa5
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6199e
movq %rbx, %rsi
callq 0x5e29a
testq %rax, %rax
jne 0x61a8b
movq 0x73db7(%rip), %rdi     # 0xd5870
callq 0x5e42c
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: check_and_set_list_variable
void check_and_set_list_variable(void* variable, char* errormessage1, char* errormessage2, char* valuelist[], int listlength)
{
 /*!Last Changed 22.11.2004*/
 int tmp, i;
 if (checkparams(paramcount, 1, errormessage1))
  {
   tmp = listindex(params[0], valuelist, listlength);
   if (tmp != -1)
     *((int*)variable) = tmp;
   else
    {
     printf(errormessage2, params[0]);
     printf(m1276);
     for (i = 0; i < listlength; i++)
      {
       printf("%s", valuelist[i]);
       printf("\n");
      }
     printf("Current value: %s\n", valuelist[*((int*)variable)]);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r14
movl 0x343fea(%rip), %edi    # 0x3b1fa0
movl $0x1, %esi
xorl %eax, %eax
callq 0x3ab3a
testl %eax, %eax
je 0x6dfdf
movq 0x67563(%rip), %rdi     # 0xd5530
movq %rbx, %rsi
movl %ebp, %edx
callq 0x3b355
cmpl $-0x1, %eax
je 0x6dfee
movl %eax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6753b(%rip), %rsi     # 0xd5530
movq %r15, %rdi
xorl %eax, %eax
callq 0x4030
leaq 0x3cb80(%rip), %rdi     # 0xaab86
callq 0x4090
testl %ebp, %ebp
jle 0x6e03c
movl %ebp, %r12d
leaq 0x39f37(%rip), %r15     # 0xa7f50
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x4030
movl $0xa, %edi
callq 0x40d0
incq %r13
cmpq %r13, %r12
jne 0x6e01c
movslq (%r14), %rax
movq (%rbx,%rax,8), %rsi
leaq 0x3dcfe(%rip), %rdi     # 0xabd48
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4030
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: deallocate_remaining_memory
void deallocate_remaining_memory()
{
 /*!Last Changed 29.11.2004*/
 int res;
 for (res = 0; res < graphcount; res++)
   deallocate_graph(Graphs[res]);
 deallocate_datasets();
 free_variables(vars, varcount);
 safe_free(vars);
 if (datadir)
   safe_free(datadir);
 if (prior_class_information)
   safe_free(prior_class_information); 
 if (traindata)
  {
   deallocate(traindata);
   traindata = NULL;
  }
 if (testdata)
  {
   deallocate(testdata);
   testdata = NULL;
  } 
 if (cvdata)
  {
   deallocate(cvdata);
   cvdata = NULL;
  }
 deallocate_orders();
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x67499(%rip)     # 0xd5500
jle 0x6e08a
xorl %ebx, %ebx
movq 0x2c9df6(%rip), %rax    # 0x337e68
movq (%rax,%rbx,8), %rdi
callq 0x4eb31
incq %rbx
movslq 0x6747b(%rip), %rax     # 0xd5500
cmpq %rax, %rbx
jl 0x6e06b
xorl %eax, %eax
callq 0x13745
movq 0x677d0(%rip), %rdi     # 0xd5868
movl 0x67466(%rip), %esi     # 0xd5504
callq 0x34846
movq 0x677be(%rip), %rdi     # 0xd5868
callq 0x3a180
movq 0x677ca(%rip), %rdi     # 0xd5880
testq %rdi, %rdi
je 0x6e0c0
callq 0x3a180
movq 0x2c9d91(%rip), %rdi    # 0x337e58
testq %rdi, %rdi
je 0x6e0d1
callq 0x3a180
movq 0x2c9d58(%rip), %rdi    # 0x337e30
testq %rdi, %rdi
je 0x6e0ed
callq 0x2ff55
movq $0x0, 0x2c9d43(%rip) # 0x337e30
movq 0x2c9d44(%rip), %rdi    # 0x337e38
testq %rdi, %rdi
je 0x6e109
callq 0x2ff55
movq $0x0, 0x2c9d2f(%rip) # 0x337e38
movq 0x2c9d30(%rip), %rdi    # 0x337e40
testq %rdi, %rdi
je 0x6e125
callq 0x2ff55
movq $0x0, 0x2c9d1b(%rip) # 0x337e40
xorl %eax, %eax
popq %rbx
jmp 0xe278
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/process.c
// Function: os_command
void os_command(OPERATING_SYSTEM_COMMAND_TYPE cmd_index)
{
 /*!Last Changed 19.04.2007*/
 int i;
 char st[MAXLENGTH];
 switch (get_parameter_l("currentos"))
  {
   case WINDOWS:strcpy(st, windows_commands[cmd_index]);
                break;
   case SOLARIS:
   case   LINUX:strcpy(st, linux_commands[cmd_index]);
                break;
  }
 for (i = 0; i < paramcount; i++)
   sprintf(st, "%s %s", st, params[i]);
 system(st);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movl %edi, %ebx
leaq 0x390b9(%rip), %rdi     # 0xa71fe
callq 0x54afc
cmpl $0x2, %eax
ja 0x6e16a
movl %eax, %eax
leaq 0x65af0(%rip), %rcx     # 0xd3c48
movq (%rcx,%rax,8), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %rsi
movq %rsp, %rdi
callq 0x4270
cmpl $0x0, 0x343e2f(%rip)    # 0x3b1fa0
jle 0x6e1ad
leaq 0x673b6(%rip), %r15     # 0xd5530
leaq 0x42324(%rip), %rbx     # 0xb04a5
movq %rsp, %r14
xorl %r12d, %r12d
movq (%r15), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x41b0
incq %r12
movslq 0x343dfc(%rip), %rax    # 0x3b1fa0
addq $0x8, %r15
cmpq %rax, %r12
jl 0x6e187
movq %rsp, %rdi
callq 0x4100
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/pstricks.c
// Function: write_rectangle_pstricks
void write_rectangle_pstricks(FILE* myfile, double corner1x, double corner1y, double corner2x, double corner2y, FILL_TYPE filltype, int color)
{
 switch (filltype)
  {
   case FILL_NONE      :fprintf(myfile, "\\psframe(%f, %f)(%f, %f)\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_FLOOD     :fprintf(myfile, "\\psframe[fillstyle=solid,fillcolor=black](%f, %f)(%f, %f)\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_GRAY      :fprintf(myfile, "\\psframe[fillstyle=solid,fillcolor=lightgray](%f, %f)(%f, %f)\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_VERTICAL  :fprintf(myfile, "\\psframe[fillstyle=vlines](%f, %f)(%f, %f)\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_HORIZONTAL:fprintf(myfile, "\\psframe[fillstyle=hlines](%f, %f)(%f, %f)\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_SQUARE    :fprintf(myfile, "\\psframe[fillstyle=crosshatch](%f, %f)(%f, %f)\n", corner1x, corner1y, corner2x, corner2y);
                        break;
   case FILL_COLOR     :fprintf(myfile, "\\psframe[fillstyle=solid,fillcolor=%s](%f, %f)(%f, %f)\n", pstrickscolors[color], corner1x, corner1y, corner2x, corner2y);
                        break;
  }
}

// Assembly:
cmpl $0x6, %esi
ja 0x6e235
movl %esi, %eax
leaq 0x40b5b(%rip), %rcx     # 0xaed50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x40ce9(%rip), %rsi     # 0xaeeee
jmp 0x6e24f
movslq %edx, %rax
leaq 0x6709f(%rip), %rcx     # 0xd52b0
movq (%rcx,%rax,8), %rdx
leaq 0x40dee(%rip), %rsi     # 0xaf00a
movb $0x4, %al
jmp 0x42e0
leaq 0x40d19(%rip), %rsi     # 0xaef43
jmp 0x6e24f
leaq 0x40da7(%rip), %rsi     # 0xaefda
jmp 0x6e24f
retq
leaq 0x40ccb(%rip), %rsi     # 0xaef08
jmp 0x6e24f
leaq 0x40d3c(%rip), %rsi     # 0xaef82
jmp 0x6e24f
leaq 0x40d5f(%rip), %rsi     # 0xaefae
movb $0x4, %al
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/pstricks.c
// Function: position_in_multi_plot_pstricks
double position_in_multi_plot_pstricks(int groupindex, int index, int groupcount, int elementcount, double* barwidth)
{
 double emptywidth;
 emptywidth = ((sqrt(5) - 1) / ((elementcount + 2) * sqrt(5) + (elementcount - 2)));
 *barwidth = ((sqrt(5) + 1) / ((elementcount + 2) * sqrt(5) + (elementcount - 2)));
 return groupindex + emptywidth + index * (*barwidth);
}

// Assembly:
leal 0x2(%rcx), %eax
cvtsi2sd %eax, %xmm0
addl $-0x2, %ecx
cvtsi2sd %ecx, %xmm1
mulsd 0x3a162(%rip), %xmm0    # 0xa88d8
addsd %xmm1, %xmm0
movsd 0x3a15e(%rip), %xmm1    # 0xa88e0
divsd %xmm0, %xmm1
movsd 0x40692(%rip), %xmm2    # 0xaee20
cvtsi2sd %edi, %xmm3
divsd %xmm0, %xmm2
addsd %xmm1, %xmm3
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movsd %xmm2, (%r8)
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/rbf.c
// Function: allocate_rbfnetwork
Rbfnetworkptr allocate_rbfnetwork(Rbf_parameterptr params)
{
	/*!Last Changed 19.08.2007*/
	Rbfnetworkptr network;
	network = safemalloc(sizeof(Rbfnetwork), "allocate_rbfnetwork", 2);
	network->hidden = params->hidden;
	network->output = params->output;
	network->input = params->input;
 allocate_rbfweights(&(network->weights), params);
	return network;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3facc(%rip), %rsi     # 0xaf721
movl $0x40, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r14
movq (%rbx), %xmm0
pshufd $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
movq %xmm0, (%rax)
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r14)
leaq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x6fbf7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/rbf.c
// Function: initialize_rbfnetwork
void initialize_rbfnetwork(Rbfnetworkptr network, Instanceptr data, Rbf_parameterptr params)
{
	/*!Last Changed 20.08.2007*/
	int i, j;
	double* spreads;
	Instanceptr clustermeans, tmp;
	clustermeans = k_means_clustering(data, params->hidden);
	tmp = clustermeans;
	for (i = 0; i < params->hidden; i++)
	 {
		 for (j = 0; j < network->input; j++)
				 network->weights.m.values[i][j] = real_feature(tmp, j);
		 tmp = tmp->next;
	 }
	spreads = cluster_spreads(data, clustermeans, params->hidden);
 for (i = 0; i < params->hidden; i++)
   network->weights.s.values[0][i] = spreads[i];
	assignTwoDimRandomWeights(&(network->weights.w), params->randrange);
	deallocate(clustermeans);
	safe_free(spreads);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movl 0x4(%rdx), %esi
movq %r12, %rdi
callq 0xcdff
movl 0x4(%rbx), %edx
testl %edx, %edx
movq %rax, (%rsp)
jle 0x6fd01
movl 0x8(%r14), %esi
xorl %r15d, %r15d
movq %rax, %r13
testl %esi, %esi
jle 0x6fcf2
xorl %ebp, %ebp
movq %r13, %rdi
movl %ebp, %esi
callq 0x2ed6a
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
movslq 0x8(%r14), %rsi
cmpq %rsi, %rbp
jl 0x6fccc
movl 0x4(%rbx), %edx
movq 0x10(%r13), %r13
incq %r15
movslq %edx, %rcx
cmpq %rcx, %r15
jl 0x6fcc6
movq %r12, %rdi
movq (%rsp), %r15
movq %r15, %rsi
callq 0xccd8
movq %rax, %r12
movslq 0x4(%rbx), %rax
testq %rax, %rax
jle 0x6fd38
movq 0x28(%r14), %rcx
movq (%rcx), %rcx
xorl %edx, %edx
movsd (%r12,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x6fd25
addq $0x30, %r14
movsd 0x20(%rbx), %xmm0
movq %r14, %rdi
callq 0x3f61d
movq %r15, %rdi
callq 0x2ff55
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/rbf.c
// Function: copy_of_rbfnetwork
Rbfnetworkptr copy_of_rbfnetwork(Rbfnetworkptr network, Rbf_parameterptr params)
{
	/*!Last Changed 19.08.2007*/
	Rbfnetworkptr copy;
	copy = allocate_rbfnetwork(params);
 copy_rbfweights(&(copy->weights), network->weights);
	return copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x6fc47
movq %rax, %r14
leaq 0x10(%rax), %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x20(%rbx), %r15
movq 0x28(%rbx), %r12
movq 0x30(%rbx), %r13
movq 0x38(%rbx), %rbx
callq 0x406d5
leaq 0x20(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x406d5
leaq 0x30(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x406d5
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq