LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x463b2(%rip), %rdi     # 0x9b8ae
xorl %eax, %eax
callq 0x4030
movq 0x76ac6(%rip), %rax     # 0xcbfd0
movq (%rax), %rdx
leaq 0x2da96c(%rip), %rbx    # 0x32fe80
movq %rbx, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x4120
movq %rbx, %rdi
callq 0x4190
movb $0x0, -0x1(%rax,%rbx)
movq %rbx, %rdi
callq 0x31e63
leaq 0x4c3df(%rip), %rsi     # 0xa191c
movq %rbx, %rdi
callq 0x4280
testq %rax, %rax
je 0x555ae
movq 0x77fd7(%rip), %rdi     # 0xcd528
movq %rax, %rsi
callq 0x3604c
movq %rax, 0x77fc8(%rip)     # 0xcd528
pushq $-0x1
popq %rcx
leaq 0x4c3b2(%rip), %rbx     # 0xa191c
leaq 0x77fbf(%rip), %r14     # 0xcd530
incl %ecx
movl %ecx, 0x354a27(%rip)    # 0x3a9fa0
xorl %edi, %edi
movq %rbx, %rsi
callq 0x4280
testq %rax, %rax
je 0x555ae
movslq 0x354a11(%rip), %rcx    # 0x3a9fa0
movq (%r14,%rcx,8), %rdi
movq %rax, %rsi
callq 0x3604c
movslq 0x3549fe(%rip), %rcx    # 0x3a9fa0
movq %rax, (%r14,%rcx,8)
cmpq $0x63, %rcx
jl 0x55571
jmp 0x555b7
cmpl $0x63, 0x3549eb(%rip)   # 0x3a9fa0
jl 0x555c3
leaq 0x490b3(%rip), %rdi     # 0x9e671
callq 0x4090
leaq 0x77f66(%rip), %rbx     # 0xcd530
xorl %r14d, %r14d
movslq 0x3549cc(%rip), %rax    # 0x3a9fa0
cmpq %rax, %r14
jge 0x555ea
movq (%rbx), %rdi
callq 0x317f0
incq %r14
addq $0x8, %rbx
jmp 0x555cd
leaq 0x77f3f(%rip), %rcx     # 0xcd530
andq $0x0, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/process.c
// Function: outlier_features
int outlier_features(char* datasetname)
{
 /*!Last Changed 23.02.2007 added free of variancefeatures*/
 /*!Last Changed 26.03.2004*/
 Datasetptr tmp;
 Instanceptr list;
 Instance variancefeatures;
 int i, count = 0, size, j, start, end;
 double sum;
 tmp = search_dataset(Datasets, datasetname);
 if (!tmp)
  {
   printf(m1279, datasetname);
   return -1;
  }
 current_dataset = tmp;
 if (traindata)
  {
   deallocate(traindata);
   traindata = NULL;
  }
 read_from_train_file(tmp, &traindata);
 variancefeatures = find_variance(traindata);
 for (i = 0; i < tmp->featurecount; i++)
   if (in_list(tmp->features[i].type, 2, REAL, INTEGER))
    {
     list = sort_instances(traindata, i, &size);
     sum = 0;
     start = (int)(size * 0.05);
     end = (int)(size * 0.95);
     for (j = start; j <= end; j++)
       sum += list[j].values[i].floatvalue;
     sum /= (end - start + 1);
     if (variancefeatures.values[i].floatvalue / sum < 0.7)
       count++;
     safe_free(list);
    }
 safe_free(variancefeatures.values);
 return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x78262(%rip), %rdi     # 0xcd878
movq %rbx, %rsi
callq 0x13da6
testq %rax, %rax
je 0x55755
movq %rax, %r14
movq %rax, 0x7823f(%rip)     # 0xcd870
movq 0x2da7f8(%rip), %rdi    # 0x32fe30
testq %rdi, %rdi
je 0x5564a
callq 0x2c010
andq $0x0, 0x2da7e6(%rip)    # 0x32fe30
leaq 0x2da7df(%rip), %rsi    # 0x32fe30
movq %r14, %rdi
callq 0x5577a
movq 0x2da7d0(%rip), %rsi    # 0x32fe30
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1197e
movq (%rbx), %r15
movq %r14, %rbx
addq $0x30f08, %rbx          # imm = 0x30F08
pushq $0x2
popq %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movslq 0x1bc(%r14), %rax
cmpq %rax, %r13
jge 0x5574b
imulq $0x340, %r13, %rax      # imm = 0x340
movl (%rbx,%rax), %edi
movl %r12d, %esi
movl %r12d, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x55743
movq 0x2da775(%rip), %rdi    # 0x32fe30
movl %r13d, %esi
leaq 0x8(%rsp), %rdx
callq 0x90c1a
cvtsi2sdl 0x8(%rsp), %xmm0
movapd %xmm0, %xmm1
mulsd 0x456ee(%rip), %xmm1    # 0x9adc8
cvttsd2si %xmm1, %ecx
mulsd 0x4472a(%rip), %xmm0    # 0x99e10
cvttsd2si %xmm0, %edx
movslq %ecx, %rsi
movslq %edx, %rdi
imulq $0x30, %rsi, %r8
addq %rax, %r8
xorpd %xmm0, %xmm0
cmpq %rdi, %rsi
jg 0x55712
movq (%r8), %r9
addsd (%r9,%r13,8), %xmm0
incq %rsi
addq $0x30, %r8
jmp 0x556fb
subl %ecx, %edx
incl %edx
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
movsd (%r15,%r13,8), %xmm1
divsd %xmm0, %xmm1
xorl %ecx, %ecx
movsd 0x4569e(%rip), %xmm0    # 0x9add0
ucomisd %xmm1, %xmm0
seta %cl
addl %ecx, %ebp
movq %rax, %rdi
callq 0x34ff7
incq %r13
jmp 0x55683
movq %r15, %rdi
callq 0x34ff7
jmp 0x55769
leaq 0x46137(%rip), %rdi     # 0x9b893
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4030
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0x14f75
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x550f7
movl %eax, %ebx
movq %r15, %rdi
callq 0x34ff7
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5577a
pushq $0x1
popq %rax
movl %eax, 0x354468(%rip)    # 0x3a9fa4
movl %eax, 0x2da32e(%rip)    # 0x32fe70
movq (%rbx), %rdi
callq 0xfc81
movq %r14, %rdi
callq 0x11d5c
movq (%rbx), %rsi
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x116b6
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x354451(%rip)   # 0x3a9fc8
movups %xmm1, 0x35443a(%rip)   # 0x3a9fb8
movups %xmm0, 0x354423(%rip)   # 0x3a9fa8
movq (%rbx), %rsi
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x1197e
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x35444e(%rip)   # 0x3a9ff8
movups %xmm1, 0x354437(%rip)   # 0x3a9fe8
movups %xmm0, 0x354420(%rip)   # 0x3a9fd8
movq (%rbx), %rdi
movups 0x354436(%rip), %xmm0   # 0x3a9ff8
movups %xmm0, 0x50(%rsp)
movups 0x35441a(%rip), %xmm0   # 0x3a9fe8
movups %xmm0, 0x40(%rsp)
movups 0x3543fe(%rip), %xmm0   # 0x3a9fd8
movups %xmm0, 0x30(%rsp)
movups 0x3543e2(%rip), %xmm0   # 0x3a9fc8
movups %xmm0, 0x20(%rsp)
movups 0x3543c6(%rip), %xmm0   # 0x3a9fb8
movups %xmm0, 0x10(%rsp)
movups 0x3543aa(%rip), %xmm0   # 0x3a9fa8
movups %xmm0, (%rsp)
callq 0xfad8
movq 0x35439a(%rip), %rdi    # 0x3a9fa8
callq 0x34ff7
movq 0x3543be(%rip), %rdi    # 0x3a9fd8
callq 0x34ff7
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x356ca
testl %eax, %eax
je 0x55cc4
movq %r14, %rdi
callq 0x4200
movl %eax, %r13d
movq %rbx, %rdi
callq 0x4200
xorl %ebp, %ebp
pushq $-0x1
popq %r8
movq %r12, %rdi
xorl %esi, %esi
movl %r13d, %edx
movl %eax, %ecx
callq 0x551d4
testq %rax, %rax
je 0x55d48
movq %rax, %r13
movq %r14, %rdi
callq 0x4200
movq %r13, (%rsp)
movq %r15, %r13
movl %eax, %r15d
movq %rbx, %rdi
callq 0x4200
pushq $0x1
popq %rsi
pushq $-0x1
popq %r8
movq %r12, %rdi
movl %r15d, %edx
movq %r13, %r15
movq (%rsp), %r13
movl %eax, %ecx
callq 0x551d4
testq %rax, %rax
je 0x55d48
movq %rax, %rbx
jmp 0x55cc7
movq %r14, %r13
leaq 0x2da162(%rip), %rdx    # 0x32fe30
movq %r12, %rdi
movq %r13, %rsi
callq 0x550f7
xorl %ebp, %ebp
testl %eax, %eax
je 0x55d48
leaq 0x2da152(%rip), %rdx    # 0x32fe38
movq %r12, %rdi
movq %rbx, %rsi
callq 0x550f7
testl %eax, %eax
je 0x55d48
testq %r15, %r15
je 0x55d10
leaq 0x2da13f(%rip), %rdx    # 0x32fe40
movq %r12, %rdi
movq %r15, %rsi
callq 0x550f7
testl %eax, %eax
je 0x55d48
movq %r14, %rdi
callq 0x356ca
testl %eax, %eax
je 0x55d2c
movq %r13, %rdi
callq 0x34ff7
movq %rbx, %rdi
callq 0x34ff7
pushq $0x1
popq %rbp
movq 0x2da0fa(%rip), %rdi    # 0x32fe30
callq 0x2c3cc
movq 0x77b2e(%rip), %rcx     # 0xcd870
movl %eax, 0x1407124(%rcx)
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_O2/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 0x2da0ac(%rip), %rdi    # 0x32fe58
testq %rdi, %rdi
je 0x55db6
callq 0x34ff7
movq 0x77ab3(%rip), %rax     # 0xcd870
movslq 0x1407120(%rax), %rdi
shlq $0x2, %rdi
leaq 0x45b26(%rip), %rsi     # 0x9b8f5
pushq $0x9
popq %rdx
callq 0x34f59
movq %rax, 0x2da07a(%rip)    # 0x32fe58
movq 0x77a8b(%rip), %rdi     # 0xcd870
callq 0x55e4c
testl %eax, %eax
je 0x55e3f
xorl %r15d, %r15d
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x55d59
movq 0x77a6d(%rip), %rdi     # 0xcd870
testq %rax, %rax
je 0x55e3a
movq %rbx, %rsi
xorl %edx, %edx
callq 0x16e32
testq %rax, %rax
je 0x55df4
movq %rax, %r14
movq %rax, %rdi
callq 0x2b47e
movq 0x2da02f(%rip), %rcx    # 0x32fe58
movl %eax, (%rcx,%r15,4)
movq %r14, %rdi
callq 0x2c010
incq %r15
jmp 0x55df4
callq 0x55ecf
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x140713c(%rdi), %edi
pushq $0x2
popq %rcx
pushq $0x3
popq %rsi
xorl %edx, %edx
movl %esi, %r8d
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x55ea6
movq %rbx, %rdi
callq 0x14f75
movq %rax, %r14
leaq 0x459fd(%rip), %rsi     # 0x9b87f
movq %rax, %rdi
callq 0x40f0
movq %rax, %r15
movq %rax, 0x354174(%rip)    # 0x3aa008
movq %r14, %rdi
callq 0x34ff7
testq %r15, %r15
je 0x55eb3
pushq $0x1
popq %rbx
jmp 0x55ec7
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x17262
movq 0x8(%rbx), %rsi
leaq 0x45b8c(%rip), %rdi     # 0x9ba4a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4030
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/process.c
// Function: close_dataset
void close_dataset(Datasetptr dataset)
{
 /*!Last Changed 07.04.2007 added STORE_TIME*/
 /*!Last Changed 29.12.2005*/
 if (in_list(dataset->storetype, 3, STORE_TEXT, STORE_SEQUENTIAL, STORE_KERNEL))
   fclose(datafile);
 else
   disconnect_from_database();
}

// Assembly:
pushq %rax
movl 0x140713c(%rdi), %edi
pushq $0x2
popq %rcx
pushq $0x3
popq %rsi
xorl %edx, %edx
movl %esi, %r8d
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x55ef9
movq 0x354115(%rip), %rdi    # 0x3aa008
popq %rax
jmp 0x42a0
xorl %eax, %eax
popq %rcx
jmp 0x17265
// File: /workspace/github_c_makefile_star2_O2/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 0x77959(%rip), %rax     # 0xcd870
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
leaq 0x459e5(%rip), %rsi     # 0x9b90b
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %r14
xorl %eax, %eax
movq 0x77936(%rip), %rcx     # 0xcd870
movslq 0x10(%rcx), %rdx
cmpq %rdx, %rax
jge 0x55f50
movl (%r15,%rax,4), %edx
movl %edx, (%r14,%rax,4)
incq %rax
jmp 0x55f3a
leaq 0x2d9ed9(%rip), %r12    # 0x32fe30
xorl %r13d, %r13d
xorl %r15d, %r15d
movslq 0x775ac(%rip), %rax     # 0xcd510
cmpq %rax, %r15
jge 0x55fc0
xorl %eax, %eax
callq 0x35c7f
cltd
idivl 0x77599(%rip)           # 0xcd510
movslq %edx, %rax
movslq (%rbx,%rax,4), %rcx
movl (%r14,%rcx,4), %edx
testl %edx, %edx
je 0x55f69
decl %edx
movl %edx, (%r14,%rcx,4)
movq 0x778dd(%rip), %rdi     # 0xcd870
movq 0x778c6(%rip), %rcx     # 0xcd860
movq (%rcx,%rax,8), %rsi
xorl %edx, %edx
callq 0x16e32
addq $0x10, %r13
testq %r15, %r15
cmoveq %r12, %r13
movq %rax, (%r13)
movl %r15d, 0x18(%rax)
incq %r15
movq %rax, %r13
jmp 0x55f5d
movq %r14, %rdi
callq 0x34ff7
movq 0x778a1(%rip), %rax     # 0xcd870
movl %r15d, 0x1407124(%rax)
cmpl $0x0, 0x772cf(%rip)     # 0xcd2ac
je 0x55ff7
movq 0x2d9e4a(%rip), %rdi    # 0x32fe30
movq %rdi, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x54edc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x458c1(%rip), %r14     # 0x9b8e3
xorl %ebx, %ebx
xorl %ebp, %ebp
movq $0x0, 0x8(%rsp)
movslq 0x774da(%rip), %rax     # 0xcd510
cmpq %rax, %rbx
jge 0x560df
movq 0x7782a(%rip), %r12     # 0xcd870
movq 0x77813(%rip), %rax     # 0xcd860
movq (%rax,%rbx,8), %r13
movq %r14, %rdi
callq 0x4cff1
movq %r12, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x16e32
testq %rax, %rax
je 0x5602f
movq %rax, %r12
movq 0x10(%rsp), %rax
movl (%rax,%rbx,4), %r13d
leaq 0x48a8e(%rip), %rdi     # 0x9eb0c
callq 0x4cd35
movl %eax, %ecx
movl %r13d, %eax
cltd
idivl %ecx
cmpl 0x4(%rsp), %edx
jne 0x560b7
movq 0x8(%rsp), %rcx
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
leaq 0x2d9d94(%rip), %rcx    # 0x32fe38
cmoveq %rcx, %rax
movq %r12, (%rax)
movl %ebx, 0x18(%r12)
movq %r12, 0x8(%rsp)
jmp 0x560d7
leaq 0x10(%rbp), %rax
testq %rbp, %rbp
leaq 0x2d9d6b(%rip), %rcx    # 0x32fe30
cmoveq %rcx, %rax
movq %r12, (%rax)
movl %r15d, 0x18(%r12)
incq %r15
movq %r12, %rbp
incq %rbx
jmp 0x5602f
movq 0x7778a(%rip), %rax     # 0xcd870
movl %r15d, 0x1407124(%rax)
cmpl $0x0, 0x771b8(%rip)     # 0xcd2ac
je 0x56126
movq 0x2d9d33(%rip), %rdi    # 0x32fe30
movq %rdi, %rsi
callq 0x54edc
movq 0x2d9d24(%rip), %rdi    # 0x32fe30
movq 0x2d9d25(%rip), %rsi    # 0x32fe38
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x54edc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %esi, %ebx
leaq 0x60(%rsp), %r15
andq $0x0, (%r15)
movq %rdi, %r14
andl $0x0, 0x2d980f(%rip)    # 0x32fe70
callq 0x55d99
movl %ebx, %edi
callq 0x35ca7
movq %r15, %rdi
callq 0x567cb
movq %rax, %rbx
movq 0x771d9(%rip), %rdi     # 0xcd858
movl 0x76e87(%rip), %esi     # 0xcd50c
leaq 0x68(%rsp), %r15
movq %r15, %rdx
callq 0x56a16
movq (%r15), %r12
movups 0x35395c(%rip), %xmm0   # 0x3a9ff8
movups %xmm0, 0x50(%rsp)
movups 0x353940(%rip), %xmm0   # 0x3a9fe8
movups %xmm0, 0x40(%rsp)
movups 0x353924(%rip), %xmm0   # 0x3a9fd8
movups %xmm0, 0x30(%rsp)
movups 0x353908(%rip), %xmm0   # 0x3a9fc8
movups %xmm0, 0x20(%rsp)
movups 0x3538ec(%rip), %xmm0   # 0x3a9fb8
movups %xmm0, 0x10(%rsp)
movups 0x3538d0(%rip), %xmm0   # 0x3a9fa8
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x56a9e
pushq $0x2
popq %rsi
pushq $-0x2
popq %rbp
movq %r14, %rdi
movl %ebp, %edx
movl %ebp, %ecx
movq %r12, %r8
xorl %r9d, %r9d
callq 0x56b5c
xorl %edi, %edi
callq 0x5549c
movq %r12, %rdi
callq 0x2c010
movq 0x7714e(%rip), %rdi     # 0xcd860
movl 0x76df8(%rip), %esi     # 0xcd510
movq %r15, %rdx
callq 0x56a16
movq (%r15), %r15
movups 0x3538ce(%rip), %xmm0   # 0x3a9ff8
movups %xmm0, 0x50(%rsp)
movups 0x3538b2(%rip), %xmm0   # 0x3a9fe8
movups %xmm0, 0x40(%rsp)
movups 0x353896(%rip), %xmm0   # 0x3a9fd8
movups %xmm0, 0x30(%rsp)
movups 0x35387a(%rip), %xmm0   # 0x3a9fc8
movups %xmm0, 0x20(%rsp)
movups 0x35385e(%rip), %xmm0   # 0x3a9fb8
movups %xmm0, 0x10(%rsp)
movups 0x353842(%rip), %xmm0   # 0x3a9fa8
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x56a9e
pushq $0x3
popq %rsi
movq %r14, %rdi
movl %ebp, %edx
movl %ebp, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x56b5c
xorl %edi, %edi
callq 0x5549c
movq %r15, %rdi
callq 0x2c010
callq 0x59120
testq %rbx, %rbx
je 0x567be
movq %rbx, %rdi
callq 0x34ff7
movq 0x60(%rsp), %rdi
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq 0x76e40(%rip), %r15     # 0xcd870
movq (%rdi), %r13
leaq 0x44ea9(%rip), %rdi     # 0x9b8e3
callq 0x4cff1
movq %r15, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x16e32
movq %rax, %r15
movq %rax, (%r12)
movslq %ebp, %rbp
pushq $0x1
popq %r14
cmpq %rbp, %r14
jge 0x56a8f
movq 0x76e0a(%rip), %r12     # 0xcd870
movq (%rbx,%r14,8), %r13
leaq 0x44e72(%rip), %rdi     # 0x9b8e3
callq 0x4cff1
movq %r12, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x16e32
movq %rax, 0x10(%r15)
incq %r14
movq %rax, %r15
jmp 0x56a5a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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, 0x3534f7(%rip)    # 0x3a9fa4
je 0x56aeb
movq 0x76dba(%rip), %rax     # 0xcd870
movslq 0x1c0(%rax), %rcx
decq %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
jge 0x56ad7
movl $0x1, 0x18864(%rax,%rdx,4)
incq %rdx
jmp 0x56ac2
movq %rbx, %rdi
callq 0xfc81
movq 0x76d8a(%rip), %rdi     # 0xcd870
callq 0x11d5c
cmpl $0x0, 0x2d937e(%rip)    # 0x32fe70
je 0x56b45
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)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xfad8
cmpl $0x0, 0x353461(%rip)    # 0x3a9fa4
je 0x56b4b
addq $0x60, %rsp
popq %rbx
retq
movq 0x76d1e(%rip), %rdi     # 0xcd870
addq $0x60, %rsp
popq %rbx
jmp 0x16c95
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r12
movq %rdi, %r14
movq 0x76cf9(%rip), %rdi     # 0xcd870
incl %edx
incl %ecx
pushq $-0x1
popq %r8
callq 0x551d4
testq %rax, %rax
je 0x56c08
movq %rax, %r15
leaq 0x44cfe(%rip), %rsi     # 0x9b891
movq %rax, %rdi
callq 0x40f0
testq %rax, %rax
je 0x56c08
movq %rax, %r13
leaq 0x404b1(%rip), %rdi     # 0x9705b
callq 0x4cf11
cmpl $0x5, %eax
jne 0x56c17
movq 0x76cb5(%rip), %rsi     # 0xcd870
movq %r13, %rdi
callq 0x17a0f
leaq 0x44d66(%rip), %rdi     # 0x9b930
pushq $0x7
popq %rsi
pushq $0x1
popq %rbp
movq %rbp, %rdx
movq %r13, %rcx
callq 0x42c0
movsbl (%r14), %esi
movq 0x76c8a(%rip), %rdx     # 0xcd870
movq %r13, %rdi
movq %r12, %rcx
callq 0x2c563
leaq 0x44d40(%rip), %rdi     # 0x9b938
pushq $0x6
popq %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x42c0
jmp 0x56c1a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rbx
movsbl (%r14), %esi
movq 0x76c4b(%rip), %rdx     # 0xcd870
movq %r13, %rdi
movq %rbx, %rcx
callq 0x2c563
movq %r13, %rdi
callq 0x42a0
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/process.c
// Function: create_cvdata
void create_cvdata()
{
 /*!Last Changed 26.11.2005 removed bug safe_free(myarray) called for regression*/
 /*!Last Changed 28.10.2005 added find_classes and find_class_counts*/
 /*!Last Changed 23.11.2004 added traincount*/
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 14.01.2004*/
 int j, dat = data_size(traindata), *myarray = NULL, *partition, *classcounts = NULL;
 Instanceptr cvbefore = NULL, trainbefore = NULL, train = traindata; 
 if (cvdata)
  {
   deallocate(cvdata);
   cvdata = NULL;
  } 
 if (current_dataset->classno > 0)
  { 
   myarray = find_classes(traindata);
   classcounts = find_class_counts(traindata);
  }  
 partition = stratified_partition(myarray, dat, current_dataset->classno, classcounts);
 j = 0; 
 while (train)
  {
   if (partition[j] % 5 == 0)
    {
     if (cvbefore)
      {
       cvbefore->next = train;
       cvbefore = cvbefore->next;
      }
     else
      {
       cvdata = train;
       cvbefore = cvdata;
      }
    }
   else
     if (trainbefore)
      {
       trainbefore->next = train;
       trainbefore = trainbefore->next;
      }
     else
      {
       traindata = train;
       trainbefore = traindata;
      }
   train = train->next;
   j++;
  }
	if (trainbefore)
   trainbefore->next = NULL;
	if (cvbefore)
   cvbefore->next = NULL;
 current_dataset->traincount = data_size(traindata);
 if (current_dataset->classno > 0)
  {
   safe_free(classcounts);
   safe_free(myarray);
  }
 safe_free(partition);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x2d8ff4(%rip), %rdi    # 0x32fe30
callq 0x2c3cc
movl %eax, %ebp
movq 0x2d8fe6(%rip), %r12    # 0x32fe30
movq 0x2d8fef(%rip), %rdi    # 0x32fe40
testq %rdi, %rdi
je 0x56e63
callq 0x2c010
andq $0x0, 0x2d8fdd(%rip)    # 0x32fe40
movq 0x76a06(%rip), %rax     # 0xcd870
movl 0x10(%rax), %edx
testl %edx, %edx
jle 0x56e9b
movq 0x2d8fb8(%rip), %rdi    # 0x32fe30
callq 0x10987
movq %rax, %rbx
movq 0x2d8fa9(%rip), %rdi    # 0x32fe30
callq 0x108c8
movq %rax, %r14
movq 0x769da(%rip), %rax     # 0xcd870
movl 0x10(%rax), %edx
jmp 0x56ea0
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rcx
callq 0x2ba93
movq %rax, %r15
xorl %ecx, %ecx
pushq $0x5
popq %rdi
leaq 0x2d8f84(%rip), %r8     # 0x32fe40
leaq 0x2d8f6d(%rip), %r9     # 0x32fe30
movq %rax, %r10
xorl %esi, %esi
testq %r12, %r12
je 0x56f04
movl (%r10), %eax
cltd
idivl %edi
testl %edx, %edx
movq %rsi, %rax
cmoveq %rcx, %rax
movq %r9, %rdx
cmoveq %r8, %rdx
cmoveq %r12, %rcx
cmovneq %r12, %rsi
leaq 0x10(%rax), %r11
testq %rax, %rax
cmoveq %rdx, %r11
movq %r12, (%r11)
movq 0x10(%r12), %r12
addq $0x4, %r10
jmp 0x56ec8
testq %rsi, %rsi
je 0x56f0e
andq $0x0, 0x10(%rsi)
testq %rcx, %rcx
je 0x56f18
andq $0x0, 0x10(%rcx)
movq 0x2d8f11(%rip), %rdi    # 0x32fe30
callq 0x2c3cc
movq 0x76945(%rip), %rcx     # 0xcd870
movl %eax, 0x1407124(%rcx)
cmpl $0x0, 0x10(%rcx)
jle 0x56f47
movq %r14, %rdi
callq 0x34ff7
movq %rbx, %rdi
callq 0x34ff7
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
xorl %r12d, %r12d
testl %esi, %esi
movl $0x0, %r13d
cmovgl %esi, %r13d
cmpl %r12d, %r13d
je 0x590c5
xorps %xmm0, %xmm0
movsd 0x3c495(%rip), %xmm1    # 0x95520
callq 0x35cae
movq %r14, %rdi
movl %ebp, %esi
callq 0x33688
movq 0x747cf(%rip), %rdi     # 0xcd870
cltq
movq (%r15,%rax,8), %rsi
xorl %edx, %edx
callq 0x16e32
addq $0x10, %rbx
testl %r12d, %r12d
cmoveq (%rsp), %rbx
movq %rax, (%rbx)
incl %r12d
movq %rax, %rbx
jmp 0x5907b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0x74738(%rip), %rdi     # 0xcd860
movl 0x743e2(%rip), %esi     # 0xcd510
callq 0x34fc3
andl $0x0, 0x743d6(%rip)     # 0xcd510
andq $0x0, 0x7471e(%rip)     # 0xcd860
leaq 0x4292a(%rip), %rdi     # 0x9ba73
callq 0x4cdcf
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x59179
movq 0x746f9(%rip), %rdi     # 0xcd858
movl 0x743a7(%rip), %esi     # 0xcd50c
callq 0x34fc3
andl $0x0, 0x7439b(%rip)     # 0xcd50c
andq $0x0, 0x746df(%rip)     # 0xcd858
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x746e2(%rip), %rdi     # 0xcd870
callq 0x55e4c
testl %eax, %eax
je 0x591dd
movq %rsp, %rbx
leaq 0x746bf(%rip), %r14     # 0xcd860
leaq 0x74368(%rip), %r15     # 0xcd510
movq %rbx, %rsi
callq 0x55d59
testq %rax, %rax
je 0x591d1
movq %rbx, %rdi
callq 0x352fc
testl %eax, %eax
jne 0x591a8
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x590d4
jmp 0x591a8
movq 0x74698(%rip), %rdi     # 0xcd870
callq 0x55ecf
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14d
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %rdx
movq %rdi, %r15
movl 0x345138(%rip), %edi    # 0x3a9fa0
pushq $0x1
popq %rsi
xorl %eax, %eax
callq 0x358ba
testl %eax, %eax
je 0x64e90
movq 0x686b3(%rip), %rdi     # 0xcd530
movq %rbx, %rsi
movl %r14d, %edx
callq 0x35f17
cmpl $-0x1, %eax
je 0x64e9f
movl %eax, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6868a(%rip), %rsi     # 0xcd530
xorl %r13d, %r13d
movq %r12, %rdi
xorl %eax, %eax
callq 0x4030
leaq 0x35bfc(%rip), %rdi     # 0x9aab6
callq 0x4090
testl %r14d, %r14d
cmovlel %r13d, %r14d
leaq 0x33003(%rip), %r12     # 0x97ed0
pushq $0xa
popq %rbp
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x64ef2
movq (%rbx,%r13,8), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x4030
movl %ebp, %edi
callq 0x40d0
incq %r13
jmp 0x64ed3
movslq (%r15), %rax
movq (%rbx,%rax,8), %rsi
leaq 0x36d6c(%rip), %rdi     # 0x9bc6c
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_O2/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
xorl %ebx, %ebx
movslq 0x685e1(%rip), %rax     # 0xcd500
cmpq %rax, %rbx
jge 0x64f39
movq 0x2caf3d(%rip), %rax    # 0x32fe68
movq (%rax,%rbx,8), %rdi
callq 0x47886
incq %rbx
jmp 0x64f18
xorl %eax, %eax
callq 0x12700
movq 0x68921(%rip), %rdi     # 0xcd868
movl 0x685b7(%rip), %esi     # 0xcd504
callq 0x303e1
movq 0x6890f(%rip), %rdi     # 0xcd868
callq 0x34ff7
movq 0x6891b(%rip), %rdi     # 0xcd880
testq %rdi, %rdi
je 0x64f6f
callq 0x34ff7
movq 0x2caee2(%rip), %rdi    # 0x32fe58
testq %rdi, %rdi
je 0x64f80
callq 0x34ff7
movq 0x2caea9(%rip), %rdi    # 0x32fe30
testq %rdi, %rdi
je 0x64f99
callq 0x2c010
andq $0x0, 0x2cae97(%rip)    # 0x32fe30
movq 0x2cae98(%rip), %rdi    # 0x32fe38
testq %rdi, %rdi
je 0x64fb2
callq 0x2c010
andq $0x0, 0x2cae86(%rip)    # 0x32fe38
movq 0x2cae87(%rip), %rdi    # 0x32fe40
testq %rdi, %rdi
je 0x64fcb
callq 0x2c010
andq $0x0, 0x2cae75(%rip)    # 0x32fe40
xorl %eax, %eax
popq %rbx
jmp 0xd8e3
// File: /workspace/github_c_makefile_star2_O2/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 0x321b3(%rip), %rdi     # 0x9719e
callq 0x4cf11
cmpl $0x2, %eax
ja 0x65010
movl %eax, %eax
leaq 0x66d9a(%rip), %rcx     # 0xcbd98
movq (%rcx,%rax,8), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %rsi
movq %rsp, %rdi
callq 0x4270
leaq 0x68519(%rip), %r15     # 0xcd530
leaq 0x3b3eb(%rip), %rbx     # 0xa0409
movq %rsp, %r14
xorl %r12d, %r12d
movslq 0x344f75(%rip), %rax    # 0x3a9fa0
cmpq %rax, %r12
jge 0x6504c
movq (%r15), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x41b0
incq %r12
addq $0x8, %r15
jmp 0x65024
movq %rsp, %rdi
callq 0x4100
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x650d5
movl %esi, %eax
leaq 0x39bdf(%rip), %rcx     # 0x9ec74
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x39d69(%rip), %rsi     # 0x9ee0e
jmp 0x650ef
movslq %edx, %rax
leaq 0x681ff(%rip), %rcx     # 0xcd2b0
movq (%rcx,%rax,8), %rdx
leaq 0x39e6e(%rip), %rsi     # 0x9ef2a
movb $0x4, %al
jmp 0x42e0
leaq 0x39d99(%rip), %rsi     # 0x9ee63
jmp 0x650ef
leaq 0x39e27(%rip), %rsi     # 0x9eefa
jmp 0x650ef
retq
leaq 0x39d4b(%rip), %rsi     # 0x9ee28
jmp 0x650ef
leaq 0x39dbc(%rip), %rsi     # 0x9eea2
jmp 0x650ef
leaq 0x39ddf(%rip), %rsi     # 0x9eece
movb $0x4, %al
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O2/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 0x3324c(%rip), %xmm0    # 0x98858
addsd %xmm1, %xmm0
movsd 0x33248(%rip), %xmm1    # 0x98860
divsd %xmm0, %xmm1
movsd 0x3971c(%rip), %xmm2    # 0x9ed40
cvtsi2sd %edi, %xmm3
divsd %xmm0, %xmm2
addsd %xmm1, %xmm3
cvtsi2sd %esi, %xmm0
movsd %xmm2, (%r8)
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x38f46(%rip), %rsi     # 0x9f641
pushq $0x40
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
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 0x6669f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc5c5
movq %rax, %r13
xorl %r15d, %r15d
movq %rax, (%rsp)
movslq 0x4(%rbx), %rdx
cmpq %rdx, %r15
jge 0x66796
xorl %ebp, %ebp
movslq 0x8(%r14), %rax
cmpq %rax, %rbp
jge 0x6678d
movq %r13, %rdi
movl %ebp, %esi
callq 0x2aea2
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
jmp 0x66768
movq 0x10(%r13), %r13
incq %r15
jmp 0x6675d
movq %r12, %rdi
movq (%rsp), %r15
movq %r15, %rsi
callq 0xc4d7
movq %rax, %r12
movl 0x4(%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x667ce
movsd (%r12,%rcx,8), %xmm0
movq 0x28(%r14), %rdx
movq (%rdx), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
jmp 0x667b2
addq $0x30, %r14
movsd 0x20(%rbx), %xmm0
movq %r14, %rdi
callq 0x398bd
movq %r15, %rdi
callq 0x2c010
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/rbf.c
// Function: distance_to_rbf_gaussian
double distance_to_rbf_gaussian(Instanceptr inst, int inputdim, double* mh)
{
	/*!Last Changed 19.08.2007*/
	int j;
	double sum;
	sum = 0.0;
	for (j = 0; j < inputdim; j++)
			sum += (real_feature(inst, j) - mh[j]) * (real_feature(inst, j) - mh[j]);
	return sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
xorl %r12d, %r12d
testl %esi, %esi
cmovlel %r12d, %r14d
xorpd %xmm0, %xmm0
cmpq %r12, %r14
je 0x668f2
movq %r15, %rdi
movl %r12d, %esi
movsd %xmm0, 0x8(%rsp)
callq 0x2aea2
subsd (%rbx,%r12,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movl %r12d, %esi
callq 0x2aea2
subsd (%rbx,%r12,8), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r12
jmp 0x6689e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/rbf.c
// Function: rbf_forward_propagation
void rbf_forward_propagation(Rbfnetworkptr network, Instanceptr inst, double* p, double* y)
{
	/*!Last Changed 19.08.2007*/
 double dist, s_h;
	int i, h;
	p[0] = 1.0;
	for (h = 1; h < network->hidden + 1; h++)
  {
   dist = distance_to_rbf_gaussian(inst, network->input, network->weights.m.values[h - 1]);
   s_h = network->weights.s.values[0][h - 1];
			p[h] = safeexp(-dist / (2 * s_h * s_h));
  }
	for (i = 0; i < network->output; i++)
	 {
		 y[i] = 0.0;
			for (h = 0; h < network->hidden + 1; h++)
				 y[i] += network->weights.w.values[i][h] * p[h];
	 }
	if (network->output > 1) /*For classification*/
  	softmax(y, network->output);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdx)
pushq $0x1
popq %r13
movslq (%r15), %rax
cmpq %rax, %r13
jg 0x66977
movl 0x8(%r15), %esi
movq 0x18(%r15), %rax
movq -0x8(%rax,%r13,8), %rdx
movq %r12, %rdi
callq 0x6687d
movq 0x28(%r15), %rax
movq (%rax), %rax
movsd -0x8(%rax,%r13,8), %xmm1
xorpd 0x2f879(%rip), %xmm0    # 0x961d0
movapd %xmm1, %xmm2
addsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
divsd %xmm2, %xmm0
callq 0x34d50
movsd %xmm0, (%r14,%r13,8)
incq %r13
jmp 0x66924
movl 0x4(%r15), %esi
xorl %ecx, %ecx
testl %esi, %esi
movl $0x0, %edx
cmovgl %esi, %edx
cmpq %rdx, %rcx
je 0x669c3
andq $0x0, (%rbx,%rcx,8)
xorpd %xmm0, %xmm0
xorl %edi, %edi
cmpq %rax, %rdi
jg 0x669be
movq 0x38(%r15), %r8
movq (%r8,%rcx,8), %r8
movsd (%r8,%rdi,8), %xmm1
mulsd (%r14,%rdi,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rdi
jmp 0x66997
incq %rcx
jmp 0x66987
cmpl $0x2, %esi
jl 0x669d9
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4dd7c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/rbf.c
// Function: real_actual_difference
double real_actual_difference(int output, Instanceptr inst, int classno, double* y)
{
	/*!Last Changed 19.08.2007*/
	double ri;
 if (output == 1)
			ri = give_regressionvalue(inst);
	else
			if (give_classno(inst) != classno)
				 ri = 0.0;
			else
					ri = 1.0;
	return ri - y[classno];
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
cmpl $0x1, %edi
jne 0x669fa
movq %rsi, %rdi
callq 0x2b4a0
jmp 0x66a14
movq %rsi, %rdi
callq 0x2b47e
cmpl %ebp, %eax
je 0x66a0c
xorpd %xmm0, %xmm0
jmp 0x66a14
movsd 0x2eb0c(%rip), %xmm0    # 0x95520
movslq %ebp, %rax
subsd (%rbx,%rax,8), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq