LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/poly.c
// Function: polydatagenerate
double** polydatagenerate(int datasize, double start, double end, char* polynomial, int noisy)
{
	/*!Last Changed 21.01.2005 rewritten*/
 int i;
 double x, value, **values;
 Polynomptr p = read_polynom(polynomial);
	values = (double **) safemalloc_2d(sizeof(double *), sizeof(double), datasize, 2, "polydatagenerate", 4);
 for (i = 0; i < datasize; i++)
  {
   x = produce_random_value(start, end);
   value = polynom_value(p, x);
   if (noisy)
     value = value + produce_normal_value(0, get_parameter_f("noiselevel"));
   values[i][0] = x;
   values[i][1] = value;
  }
	return values;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x82070
movq %rax, -0x48(%rbp)
movl -0x4(%rbp), %edx
movl $0x8, %esi
movl $0x2, %ecx
leaq 0x64950(%rip), %r8      # 0xe786d
movl $0x4, %r9d
movq %rsi, %rdi
callq 0x53120
movq %rax, -0x40(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x82fda
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x545a0
movsd %xmm0, -0x30(%rbp)
movq -0x48(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x81500
movsd %xmm0, -0x38(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x82fa1
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
leaq 0x602a1(%rip), %rdi     # 0xe3221
callq 0x79040
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
callq 0xc4710
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x40(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movq -0x40(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, 0x8(%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x82f36
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/poly.c
// Function: savepolydata
void savepolydata(char* fname, double** polydata, int datasize)
{
	/*!Last Changed 21.01.2005*/
 FILE* outfile;
	int i;
	char pst[READLINELENGTH];
 outfile = fopen(fname,"w");
 if (outfile == NULL)
   return;
 for (i = 0; i < datasize; i++)
	 {
			set_precision(pst, NULL, NULL);
			fprintf(outfile, pst, polydata[i][0]);
			set_precision(pst, " ", "\n");
		 fprintf(outfile, pst, polydata[i][1]);
	 }
 fclose(outfile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a150, %rsp          # imm = 0x7A150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x651ad(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x83026
jmp 0x830c2
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x830b9
leaq -0x7a150(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x53310
movq -0x20(%rbp), %rdi
leaq -0x7a150(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
movb $0x1, %al
callq 0x4280
leaq -0x7a150(%rbp), %rdi
leaq 0x62209(%rip), %rsi     # 0xe5285
leaq 0x62cb8(%rip), %rdx     # 0xe5d3b
callq 0x53310
movq -0x20(%rbp), %rdi
leaq -0x7a150(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x8(%rax), %xmm0
movb $0x1, %al
callq 0x4280
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8302d
movq -0x20(%rbp), %rdi
callq 0x4250
addq $0x7a150, %rsp          # imm = 0x7A150
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/process.c
// Function: fill_missing_values
void fill_missing_values(Instanceptr data, Instance mean)
{
 /*!Last Changed 16.10.2005*/
 int i;
 Instanceptr tmp;
 tmp = data;
 while (tmp)
  {
   for (i = 0; i < current_dataset->featurecount; i++)
     switch (current_dataset->features[i].type)
      {
       case INTEGER:if (tmp->values[i].intvalue == ISELL)
                      tmp->values[i].intvalue = mean.values[i].intvalue;
                    break;
       case    REAL:if (tmp->values[i].floatvalue == ISELL)
                      tmp->values[i].floatvalue = mean.values[i].floatvalue;
                    break;
       case  STRING:if (tmp->values[i].stringindex == -1)
                      tmp->values[i].stringindex = mean.values[i].stringindex;
                    break;
      }
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x85211
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq 0x8073c(%rip), %rcx     # 0x105840
cmpl 0x1bc(%rcx), %eax
jge 0x85200
movq 0x80729(%rip), %rax     # 0x105840
movslq -0xc(%rbp), %rcx
imulq $0x340, %rcx, %rcx      # imm = 0x340
movl 0x30f08(%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x8514d
jmp 0x85132
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x851c1
jmp 0x85140
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x8517f
jmp 0x851f0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x75bcd15, (%rax,%rcx,8) # imm = 0x75BCD15
jne 0x8517d
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,8), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,8)
jmp 0x851f0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x5d801(%rip), %xmm1    # 0xe2998
ucomisd %xmm1, %xmm0
jne 0x851bf
jp 0x851bf
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x851f0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,8)
jne 0x851ee
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,8), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,8)
jmp 0x851f0
jmp 0x851f2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x850fa
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x850e8
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0x85250
leaq 0x62f7c(%rip), %rdi     # 0xe81c0
movb $0x0, %al
callq 0x4030
jmp 0x8537b
movq 0x805f1(%rip), %rdi     # 0x105848
movq -0x8(%rbp), %rsi
callq 0x1db80
movq %rax, 0x805d9(%rip)     # 0x105840
cmpq $0x0, 0x805d1(%rip)     # 0x105840
jne 0x85288
movq -0x8(%rbp), %rsi
leaq 0x62f61(%rip), %rdi     # 0xe81dd
movb $0x0, %al
callq 0x4030
jmp 0x8537b
movq 0x805b1(%rip), %rdi     # 0x105840
movq -0x18(%rbp), %rsi
leaq 0x2e2b66(%rip), %rdx    # 0x367e00
callq 0x85390
cmpl $0x0, %eax
jne 0x852a9
jmp 0x8537b
movl -0x1c(%rbp), %esi
leaq 0x2e2b4d(%rip), %rdi    # 0x367e00
callq 0x45c40
movq %rax, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x8533c
movq 0x8056e(%rip), %rdi     # 0x105840
movl -0x34(%rbp), %r8d
addl $0x1, %r8d
movl $0x4, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %edx
callq 0x85500
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x62ec4(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movb (%rax), %al
movq 0x8052c(%rip), %rdx     # 0x105840
movq -0x40(%rbp), %rcx
movslq -0x34(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
movsbl %al, %esi
callq 0x44c60
movq -0x28(%rbp), %rdi
callq 0x4250
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x852c3
movq $0x0, 0x2e2ab9(%rip) # 0x367e00
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x85372
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x44510
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x8534e
movq -0x40(%rbp), %rdi
callq 0x52e80
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x7a180, %rsp          # imm = 0x7A180
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x7a154(%rbp)
movq $0x0, -0x7a168(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x62ddf(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x853f5
movq -0x18(%rbp), %rsi
leaq 0x5e7e9(%rip), %rdi     # 0xe3bcb
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x854ed
jmp 0x853f7
leaq -0x7a150(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
cmpq $0x0, %rax
je 0x854c1
movq -0x10(%rbp), %rax
movq %rax, -0x7a178(%rbp)
leaq -0x7a150(%rbp), %rax
movq %rax, -0x7a170(%rbp)
leaq 0x62e3d(%rip), %rdi     # 0xe8273
callq 0x79440
movq -0x7a178(%rbp), %rdi
movq -0x7a170(%rbp), %rsi
movl %eax, %edx
callq 0x22c30
movq %rax, -0x7a160(%rbp)
cmpq $0x0, -0x7a160(%rbp)
jne 0x85463
jmp 0x853f7
cmpq $0x0, -0x7a168(%rbp)
je 0x85481
movq -0x7a160(%rbp), %rcx
movq -0x7a168(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x8548f
movq -0x7a160(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x7a154(%rbp), %ecx
movq -0x7a160(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x7a154(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7a154(%rbp)
movq -0x7a160(%rbp), %rax
movq %rax, -0x7a168(%rbp)
jmp 0x853f7
movq -0x28(%rbp), %rdi
callq 0x4250
cmpl $0x0, 0x7fdab(%rip)     # 0x10527c
je 0x854e6
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x85060
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x7a180, %rsp          # imm = 0x7A180
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, 0x2e26ae(%rip)    # 0x367e40
movq -0x20(%rbp), %rdi
leaq 0x62a21(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x857b2
jmp 0x85854
movq 0x8008f(%rip), %rdi     # 0x105848
movq -0x8(%rbp), %rsi
callq 0x1db80
movq %rax, 0x80077(%rip)     # 0x105840
cmpq $0x0, 0x8006f(%rip)     # 0x105840
jne 0x857e7
movq -0x8(%rbp), %rsi
leaq 0x629ff(%rip), %rdi     # 0xe81dd
movb $0x0, %al
callq 0x4030
jmp 0x85854
movq 0x80052(%rip), %rdi     # 0x105840
movq -0x18(%rbp), %rsi
leaq 0x2e2607(%rip), %rdx    # 0x367e00
callq 0x85390
cmpl $0x0, %eax
jne 0x85805
jmp 0x85854
callq 0x87c40
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movb (%rax), %al
movq 0x80025(%rip), %rdx     # 0x105840
movq 0x2e25de(%rip), %rcx    # 0x367e00
movsbl %al, %esi
callq 0x44c60
movl $0x1, %edi
callq 0x85860
movq 0x2e25c5(%rip), %rdi    # 0x367e00
callq 0x44510
movq $0x0, 0x2e25b5(%rip) # 0x367e00
movq -0x28(%rbp), %rdi
callq 0x4250
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x35c702(%rip)    # 0x3e1f74
je 0x85880
movq 0x7ffc5(%rip), %rdi     # 0x105840
callq 0x1a880
cmpl $0x0, 0x2e25b9(%rip)    # 0x367e40
je 0x858be
cmpl $0x0, -0x4(%rbp)
je 0x858a7
movq 0x35c6e2(%rip), %rdi    # 0x3e1f78
callq 0x52e80
movq 0x35c706(%rip), %rdi    # 0x3e1fa8
callq 0x52e80
cmpl $0x0, 0x35c6c6(%rip)    # 0x3e1f74
jne 0x858bc
movq 0x7ff89(%rip), %rdi     # 0x105840
callq 0x229e0
jmp 0x858be
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x62919(%rip), %rdi     # 0xe81f8
movb $0x0, %al
callq 0x4030
movq 0x7e6fb(%rip), %rax     # 0x103fe8
movq (%rax), %rdx
leaq 0x2e2559(%rip), %rdi    # 0x367e50
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
leaq 0x2e2548(%rip), %rdi    # 0x367e50
callq 0x4150
movq %rax, %rcx
subq $0x1, %rcx
leaq 0x2e2535(%rip), %rax    # 0x367e50
movb $0x0, (%rax,%rcx)
leaq 0x2e252a(%rip), %rdi    # 0x367e50
callq 0x4dcd0
leaq 0x2e251e(%rip), %rdi    # 0x367e50
leaq 0x6869f(%rip), %rsi     # 0xedfd8
callq 0x4230
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x859ec
movq 0x7fba4(%rip), %rdi     # 0x1054f8
movq -0x10(%rbp), %rsi
callq 0x54ba0
movq %rax, 0x7fb94(%rip)     # 0x1054f8
movl $0xffffffff, 0x35c602(%rip) # imm = 0xFFFFFFFF
movl 0x35c5fc(%rip), %eax    # 0x3e1f70
addl $0x1, %eax
movl %eax, 0x35c5f3(%rip)    # 0x3e1f70
xorl %eax, %eax
movl %eax, %edi
leaq 0x68650(%rip), %rsi     # 0xedfd8
callq 0x4230
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x859c8
movslq 0x35c5d1(%rip), %rcx    # 0x3e1f70
leaq 0x7fb5a(%rip), %rax     # 0x105500
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x54ba0
movq %rax, %rdx
movslq 0x35c5b3(%rip), %rcx    # 0x3e1f70
leaq 0x7fb3c(%rip), %rax     # 0x105500
movq %rdx, (%rax,%rcx,8)
jmp 0x859ca
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x859e3
cmpl $0x63, 0x35c593(%rip)   # 0x3e1f70
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x8596e
jmp 0x859ec
cmpl $0x63, 0x35c57d(%rip)   # 0x3e1f70
jl 0x85a03
leaq 0x627ff(%rip), %rdi     # 0xe81fb
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x35c55d(%rip), %eax    # 0x3e1f70
jge 0x85a34
movslq -0x4(%rbp), %rcx
leaq 0x7fae0(%rip), %rax     # 0x105500
movq (%rax,%rcx,8), %rdi
callq 0x4d100
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x85a0a
movslq 0x35c535(%rip), %rcx    # 0x3e1f70
leaq 0x7fabe(%rip), %rax     # 0x105500
movq $0x0, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1fc90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x85390
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x52e80
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x85c60
movl $0x1, 0x35be2a(%rip)    # 0x3e1f74
movl $0x1, 0x2e1cec(%rip)    # 0x367e40
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x17090
movq -0x8(%rbp), %rdi
callq 0x1a880
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x19b30
leaq 0x35bdf8(%rip), %rdi    # 0x3e1f78
leaq -0x40(%rbp), %rsi
movl $0x30, %edx
callq 0x42b0
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1a0a0
leaq 0x35be03(%rip), %rdi    # 0x3e1fa8
leaq -0x70(%rbp), %rsi
movl $0x30, %edx
callq 0x42b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movups 0x35be07(%rip), %xmm0   # 0x3e1fc8
movq %rsp, %rax
movups %xmm0, 0x50(%rax)
movups 0x35bde9(%rip), %xmm0   # 0x3e1fb8
movups %xmm0, 0x40(%rax)
movups 0x35bdce(%rip), %xmm0   # 0x3e1fa8
movups %xmm0, 0x30(%rax)
movups 0x35bdb3(%rip), %xmm0   # 0x3e1f98
movups %xmm0, 0x20(%rax)
movups 0x35bd98(%rip), %xmm0   # 0x3e1f88
movups %xmm0, 0x10(%rax)
movups 0x35bd7d(%rip), %xmm0   # 0x3e1f78
movups %xmm0, (%rax)
callq 0x16db0
movq 0x35bd6e(%rip), %rdi    # 0x3e1f78
callq 0x52e80
movq 0x35bd92(%rip), %rdi    # 0x3e1fa8
callq 0x52e80
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x53bd0
cmpl $0x0, %eax
je 0x862f3
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41c0
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x41c0
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %edx
movl %eax, %ecx
xorl %esi, %esi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x85500
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x862a4
movl $0x0, -0x4(%rbp)
jmp 0x863b5
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41c0
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x41c0
movq -0x58(%rbp), %rdi
movl -0x4c(%rbp), %edx
movl %eax, %ecx
movl $0x1, %esi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x85500
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x862f1
movl $0x0, -0x4(%rbp)
jmp 0x863b5
jmp 0x86303
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq 0x2e1aee(%rip), %rdx    # 0x367e00
callq 0x85390
cmpl $0x0, %eax
jne 0x86328
movl $0x0, -0x4(%rbp)
jmp 0x863b5
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq 0x2e1ad1(%rip), %rdx    # 0x367e08
callq 0x85390
cmpl $0x0, %eax
jne 0x8634a
movl $0x0, -0x4(%rbp)
jmp 0x863b5
cmpq $0x0, -0x28(%rbp)
je 0x86373
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq 0x2e1ab0(%rip), %rdx    # 0x367e10
callq 0x85390
cmpl $0x0, %eax
jne 0x86373
movl $0x0, -0x4(%rbp)
jmp 0x863b5
movq -0x18(%rbp), %rdi
callq 0x53bd0
cmpl $0x0, %eax
je 0x86393
movq -0x30(%rbp), %rdi
callq 0x52e80
movq -0x38(%rbp), %rdi
callq 0x52e80
movq 0x2e1a66(%rip), %rdi    # 0x367e00
callq 0x449f0
movl %eax, %ecx
movq 0x7f498(%rip), %rax     # 0x105840
movl %ecx, 0x1407124(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x7a130, %rsp          # imm = 0x7A130
cmpq $0x0, 0x2e19e5(%rip)    # 0x367e28
je 0x86451
movq 0x2e19dc(%rip), %rdi    # 0x367e28
callq 0x52e80
movq 0x7f3e8(%rip), %rax     # 0x105840
movslq 0x1407120(%rax), %rdi
shlq $0x2, %rdi
leaq 0x61e1b(%rip), %rsi     # 0xe8285
movl $0x9, %edx
callq 0x52d70
movq %rax, 0x2e19ad(%rip)    # 0x367e28
movq 0x7f3be(%rip), %rdi     # 0x105840
callq 0x86540
cmpl $0x0, %eax
jne 0x86491
jmp 0x86528
movq $0x0, -0x7a128(%rbp)
movq 0x7f39d(%rip), %rdi     # 0x105840
leaq -0x7a120(%rbp), %rsi
callq 0x863c0
cmpq $0x0, %rax
je 0x8651c
movq 0x7f384(%rip), %rdi     # 0x105840
leaq -0x7a120(%rbp), %rsi
xorl %edx, %edx
callq 0x22c30
movq %rax, -0x7a130(%rbp)
cmpq $0x0, -0x7a130(%rbp)
jne 0x864dd
jmp 0x8649c
movq -0x7a130(%rbp), %rdi
callq 0x43530
movl %eax, %edx
movq 0x2e1936(%rip), %rax    # 0x367e28
movq -0x7a128(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x7a130(%rbp), %rdi
callq 0x44510
movq -0x7a128(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x7a128(%rbp)
jmp 0x8649c
movq 0x7f31d(%rip), %rdi     # 0x105840
callq 0x865f0
addq $0x7a130, %rsp          # imm = 0x7A130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x140713c(%rax), %edi
movl $0x3, %r8d
xorl %edx, %edx
movl $0x2, %ecx
movl %r8d, %esi
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x865d6
movq -0x10(%rbp), %rdi
callq 0x1fc90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x61c1c(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, 0x35ba42(%rip)    # 0x3e1fd8
cmpq $0x0, %rax
jne 0x865c4
movq -0x18(%rbp), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x61e26(%rip), %rdi     # 0xe83da
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x865e2
movq -0x18(%rbp), %rdi
callq 0x52e80
movl $0x1, -0x4(%rbp)
jmp 0x865e2
movq -0x10(%rbp), %rdi
callq 0x23240
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, 0x2e0d8c(%rip)    # 0x367e40
callq 0x86430
movl -0xc(%rbp), %edi
callq 0x54580
leaq -0x20(%rbp), %rdi
callq 0x87220
movq %rax, -0x18(%rbp)
movq 0x7e753(%rip), %rdi     # 0x105828
movl 0x7e401(%rip), %esi     # 0x1054dc
leaq -0x28(%rbp), %rdx
callq 0x87530
movq -0x28(%rbp), %rdi
movups 0x35aed9(%rip), %xmm0   # 0x3e1fc8
movq %rsp, %rax
movups %xmm0, 0x50(%rax)
movups 0x35aebb(%rip), %xmm0   # 0x3e1fb8
movups %xmm0, 0x40(%rax)
movups 0x35aea0(%rip), %xmm0   # 0x3e1fa8
movups %xmm0, 0x30(%rax)
movups 0x35ae85(%rip), %xmm0   # 0x3e1f98
movups %xmm0, 0x20(%rax)
movups 0x35ae6a(%rip), %xmm0   # 0x3e1f88
movups %xmm0, 0x10(%rax)
movups 0x35ae4f(%rip), %xmm0   # 0x3e1f78
movups %xmm0, (%rax)
callq 0x87600
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %r8
movl $0x2, %esi
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
callq 0x876f0
xorl %edi, %edi
callq 0x85860
movq -0x28(%rbp), %rdi
callq 0x44510
movq 0x7e6ca(%rip), %rdi     # 0x105830
movl 0x7e374(%rip), %esi     # 0x1054e0
leaq -0x28(%rbp), %rdx
callq 0x87530
movq -0x28(%rbp), %rdi
movups 0x35ae48(%rip), %xmm0   # 0x3e1fc8
movq %rsp, %rax
movups %xmm0, 0x50(%rax)
movups 0x35ae2a(%rip), %xmm0   # 0x3e1fb8
movups %xmm0, 0x40(%rax)
movups 0x35ae0f(%rip), %xmm0   # 0x3e1fa8
movups %xmm0, 0x30(%rax)
movups 0x35adf4(%rip), %xmm0   # 0x3e1f98
movups %xmm0, 0x20(%rax)
movups 0x35add9(%rip), %xmm0   # 0x3e1f88
movups %xmm0, 0x10(%rax)
movups 0x35adbe(%rip), %xmm0   # 0x3e1f78
movups %xmm0, (%rax)
callq 0x87600
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %r8
movl $0x3, %esi
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
callq 0x876f0
xorl %edi, %edi
callq 0x85860
movq -0x28(%rbp), %rdi
callq 0x44510
callq 0x8b040
cmpq $0x0, -0x18(%rbp)
je 0x8720e
movq -0x18(%rbp), %rdi
callq 0x52e80
movq -0x20(%rbp), %rdi
callq 0x52e80
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x7e2f6(%rip), %rax     # 0x105840
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
leaq 0x60d13(%rip), %rdi     # 0xe8273
callq 0x79440
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl %eax, %edx
callq 0x22c30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x875f1
movq 0x7e2a1(%rip), %rax     # 0x105840
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
leaq 0x60cb9(%rip), %rdi     # 0xe8273
callq 0x79440
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl %eax, %edx
callq 0x22c30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x87590
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x35a94e(%rip)    # 0x3e1f74
je 0x8767c
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq 0x7e207(%rip), %rcx     # 0x105840
movl 0x1c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x87667
movq 0x7e1f3(%rip), %rax     # 0x105840
movslq -0xc(%rbp), %rcx
movl $0x1, 0x18864(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8762f
movq -0x8(%rbp), %rdi
callq 0x17090
movq 0x7e1c9(%rip), %rdi     # 0x105840
callq 0x1a880
cmpl $0x0, 0x2e07bd(%rip)    # 0x367e40
je 0x876dd
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x50(%rax)
movups %xmm1, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x16db0
cmpl $0x0, 0x35a8a7(%rip)    # 0x3e1f74
jne 0x876db
movq 0x7e16a(%rip), %rdi     # 0x105840
callq 0x22930
jmp 0x876dd
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq 0x7e12c(%rip), %rdi     # 0x105840
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
addl $0x1, %edx
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x85500
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x8773e
jmp 0x8780e
movq -0x38(%rbp), %rdi
leaq 0x60a75(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x8775e
jmp 0x8780e
leaq 0x5c6da(%rip), %rdi     # 0xe3e3f
callq 0x792b0
cmpl $0x5, %eax
jne 0x877df
movq -0x30(%rbp), %rdi
movq 0x7e0c6(%rip), %rsi     # 0x105840
callq 0x24020
movq -0x30(%rbp), %rdi
leaq 0x60b36(%rip), %rsi     # 0xe82c0
movb $0x0, %al
callq 0x4280
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movb (%rax), %al
movq 0x7e09e(%rip), %rdx     # 0x105840
movq -0x20(%rbp), %rcx
movsbl %al, %esi
callq 0x44c60
movq -0x30(%rbp), %rdi
leaq 0x60b0f(%rip), %rsi     # 0xe82c8
movb $0x0, %al
callq 0x4280
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movb (%rax), %al
movq 0x7e06f(%rip), %rdx     # 0x105840
movq -0x28(%rbp), %rcx
movsbl %al, %esi
callq 0x44c60
jmp 0x877fc
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movb (%rax), %al
movq 0x7e050(%rip), %rdx     # 0x105840
movq -0x20(%rbp), %rcx
movsbl %al, %esi
callq 0x44c60
movq -0x30(%rbp), %rdi
callq 0x4250
movq -0x38(%rbp), %rdi
callq 0x52e80
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8afa2
xorps %xmm0, %xmm0
movsd 0x570e7(%rip), %xmm1    # 0xe2018
callq 0x545a0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movsd -0x30(%rbp), %xmm0
callq 0x4fff0
movl %eax, -0x28(%rbp)
movq 0x7a8ea(%rip), %rdi     # 0x105840
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x22c30
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x8af80
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x8af8c
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8af1e
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq 0x7a7e5(%rip), %rdi     # 0x105830
movl 0x7a48f(%rip), %esi     # 0x1054e0
callq 0x52e20
movl $0x0, 0x7a480(%rip)     # 0x1054e0
movq $0x0, 0x7a7c5(%rip) # 0x105830
leaq 0x5d391(%rip), %rdi     # 0xe8403
callq 0x79040
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x8b0a7
movq 0x7a7a1(%rip), %rdi     # 0x105828
movl 0x7a44f(%rip), %esi     # 0x1054dc
callq 0x52e20
movl $0x0, 0x7a440(%rip)     # 0x1054dc
movq $0x0, 0x7a781(%rip) # 0x105828
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x7a120, %rsp          # imm = 0x7A120
movq 0x7a77e(%rip), %rdi     # 0x105840
callq 0x86540
cmpl $0x0, %eax
jne 0x8b0ce
jmp 0x8b124
jmp 0x8b0d0
movq 0x7a769(%rip), %rdi     # 0x105840
leaq -0x7a120(%rbp), %rsi
callq 0x863c0
cmpq $0x0, %rax
je 0x8b118
leaq -0x7a120(%rbp), %rdi
callq 0x532e0
cmpl $0x0, %eax
je 0x8b0fc
jmp 0x8b0d0
leaq -0x7a120(%rbp), %rdx
leaq 0x7a726(%rip), %rdi     # 0x105830
leaq 0x7a3cf(%rip), %rsi     # 0x1054e0
callq 0x8afb0
jmp 0x8b0d0
movq 0x7a721(%rip), %rdi     # 0x105840
callq 0x865f0
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl 0x3480ee(%rip), %edi    # 0x3e1f70
movq -0x10(%rbp), %rdx
movl $0x1, %esi
movb $0x0, %al
callq 0x53f70
cmpl $0x0, %eax
je 0x99f43
movq 0x6b65e(%rip), %rdi     # 0x105500
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x54910
movl %eax, -0x28(%rbp)
cmpl $-0x1, -0x28(%rbp)
je 0x99ec2
movl -0x28(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0x99f41
movq -0x18(%rbp), %rdi
movq 0x6b633(%rip), %rsi     # 0x105500
movb $0x0, %al
callq 0x4030
leaq 0x4d6e3(%rip), %rdi     # 0xe75be
movb $0x0, %al
callq 0x4030
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x99f24
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x4ab94(%rip), %rdi     # 0xe4a98
movb $0x0, %al
callq 0x4030
leaq 0x4be29(%rip), %rdi     # 0xe5d3b
movb $0x0, %al
callq 0x4030
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x99ee9
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x4e6fe(%rip), %rdi     # 0xe8638
movb $0x0, %al
callq 0x4030
jmp 0x99f43
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x6b568(%rip), %eax     # 0x1054d0
jge 0x99f89
movq 0x2cdec7(%rip), %rax    # 0x367e38
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x71010
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x99f5f
movb $0x0, %al
callq 0x1b6c0
movq 0x6b8a1(%rip), %rdi     # 0x105838
movl 0x6b537(%rip), %esi     # 0x1054d4
callq 0x4ad10
movq 0x6b88f(%rip), %rdi     # 0x105838
callq 0x52e80
cmpq $0x0, 0x6b89a(%rip)     # 0x105850
je 0x99fc4
movq 0x6b891(%rip), %rdi     # 0x105850
callq 0x52e80
cmpq $0x0, 0x2cde5c(%rip)    # 0x367e28
je 0x99fda
movq 0x2cde53(%rip), %rdi    # 0x367e28
callq 0x52e80
cmpq $0x0, 0x2cde1e(%rip)    # 0x367e00
je 0x99ffb
movq 0x2cde15(%rip), %rdi    # 0x367e00
callq 0x44510
movq $0x0, 0x2cde05(%rip) # 0x367e00
cmpq $0x0, 0x2cde05(%rip)    # 0x367e08
je 0x9a01c
movq 0x2cddfc(%rip), %rdi    # 0x367e08
callq 0x44510
movq $0x0, 0x2cddec(%rip) # 0x367e08
cmpq $0x0, 0x2cddec(%rip)    # 0x367e10
je 0x9a03d
movq 0x2cdde3(%rip), %rdi    # 0x367e10
callq 0x44510
movq $0x0, 0x2cddd3(%rip) # 0x367e10
movb $0x0, %al
callq 0x13390
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x7a140, %rsp          # imm = 0x7A140
movl %edi, -0x4(%rbp)
leaq 0x49f6f(%rip), %rdi     # 0xe3fe4
callq 0x792b0
movl %eax, %ecx
movl %ecx, -0x7a134(%rbp)
testl %eax, %eax
je 0x9a097
jmp 0x9a088
movl -0x7a134(%rbp), %eax
decl %eax
subl $0x2, %eax
jb 0x9a0b5
jmp 0x9a0d1
leaq -0x7a130(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x6b0d6(%rip), %rax     # 0x105180
movq (%rax,%rcx,8), %rsi
callq 0x4220
jmp 0x9a0d1
leaq -0x7a130(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x6b108(%rip), %rax     # 0x1051d0
movq (%rax,%rcx,8), %rsi
callq 0x4220
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x347e8f(%rip), %eax    # 0x3e1f70
jge 0x9a119
leaq -0x7a130(%rbp), %rdi
leaq -0x7a130(%rbp), %rdx
movslq -0x8(%rbp), %rcx
leaq 0x6b404(%rip), %rax     # 0x105500
movq (%rax,%rcx,8), %rcx
leaq 0x52a0e(%rip), %rsi     # 0xecb15
movb $0x0, %al
callq 0x4170
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x9a0d8
leaq -0x7a130(%rbp), %rdi
callq 0x40d0
addq $0x7a140, %rsp          # imm = 0x7A140
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/pstricks.c
// Function: write_string_pstricks
void write_string_pstricks(FILE* myfile, double posx, double posy, char* st, ALIGN_TYPE align)
{
 switch (align)
  {
   case ALIGN_LEFT         :fprintf(myfile, "\\rput[lb](%f,%f){%s}\n", posx, posy, st);
                            break;
   case ALIGN_ROTATE_LEFT  :fprintf(myfile, "\\rput[lb]{90}(%f,%f){%s}\n", posx, posy, st);
                            break;
   case ALIGN_CENTER       :fprintf(myfile, "\\rput[b](%f,%f){%s}\n", posx, posy, st);
                            break;
   case ALIGN_ROTATE_CENTER:fprintf(myfile, "\\rput[b]{90}(%f,%f){%s}\n", posx, posy, st);
                            break;
   case ALIGN_RIGHT        :fprintf(myfile, "\\rput[rb](%f,%f){%s}\n", posx, posy, st);
                            break;
   case ALIGN_ROTATE_RIGHT :fprintf(myfile, "\\rput[rb]{90}(%f,%f){%s}\n", posx, posy, st);
                            break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x5, %rax
ja 0x9a242
movq -0x30(%rbp), %rax
leaq 0x51317(%rip), %rcx     # 0xeb480
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq -0x20(%rbp), %rdx
leaq 0x513e5(%rip), %rsi     # 0xeb570
movb $0x2, %al
callq 0x4280
jmp 0x9a242
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq -0x20(%rbp), %rdx
leaq 0x513d6(%rip), %rsi     # 0xeb586
movb $0x2, %al
callq 0x4280
jmp 0x9a242
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq -0x20(%rbp), %rdx
leaq 0x513cb(%rip), %rsi     # 0xeb5a0
movb $0x2, %al
callq 0x4280
jmp 0x9a242
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq -0x20(%rbp), %rdx
leaq 0x513be(%rip), %rsi     # 0xeb5b5
movb $0x2, %al
callq 0x4280
jmp 0x9a242
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq -0x20(%rbp), %rdx
leaq 0x513b5(%rip), %rsi     # 0xeb5ce
movb $0x2, %al
callq 0x4280
jmp 0x9a242
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq -0x20(%rbp), %rdx
leaq 0x513a9(%rip), %rsi     # 0xeb5e4
movb $0x2, %al
callq 0x4280
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)