LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/poly.c
// Function: calculate_poly_loglikelihood
double calculate_poly_loglikelihood(double** data, int datasize, Polynomptr p)
{
	/*!Last Changed 26.01.2005*/
 double sum = 0, y, o;
	int i;
	for (i = 0; i < datasize; i++)
	 {
		 y = polynom_value(p, data[i][0]);
			o = sigmoid(y);
			if (data[i][1] == 1 && o != 0)
				 sum += log(o);
			else
				 if (o != 1)
						 sum += log(1 - o);
	 }
 return sum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
testl %esi, %esi
jle 0x5a1c8
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r15d
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq (%rbx), %r13
xorpd %xmm0, %xmm0
testq %r13, %r13
je 0x5a169
movq (%r14,%r12,8), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%r13), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x8(%r13), %edi
movsd 0x10(%rsp), %xmm0
callq 0x38db2
mulsd 0x18(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x5a123
callq 0x54568
movq (%r14,%r12,8), %rax
movsd 0x8(%rax), %xmm1
movsd 0x483a1(%rip), %xmm2    # 0xa2520
ucomisd %xmm2, %xmm1
movapd %xmm2, %xmm1
jne 0x5a197
jp 0x5a197
ucomisd 0x48b75(%rip), %xmm0    # 0xa2d08
jne 0x5a1a7
jp 0x5a1a7
ucomisd %xmm1, %xmm0
jne 0x5a19f
jnp 0x5a1ba
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x4160
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r12
cmpq %r15, %r12
jne 0x5a106
jmp 0x5a1d1
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/poly.c
// Function: calculate_mse
double calculate_mse(double** data, int datasize, Polynomptr p)
{
	/*!Last Changed 21.01.2005*/
 double sum = 0, r, y;
	int i;
	for (i = 0; i < datasize; i++)
	 {
		 y = polynom_value(p, data[i][0]);
			r = data[i][1];
   sum += (r - y) * (r - y);
	 }
 if (datasize == 0)
   return 0;
 return sum / datasize;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
xorpd %xmm1, %xmm1
testl %esi, %esi
jle 0x5a287
movq %rdx, %r14
movq %rdi, %r15
movl %ebx, %r12d
xorl %r13d, %r13d
movsd %xmm1, 0x8(%rsp)
movq (%r14), %rbp
xorpd %xmm1, %xmm1
testq %rbp, %rbp
je 0x5a264
movq (%r15,%r13,8), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd (%rbp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x8(%rbp), %edi
movsd 0x10(%rsp), %xmm0
callq 0x38db2
movsd 0x20(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm0
addsd %xmm0, %xmm1
movq 0x10(%rbp), %rbp
testq %rbp, %rbp
jne 0x5a22c
movq (%r15,%r13,8), %rax
movsd 0x8(%rax), %xmm0
subsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
incq %r13
cmpq %r12, %r13
jne 0x5a20c
testl %ebx, %ebx
xorpd %xmm0, %xmm0
je 0x5a29e
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/poly.c
// Function: calculate_msefile
double calculate_msefile(char* fname, Polynomptr p)
{
	/*!Last Changed 21.01.2005*/
 FILE* infile;
 char line[READLINELENGTH];
 double inp, out, sum = 0, tmp;
 int count = 0;
 infile = fopen(fname, "r");
 if (infile == NULL)
   return +LONG_MAX;
 while (fgets(line, READLINELENGTH, infile))
  {
   sscanf(line, "%lf %lf", &inp, &out);
   tmp = polynom_value(p, inp);
   sum += (tmp - out) * (tmp - out);
   count++;
  }
 fclose(infile);
 if (count == 0)
   return 0;
 return sum / count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a158, %rsp          # imm = 0x7A158
movq %rsi, %r14
leaq 0x4e5c7(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x5a3ab
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
testq %rax, %rax
je 0x5a3b5
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x30(%rsp), %r12
leaq 0x20(%rsp), %rbp
xorl %r15d, %r15d
movq %r12, %rdi
leaq 0x4b5de(%rip), %rsi     # 0xa58f2
leaq 0x28(%rsp), %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x40b0
movq (%r14), %r13
xorpd %xmm1, %xmm1
testq %r13, %r13
je 0x5a375
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd (%r13), %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0x8(%r13), %edi
movsd 0x8(%rsp), %xmm0
callq 0x38db2
movsd 0x18(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm1
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x5a33b
subsd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
incl %r15d
movq %r12, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rbx, %rdx
callq 0x4120
testq %rax, %rax
jne 0x5a30a
jmp 0x5a3c1
movsd 0x48f7d(%rip), %xmm0    # 0xa3330
jmp 0x5a3e7
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x42a0
testl %r15d, %r15d
xorpd %xmm0, %xmm0
je 0x5a3e7
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x7a158, %rsp          # imm = 0x7A158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/poly.c
// Function: polyfit
Polynomptr polyfit(double** data, int datasize, int degree)
{
	/*!Last Changed 21.01.2005*/
 double pow1, pow2;
 int i, j, k;
 matrix A, w, y;
 Polynomptr p;
 A = matrix_alloc(degree + 1, degree + 1);
 y = matrix_alloc(degree + 1, 1);
 for (k = 0; k < datasize; k++)
  {
   pow1 = 1;
   for (i = 0; i < degree + 1; i++)
    {
     pow2 = pow1;
     for (j = 0; j < degree + 1; j++)
      {
       A.values[i][j] += pow2;                              /*fpow(inp[count-1],i+j);*/
       pow2 *= data[k][0];
      }
     y.values[i][0] += data[k][1] * pow1;                  /*out[count-1]*fpow(inp[count-1],i);*/
     pow1 *= data[k][0];
    }
  }
 p = create_polynom();
 matrix_inverse(&A);
 w = matrix_multiply(A,y);
 for (i = 0; i < degree + 1; i++)
   add_polynode_to_polynom(p, i, w.values[i][0]);
 matrix_free(A);
 matrix_free(w);
 matrix_free(y);
 return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r13
leal 0x1(%r12), %ebx
movl %ebx, %edi
movl %ebx, %esi
callq 0x3c6e5
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movl %ebx, %edi
movl $0x1, %esi
callq 0x3c6e5
movq %rax, (%rsp)
movq %rdx, %r15
testl %ebp, %ebp
jle 0x5a4b1
movl %ebp, %eax
xorl %ecx, %ecx
movsd 0x480d6(%rip), %xmm0    # 0xa2520
testl %r12d, %r12d
js 0x5a4a9
movq 0x10(%rsp), %rdx
movq (%r13,%rcx,8), %rsi
xorl %edi, %edi
movapd %xmm0, %xmm1
movq (%rdx,%rdi,8), %r8
xorl %r9d, %r9d
movapd %xmm1, %xmm2
movsd (%r8,%r9,8), %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%r8,%r9,8)
mulsd (%rsi), %xmm2
incq %r9
cmpq %r9, %rbx
jne 0x5a46a
movq (%r15,%rdi,8), %r8
movsd 0x8(%rsi), %xmm2
mulsd %xmm1, %xmm2
addsd (%r8), %xmm2
movsd %xmm2, (%r8)
mulsd (%rsi), %xmm1
incq %rdi
cmpq %rbx, %rdi
jne 0x5a45f
incq %rcx
cmpq %rax, %rcx
jne 0x5a44a
leaq 0x4d88a(%rip), %rsi     # 0xa7d42
movl $0x10, %edi
movl $0x1, %edx
callq 0x390f5
movq %rax, %r13
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3f648
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq (%rsp), %rdx
movq %r15, %rcx
callq 0x3dc8b
movq %rax, %rbp
movq %rdx, %r14
testl %r12d, %r12d
js 0x5a51b
xorl %r12d, %r12d
movq (%r14,%r12,8), %rax
movsd (%rax), %xmm0
movq %r13, %rdi
movl %r12d, %esi
callq 0x5908a
incq %r12
cmpq %r12, %rbx
jne 0x5a500
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3dbad
movq %rbp, %rdi
movq %r14, %rsi
callq 0x3dbad
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x3dbad
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/poly.c
// Function: polyfitfile
Polynomptr polyfitfile(char* fname, int degree, double* error)
{
	/*!Last Changed 22.01.2005 added read_polydata*/
	/*!Last Changed 21.01.2004 rewritten*/
 /*!Last Changed 02.02.2004 added safemalloc*/
 double **data;
 int datacount;
 Polynomptr p;
 data = readpolydata(fname, &datacount);
 p = polyfit(data, datacount, degree);
 (*error) = calculate_msefile(fname, p);
	free_2d((void**)data, datacount);
 return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movq %r15, %rsi
callq 0x58eb0
movq %rax, %r12
movl (%r15), %r15d
movq %rax, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x5a3f9
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x5a2ad
movsd %xmm0, (%rbx)
movq %r12, %rdi
movl %r15d, %esi
callq 0x3915f
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/poly.c
// Function: polyfitclsfile
Polynomptr polyfitclsfile(char* fname, int degree, double* error)
{
	/*!Last Changed 26.01.2005*/
 double **data;
 int datacount;
 Polynomptr p;
 data = readpolydata(fname, &datacount);
 p = polyfitcls(data, datacount, degree);
 (*error) = calculate_poly_clserror(data, datacount, p);
	free_2d((void**)data, datacount);
 return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %ebp
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x58eb0
movq %rax, %r15
movl (%r14), %r14d
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x5a616
movq %rax, %r12
movq %r15, %rdi
movl %r14d, %esi
movq %rax, %rdx
callq 0x59fd1
movsd %xmm0, (%rbx)
movq %r15, %rdi
movl %r14d, %esi
callq 0x3915f
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %edi, %ebp
movq %rsi, %rdi
callq 0x59d2a
movq %rax, %r14
leaq 0x4d4c9(%rip), %r8      # 0xa7d6d
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl $0x2, %ecx
movl $0x4, %r9d
callq 0x393b5
movq %rax, %r15
testl %ebp, %ebp
jle 0x5a97d
movl %ebp, %r13d
xorl %ebp, %ebp
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x39f62
movq (%r14), %r12
xorpd %xmm1, %xmm1
testq %r12, %r12
movsd %xmm0, 0x8(%rsp)
je 0x5a933
movsd %xmm1, (%rsp)
movsd (%r12), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x8(%r12), %edi
movsd 0x8(%rsp), %xmm0
callq 0x38db2
movsd (%rsp), %xmm1
mulsd 0x20(%rsp), %xmm0
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x5a8f3
testl %ebx, %ebx
je 0x5a964
leaq 0x48cbf(%rip), %rdi     # 0xa35fd
movsd %xmm1, (%rsp)
callq 0x534b6
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
callq 0x8cd13
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movq (%r15,%rbp,8), %rax
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
incq %rbp
cmpq %r13, %rbp
jne 0x5a8d0
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movl %edx, %ebp
movq %rsi, %rbx
leaq 0x4def5(%rip), %rsi     # 0xa88a1
callq 0x40f0
testq %rax, %rax
je 0x5aa25
movq %rax, %r14
testl %ebp, %ebp
jle 0x5aa1d
movl %ebp, %ebp
xorl %r12d, %r12d
movq %rsp, %r15
leaq 0x4b79f(%rip), %r13     # 0xa616b
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x39529
movq (%rbx,%r12,8), %rax
movsd (%rax), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
movq %r15, %rdi
leaq 0x4ac96(%rip), %rsi     # 0xa568d
movq %r13, %rdx
callq 0x39529
movq (%rbx,%r12,8), %rax
movsd 0x8(%rax), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
incq %r12
cmpq %r12, %rbp
jne 0x5a9cc
movq %r14, %rdi
callq 0x42a0
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x5bff1
leaq 0x8(%rsp), %rax
movq (%rax), %rax
movsd 0x46d89(%rip), %xmm0    # 0xa2cf0
movq 0x76902(%rip), %rsi     # 0xd2870
cmpl $0x0, 0x1bc(%rsi)
jle 0x5bfe4
movl $0x61e1, %ecx           # imm = 0x61E1
xorl %edx, %edx
movl (%rsi,%rcx,8), %esi
cmpl $0x2, %esi
je 0x5bfb0
cmpl $0x1, %esi
je 0x5bf9d
testl %esi, %esi
jne 0x5bfca
movq (%rdi), %rsi
cmpl $0x75bcd15, (%rsi,%rdx,8) # imm = 0x75BCD15
je 0x5bfa6
jmp 0x5bfca
movq (%rdi), %rsi
cmpl $-0x1, (%rsi,%rdx,8)
jne 0x5bfca
movl (%rax,%rdx,8), %r8d
movl %r8d, (%rsi,%rdx,8)
jmp 0x5bfca
movq (%rdi), %rsi
movsd (%rsi,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x5bfca
jp 0x5bfca
movsd (%rax,%rdx,8), %xmm1
movsd %xmm1, (%rsi,%rdx,8)
incq %rdx
movq 0x7689c(%rip), %rsi     # 0xd2870
movslq 0x1bc(%rsi), %r8
addq $0x68, %rcx
cmpq %r8, %rdx
jl 0x5bf7e
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0x5bf67
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/process.c
// Function: divide_data_file
void divide_data_file(char* datasetname, char* separator, char* infilename, int partcount)
{
 /*!Last Changed 23.02.2007 added minimum partcount and check for datasetname*/
 /*!Last Changed 03.08.2006*/
 FILE* outfile;
 char* exportfname;
 int i;
 Instanceptr* parts;
 if (partcount < 2)
  {
   printf(m1367);
   return;
  }
 current_dataset = search_dataset(Datasets, datasetname);
 if (!current_dataset)
  {
   printf(m1279, datasetname);
   return;
  }
 if (!read_from_data_file(current_dataset, infilename, &traindata)) 
   return;
 parts = divide_instancelist_into_parts(&traindata, partcount);
 for (i = 0; i < partcount; i++)
  { 
   exportfname = export_file_name(current_dataset, 4, -1, -1, i + 1);
   outfile = fopen(exportfname, "w");
   print_instance_list(outfile, *separator, current_dataset, parts[i]);
   fclose(outfile);
  }
 traindata = NULL;
 for (i = 0; i < partcount; i++)
   deallocate(parts[i]);
 safe_free(parts);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x1, %ecx
jg 0x5c01c
leaq 0x4f65c(%rip), %rdi     # 0xab665
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq 0x7684a(%rip), %rdi     # 0xd2878
movq %r12, %rsi
callq 0x14f16
movq %rax, 0x76833(%rip)     # 0xd2870
testq %rax, %rax
je 0x5c119
leaq 0x2d8de3(%rip), %rdx    # 0x334e30
movq %rax, %rdi
movq %r15, %rsi
callq 0x5c147
testl %eax, %eax
je 0x5c138
leaq 0x2d8dc9(%rip), %rdi    # 0x334e30
movl %ebx, %esi
callq 0x30510
movq %rax, %r15
movl %ebx, 0x4(%rsp)
movl %ebx, %ebx
xorl %r13d, %r13d
movq 0x767ef(%rip), %rdi     # 0xd2870
leaq 0x1(%r13), %r12
movl $0x4, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %r12d, %r8d
callq 0x5c226
movq %rax, %rdi
leaq 0x4c7fb(%rip), %rsi     # 0xa88a1
callq 0x40f0
movq %rax, %rbp
movsbl (%r14), %esi
movq 0x767b7(%rip), %rdx     # 0xd2870
movq (%r15,%r13,8), %rcx
movq %rax, %rdi
callq 0x2fbad
movq %rbp, %rdi
callq 0x42a0
movq %r12, %r13
cmpq %r12, %rbx
jne 0x5c07a
movq $0x0, 0x2d8d50(%rip) # 0x334e30
movl 0x4(%rsp), %eax
cmpl $0x2, %eax
movl $0x1, %ebx
cmovgel %eax, %ebx
xorl %r14d, %r14d
movq (%r15,%r14,8), %rdi
callq 0x2f616
incq %r14
cmpq %r14, %rbx
jne 0x5c0f2
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39194
leaq 0x4c783(%rip), %rdi     # 0xa88a3
movq %r12, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4030
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/process.c
// Function: read_from_data_file
int read_from_data_file(Datasetptr dataset, char* datafilename, Instanceptr* whereto)
{
 /*!Last Changed 31.10.2005*/
 FILE *myfile;
 char myline[READLINELENGTH];
 int j = 0;
 Instanceptr currentinstance, instancebefore = NULL;
 myfile = fopen(datafilename, "r");
 if (!myfile)
  {
   printf(m1121, datafilename);
   return FAILURE;
  }
 while (fgets(myline, READLINELENGTH, myfile))
  {
   currentinstance = create_instance(dataset, myline, get_parameter_o("runwithclassnoise"));
   if (!currentinstance)
     continue;
   if (instancebefore)
     instancebefore->next = currentinstance;
   else
     *whereto = currentinstance;
   currentinstance->index = j;
   j++;
   instancebefore = currentinstance;
  }
 fclose(myfile);
 if (convert_missing_values)
   handle_missing_values(*whereto, *whereto);
 return SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %r14
leaq 0x4c725(%rip), %rsi     # 0xa888f
movq %r12, %rdi
callq 0x40f0
testq %rax, %rax
je 0x5c1ff
movq %rax, %r15
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
leaq 0x4c767(%rip), %r13     # 0xa88f3
xorl %ebp, %ebp
movq %r12, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r15, %rdx
callq 0x4120
testq %rax, %rax
je 0x5c1d7
movq %r13, %rdi
callq 0x536e7
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x1847e
testq %rax, %rax
je 0x5c18e
leaq 0x10(%rbx), %rcx
testq %rbx, %rbx
cmoveq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movl %ebp, 0x18(%rax)
incl %ebp
movq %rax, %rbx
jmp 0x5c18e
movq %r15, %rdi
callq 0x42a0
movl $0x1, %ebp
cmpl $0x0, 0x760c1(%rip)     # 0xd22ac
je 0x5c212
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq %rdi, %rsi
callq 0x5bf00
jmp 0x5c212
leaq 0x47d17(%rip), %rdi     # 0xa3f1d
xorl %ebp, %ebp
movq %r12, %rsi
xorl %eax, %eax
callq 0x4030
movl %ebp, %eax
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/process.c
// Function: export_data_file
void export_data_file(char* datasetname, char* separator, char* infilename, char* outfilename)
{
 /*!Last Changed 21.10.2005 added read_from_data_file*/
 /*!Last Changed 29.09.2004*/
 /*!Last Changed 28.10.2003*/
 FILE* outfile;
 mustnormalize = NO;
 outfile = fopen(outfilename, "w");
 if (!outfile)
   return;
 current_dataset = search_dataset(Datasets, datasetname);
 if (!current_dataset)
  {
   printf(m1279, datasetname);
   return;
  }
 if (!read_from_data_file(current_dataset, infilename, &traindata)) 
   return;
 pre_process();
 print_instance_list(outfile, *separator, current_dataset, traindata);
 post_process(YES);
 deallocate(traindata);
 traindata = NULL;
 fclose(outfile);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movl $0x0, 0x2d8a9c(%rip)    # 0x334e70
leaq 0x4c4c6(%rip), %rsi     # 0xa88a1
movq %rcx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x5c473
movq %rax, %rbx
movq 0x76482(%rip), %rdi     # 0xd2878
movq %r12, %rsi
callq 0x14f16
movq %rax, 0x7646b(%rip)     # 0xd2870
testq %rax, %rax
je 0x5c47f
leaq 0x2d8a1f(%rip), %rdx    # 0x334e30
movq %rax, %rdi
movq %r15, %rsi
callq 0x5c147
testl %eax, %eax
je 0x5c473
callq 0x5e071
movsbl (%r14), %esi
movq 0x76440(%rip), %rdx     # 0xd2870
movq 0x2d89f9(%rip), %rcx    # 0x334e30
movq %rbx, %rdi
callq 0x2fbad
movl $0x1, %edi
callq 0x5c49b
movq 0x2d89e0(%rip), %rdi    # 0x334e30
callq 0x2f616
movq $0x0, 0x2d89d0(%rip) # 0x334e30
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x42a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4c41d(%rip), %rdi     # 0xa88a3
movq %r12, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4030
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/process.c
// Function: post_process
void post_process(int free_values)
{
 /*!Last Changed 31.10.2005 added type_restore*/
 /*!Last Changed 11.08.2005*/
 if (mustrealize)
   exchange_classdefno(current_dataset);
 if (mustnormalize)
  {
   if (free_values)
    {
     safe_free(mean.values);
     safe_free(variance.values);
    }
   if (!mustrealize)
     type_restore(current_dataset);
  }
}

// Assembly:
pushq %rbx
movl %edi, %ebx
cmpl $0x0, 0x352aff(%rip)    # 0x3aefa4
je 0x5c4b3
movq 0x763c2(%rip), %rdi     # 0xd2870
callq 0x12cfc
cmpl $0x0, 0x2d89b6(%rip)    # 0x334e70
je 0x5c4e1
testl %ebx, %ebx
je 0x5c4d8
movq 0x352ae1(%rip), %rdi    # 0x3aefa8
callq 0x39194
movq 0x352b05(%rip), %rdi    # 0x3aefd8
callq 0x39194
cmpl $0x0, 0x352ac5(%rip)    # 0x3aefa4
je 0x5c4e3
popq %rbx
retq
movq 0x76386(%rip), %rdi     # 0xd2870
popq %rbx
jmp 0x1826b
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
leaq 0x4c3c2(%rip), %rdi     # 0xa88be
xorl %eax, %eax
callq 0x4030
movq 0x74ac6(%rip), %rax     # 0xd0fd0
movq (%rax), %rdx
leaq 0x2d896c(%rip), %rbx    # 0x334e80
movq %rbx, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x4120
movq %rbx, %rdi
callq 0x4190
movb $0x0, -0x1(%rax,%rbx)
movq %rbx, %rdi
callq 0x35a99
leaq 0x523ef(%rip), %rsi     # 0xae92c
movq %rbx, %rdi
callq 0x4280
testq %rax, %rax
je 0x5c5bc
movq 0x75fd7(%rip), %rdi     # 0xd2528
movq %rax, %rsi
callq 0x3a404
movq %rax, 0x75fc8(%rip)     # 0xd2528
movl $0xffffffff, 0x352a36(%rip) # imm = 0xFFFFFFFF
leaq 0x523bb(%rip), %rbx     # 0xae92c
leaq 0x75fb8(%rip), %r15     # 0xd2530
incl 0x352a22(%rip)          # 0x3aefa0
xorl %edi, %edi
movq %rbx, %rsi
callq 0x4280
movq %rax, %r14
testq %rax, %rax
je 0x5c5ae
movslq 0x352a09(%rip), %rax    # 0x3aefa0
movq (%r15,%rax,8), %rdi
movq %r14, %rsi
callq 0x3a404
movslq 0x3529f6(%rip), %rcx    # 0x3aefa0
movq %rax, (%r15,%rcx,8)
testq %r14, %r14
je 0x5c5bc
cmpl $0x63, 0x3529e6(%rip)   # 0x3aefa0
jl 0x5c578
cmpl $0x63, 0x3529dd(%rip)   # 0x3aefa0
jl 0x5c5d1
leaq 0x4f0b5(%rip), %rdi     # 0xab681
callq 0x4090
movl 0x3529c9(%rip), %eax    # 0x3aefa0
testl %eax, %eax
jle 0x5c600
leaq 0x75f4e(%rip), %rbx     # 0xd2530
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0x3534b
incq %r14
movslq 0x3529a9(%rip), %rax    # 0x3aefa0
addq $0x8, %rbx
cmpq %rax, %r14
jl 0x5c5e5
cltq
leaq 0x75f27(%rip), %rcx     # 0xd2530
movq $0x0, (%rcx,%rax,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq 0x76249(%rip), %rdi     # 0xd2878
movq %r14, %rsi
callq 0x14f16
testq %rax, %rax
je 0x5c77c
movq %rax, %rbx
movq %rax, 0x76226(%rip)     # 0xd2870
movq 0x2d87df(%rip), %rdi    # 0x334e30
testq %rdi, %rdi
je 0x5c666
callq 0x2f616
movq $0x0, 0x2d87ca(%rip) # 0x334e30
leaq 0x2d87c3(%rip), %rsi    # 0x334e30
movq %rbx, %rdi
callq 0x5c7af
movq 0x2d87b4(%rip), %rsi    # 0x334e30
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1286d
movq (%r14), %r14
cmpl $0x0, 0x1bc(%rbx)
jle 0x5c794
movq %rbx, %r13
addq $0x30f08, %r13          # imm = 0x30F08
leaq 0x8(%rsp), %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
imulq $0x340, %r12, %rax      # imm = 0x340
movl (%r13,%rax), %edi
movl $0x2, %esi
movl $0x2, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0x5c767
movq 0x2d8755(%rip), %rdi    # 0x334e30
movl %r12d, %esi
movq %r15, %rdx
callq 0x9d053
xorps %xmm0, %xmm0
cvtsi2sdl 0x8(%rsp), %xmm0
movapd %xmm0, %xmm1
mulsd 0x4b6e5(%rip), %xmm1    # 0xa7de0
cvttsd2si %xmm1, %edx
mulsd 0x4a771(%rip), %xmm0    # 0xa6e78
cvttsd2si %xmm0, %ecx
xorpd %xmm0, %xmm0
subl %edx, %ecx
jl 0x5c735
movslq %edx, %rdx
leaq (%rdx,%rdx,2), %rdx
shlq $0x4, %rdx
addq %rax, %rdx
leal 0x1(%rcx), %esi
movq (%rdx), %rdi
addsd (%rdi,%r12,8), %xmm0
addq $0x30, %rdx
decl %esi
jne 0x5c724
incl %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
movsd (%r14,%r12,8), %xmm1
divsd %xmm0, %xmm1
xorl %ecx, %ecx
movsd 0x4b692(%rip), %xmm0    # 0xa7de8
ucomisd %xmm1, %xmm0
seta %cl
addl %ecx, %ebp
movq %rax, %rdi
callq 0x39194
incq %r12
movslq 0x1bc(%rbx), %rax
cmpq %rax, %r12
jl 0x5c6ad
jmp 0x5c796
leaq 0x4c120(%rip), %rdi     # 0xa88a3
movq %r14, %rsi
xorl %eax, %eax
callq 0x4030
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x5c79e
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x39194
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_O1/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 0x16285
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x5c147
movl %eax, %ebx
movq %r15, %rdi
callq 0x39194
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5c7af
movl $0x1, %eax
movl %eax, 0x352429(%rip)    # 0x3aefa4
movl %eax, 0x2d82ef(%rip)    # 0x334e70
movq (%rbx), %rdi
callq 0x10964
movq %r14, %rdi
callq 0x12cfc
movq (%rbx), %rsi
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x12519
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x352412(%rip)   # 0x3aefc8
movups %xmm1, 0x3523fb(%rip)   # 0x3aefb8
movups %xmm0, 0x3523e4(%rip)   # 0x3aefa8
movq (%rbx), %rsi
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x1286d
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x35240f(%rip)   # 0x3aeff8
movups %xmm1, 0x3523f8(%rip)   # 0x3aefe8
movups %xmm0, 0x3523e1(%rip)   # 0x3aefd8
movq (%rbx), %rdi
movups 0x3523f7(%rip), %xmm0   # 0x3aeff8
movups %xmm0, 0x50(%rsp)
movups 0x3523db(%rip), %xmm0   # 0x3aefe8
movups %xmm0, 0x40(%rsp)
movups 0x3523bf(%rip), %xmm0   # 0x3aefd8
movups %xmm0, 0x30(%rsp)
movups 0x3523a3(%rip), %xmm0   # 0x3aefc8
movups %xmm0, 0x20(%rsp)
movups 0x352387(%rip), %xmm0   # 0x3aefb8
movups %xmm0, 0x10(%rsp)
movups 0x35236b(%rip), %xmm0   # 0x3aefa8
movups %xmm0, (%rsp)
callq 0x107bc
movq 0x35235b(%rip), %rdi    # 0x3aefa8
callq 0x39194
movq 0x35237f(%rip), %rdi    # 0x3aefd8
callq 0x39194
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3992c
testl %eax, %eax
je 0x5cd09
movq %r14, %rdi
callq 0x4200
movl %eax, %r13d
movq %rbx, %rdi
callq 0x4200
xorl %ebp, %ebp
movq %r12, %rdi
xorl %esi, %esi
movl %r13d, %edx
movl %eax, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x5c226
testq %rax, %rax
je 0x5cd8f
movq %rax, %r13
movq %r14, %rdi
callq 0x4200
movq %r13, (%rsp)
movq %r15, %r13
movl %eax, %r15d
movq %rbx, %rdi
callq 0x4200
movq %r12, %rdi
movl $0x1, %esi
movl %r15d, %edx
movq %r13, %r15
movq (%rsp), %r13
movl %eax, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x5c226
testq %rax, %rax
je 0x5cd8f
movq %rax, %rbx
jmp 0x5cd0c
movq %r14, %r13
leaq 0x2d811d(%rip), %rdx    # 0x334e30
movq %r12, %rdi
movq %r13, %rsi
callq 0x5c147
xorl %ebp, %ebp
testl %eax, %eax
je 0x5cd8f
leaq 0x2d810d(%rip), %rdx    # 0x334e38
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5c147
testl %eax, %eax
je 0x5cd8f
testq %r15, %r15
je 0x5cd55
leaq 0x2d80fa(%rip), %rdx    # 0x334e40
movq %r12, %rdi
movq %r15, %rsi
callq 0x5c147
testl %eax, %eax
je 0x5cd8f
movq %r14, %rdi
callq 0x3992c
testl %eax, %eax
je 0x5cd71
movq %r13, %rdi
callq 0x39194
movq %rbx, %rdi
callq 0x39194
movq 0x2d80b8(%rip), %rdi    # 0x334e30
callq 0x2fa14
movq 0x75aec(%rip), %rcx     # 0xd2870
movl %eax, 0x1407124(%rcx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d805e(%rip), %rdi    # 0x334e58
testq %rdi, %rdi
je 0x5ce04
callq 0x39194
movq 0x75a65(%rip), %rax     # 0xd2870
movslq 0x1407120(%rax), %rdi
shlq $0x2, %rdi
leaq 0x4bae8(%rip), %rsi     # 0xa8905
movl $0x9, %edx
callq 0x390f5
movq %rax, 0x2d802a(%rip)    # 0x334e58
movq 0x75a3b(%rip), %rdi     # 0xd2870
callq 0x5ce9c
testl %eax, %eax
je 0x5ce8f
xorl %r15d, %r15d
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x5cda0
movq 0x75a1d(%rip), %rdi     # 0xd2870
testq %rax, %rax
je 0x5ce8a
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1847e
testq %rax, %rax
je 0x5ce44
movq %rax, %r14
movq %rax, %rdi
callq 0x2eaca
movq 0x2d7fdf(%rip), %rcx    # 0x334e58
movl %eax, (%rcx,%r15,4)
movq %r14, %rdi
callq 0x2f616
incq %r15
jmp 0x5ce44
callq 0x5cf32
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/process.c
// Function: open_dataset
int open_dataset(Datasetptr dataset)
{
 /*!Last Changed 07.04.2007 added STORE_TIME*/
 /*!Last Changed 29.12.2005*/
 char* datafilename;
 if (in_list(dataset->storetype, 3, STORE_TEXT, STORE_SEQUENTIAL, STORE_KERNEL))
  {
   datafilename = dataset_file_name(dataset);
   if ((datafile = fopen(datafilename, "r")) == NULL)
    {
     safe_free(datafilename);
     printf(m1271, dataset->name);
     return FAILURE;
    }
   else
    {
     safe_free(datafilename);
     return SUCCESS;
    }
  }
 else
   return connect_to_database(dataset);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x140713c(%rdi), %edi
movl $0x3, %esi
xorl %edx, %edx
movl $0x2, %ecx
movl $0x3, %r8d
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0x5cf20
movq %rbx, %rdi
callq 0x16285
movq %rax, %r14
leaq 0x4b9b4(%rip), %rsi     # 0xa888f
movq %rax, %rdi
callq 0x40f0
movq %rax, %r15
movq %rax, 0x35211b(%rip)    # 0x3af008
movq %r14, %rdi
callq 0x39194
movl $0x1, %ebp
testq %r15, %r15
jne 0x5cf13
movq 0x8(%rbx), %rsi
leaq 0x4bb50(%rip), %rdi     # 0xa8a5a
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x4030
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x188d6
// File: /workspace/github_c_makefile_star2_O1/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 0x758ef(%rip), %rax     # 0xd2870
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
leaq 0x4b98b(%rip), %rsi     # 0xa891b
movl $0x2, %edx
callq 0x390f5
movq %rax, %r14
movq 0x758cc(%rip), %rax     # 0xd2870
cmpl $0x0, 0x10(%rax)
jle 0x5cfc0
xorl %ecx, %ecx
movl (%r15,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
movslq 0x10(%rax), %rdx
cmpq %rdx, %rcx
jl 0x5cfac
cmpl $0x0, 0x75549(%rip)     # 0xd2510
jle 0x5d039
leaq 0x2d7e60(%rip), %r12    # 0x334e30
xorl %r15d, %r15d
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x39f18
cltd
idivl 0x7552c(%rip)           # 0xd2510
movslq %edx, %rax
movslq (%rbx,%rax,4), %rcx
movl (%r14,%rcx,4), %edx
testl %edx, %edx
je 0x5cfd6
decl %edx
movl %edx, (%r14,%rcx,4)
movq 0x75870(%rip), %rdi     # 0xd2870
movq 0x75859(%rip), %rcx     # 0xd2860
movq (%rcx,%rax,8), %rsi
xorl %edx, %edx
callq 0x1847e
addq $0x10, %r13
testq %r15, %r15
cmoveq %r12, %r13
movq %rax, (%r13)
movl %r15d, 0x18(%rax)
incq %r15
movslq 0x754e1(%rip), %rcx     # 0xd2510
movq %rax, %r13
cmpq %rcx, %r15
jl 0x5cfd6
jmp 0x5d03c
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x39194
movq 0x75825(%rip), %rax     # 0xd2870
movl %r15d, 0x1407124(%rax)
cmpl $0x0, 0x75253(%rip)     # 0xd22ac
je 0x5d073
movq 0x2d7dce(%rip), %rdi    # 0x334e30
movq %rdi, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5bf00
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4b855(%rip), %r14     # 0xa88f3
xorl %ebx, %ebx
xorl %ebp, %ebp
movq $0x0, 0x8(%rsp)
movslq 0x7545e(%rip), %rax     # 0xd2510
cmpq %rax, %rbx
jge 0x5d15b
movq 0x757ae(%rip), %r12     # 0xd2870
movq 0x75797(%rip), %rax     # 0xd2860
movq (%rax,%rbx,8), %r13
movq %r14, %rdi
callq 0x536e7
movq %r12, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x1847e
testq %rax, %rax
je 0x5d0ab
movq %rax, %r12
movq 0x10(%rsp), %rax
movl (%rax,%rbx,4), %r13d
leaq 0x4ea22(%rip), %rdi     # 0xabb1c
callq 0x5341c
movl %eax, %ecx
movl %r13d, %eax
cltd
idivl %ecx
cmpl 0x4(%rsp), %edx
jne 0x5d133
movq 0x8(%rsp), %rcx
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
leaq 0x2d7d18(%rip), %rcx    # 0x334e38
cmoveq %rcx, %rax
movq %r12, (%rax)
movl %ebx, 0x18(%r12)
movq %r12, 0x8(%rsp)
jmp 0x5d153
leaq 0x10(%rbp), %rax
testq %rbp, %rbp
leaq 0x2d7cef(%rip), %rcx    # 0x334e30
cmoveq %rcx, %rax
movq %r12, (%rax)
movl %r15d, 0x18(%r12)
incq %r15
movq %r12, %rbp
incq %rbx
jmp 0x5d0ab
movq 0x7570e(%rip), %rax     # 0xd2870
movl %r15d, 0x1407124(%rax)
cmpl $0x0, 0x7513c(%rip)     # 0xd22ac
je 0x5d1a2
movq 0x2d7cb7(%rip), %rdi    # 0x334e30
movq %rdi, %rsi
callq 0x5bf00
movq 0x2d7ca8(%rip), %rdi    # 0x334e30
movq 0x2d7ca9(%rip), %rsi    # 0x334e38
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5bf00
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/process.c
// Function: export_valdata
void export_valdata(char* separator, int newseed)
{
 /*!Last Changed 13.02.2008 added regression for validation data export*/
 /*!Last Changed 21.04.2007 added export_single_file*/
 /*!Last Changed 24.11.2005*/
 /*!Last Changed 30.10.2005*/
 int *classes, *classcounts = NULL;
 Instanceptr exportdata;
 mustnormalize = NO;
 get_prior_information();
 mysrand(newseed);
 classes = read_train_and_test_lines(&classcounts);
 read_data_from_lines(testlines, testlinecount, &exportdata);
 pre_process_with_mean_and_variance(mean, variance, exportdata);
 export_single_file(separator, 2, -2, -2, exportdata, NULL);
 post_process(NO);
 deallocate(exportdata);
 read_data_from_lines(trainlines, trainlinecount, &exportdata);
 pre_process_with_mean_and_variance(mean, variance, exportdata);
 export_single_file(separator, 3, -2, -2, exportdata, NULL);
 post_process(NO);
 deallocate(exportdata);
 free_train_and_test_lines();
 if (classes)
  {
   safe_free(classes);
   safe_free(classcounts);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x68(%rsp), %r15
movq $0x0, (%r15)
movl $0x0, 0x2d7766(%rip)    # 0x334e70
callq 0x5cde7
movl %ebx, %edi
callq 0x39f5b
movq %r15, %rdi
callq 0x5d87f
movq %rax, %rbx
movq 0x75130(%rip), %rdi     # 0xd2858
movl 0x74dde(%rip), %esi     # 0xd250c
leaq 0x70(%rsp), %r15
movq %r15, %rdx
callq 0x5dad7
movq (%r15), %r12
movups 0x3518b3(%rip), %xmm0   # 0x3aeff8
movups %xmm0, 0x50(%rsp)
movups 0x351897(%rip), %xmm0   # 0x3aefe8
movups %xmm0, 0x40(%rsp)
movups 0x35187b(%rip), %xmm0   # 0x3aefd8
movups %xmm0, 0x30(%rsp)
movups 0x35185f(%rip), %xmm0   # 0x3aefc8
movups %xmm0, 0x20(%rsp)
movups 0x351843(%rip), %xmm0   # 0x3aefb8
movups %xmm0, 0x10(%rsp)
movups 0x351827(%rip), %xmm0   # 0x3aefa8
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x5db62
movq %r14, %rdi
movl $0x2, %esi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
movq %r12, %r8
xorl %r9d, %r9d
callq 0x5dc27
xorl %edi, %edi
callq 0x5c49b
movq %r12, %rdi
callq 0x2f616
movq 0x750a0(%rip), %rdi     # 0xd2860
movl 0x74d4a(%rip), %esi     # 0xd2510
movq %r15, %rdx
callq 0x5dad7
movq (%r15), %r15
movups 0x351820(%rip), %xmm0   # 0x3aeff8
movups %xmm0, 0x50(%rsp)
movups 0x351804(%rip), %xmm0   # 0x3aefe8
movups %xmm0, 0x40(%rsp)
movups 0x3517e8(%rip), %xmm0   # 0x3aefd8
movups %xmm0, 0x30(%rsp)
movups 0x3517cc(%rip), %xmm0   # 0x3aefc8
movups %xmm0, 0x20(%rsp)
movups 0x3517b0(%rip), %xmm0   # 0x3aefb8
movups %xmm0, 0x10(%rsp)
movups 0x351794(%rip), %xmm0   # 0x3aefa8
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x5db62
movq %r14, %rdi
movl $0x3, %esi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
movq %r15, %r8
xorl %r9d, %r9d
callq 0x5dc27
xorl %edi, %edi
callq 0x5c49b
movq %r15, %rdi
callq 0x2f616
callq 0x60317
testq %rbx, %rbx
je 0x5d873
movq %rbx, %rdi
callq 0x39194
movq 0x68(%rsp), %rdi
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x39194
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/process.c
// Function: read_data_from_lines
void read_data_from_lines(char** lines, int linecount, Instanceptr* data)
{
 /*!Last Changed 30.10.2005*/
 int i;
 Instanceptr currentinstance, before;
 *data = create_instance(current_dataset, lines[0], get_parameter_o("runwithclassnoise"));
 before = *data;
 for (i = 1; i < linecount; i++)
  {
   currentinstance = create_instance(current_dataset, lines[i], get_parameter_o("runwithclassnoise"));
   before->next = currentinstance;
   before = currentinstance;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq 0x74d7f(%rip), %r14     # 0xd2870
movq (%rdi), %r12
leaq 0x4adf8(%rip), %rdi     # 0xa88f3
callq 0x536e7
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x1847e
movq %rax, (%r15)
cmpl $0x2, %ebp
jl 0x5db53
movq %rax, %r14
movl %ebp, %ebp
movl $0x1, %r15d
movq 0x74d49(%rip), %r12     # 0xd2870
movq (%rbx,%r15,8), %r13
leaq 0x4adc1(%rip), %rdi     # 0xa88f3
callq 0x536e7
movq %r12, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x1847e
movq %rax, 0x10(%r14)
incq %r15
movq %rax, %r14
cmpq %r15, %rbp
jne 0x5db20
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x351433(%rip)    # 0x3aefa4
je 0x5dbb6
movq 0x74cf6(%rip), %rax     # 0xd2870
cmpl $0x2, 0x1c0(%rax)
jl 0x5dba2
xorl %ecx, %ecx
movl $0x1, 0x18864(%rax,%rcx,4)
incq %rcx
movslq 0x1c0(%rax), %rdx
decq %rdx
cmpq %rdx, %rcx
jl 0x5db85
movq %rbx, %rdi
callq 0x10964
movq 0x74cbf(%rip), %rdi     # 0xd2870
callq 0x12cfc
cmpl $0x0, 0x2d72b3(%rip)    # 0x334e70
je 0x5dc10
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 0x107bc
cmpl $0x0, 0x351396(%rip)    # 0x3aefa4
je 0x5dc16
addq $0x60, %rsp
popq %rbx
retq
movq 0x74c53(%rip), %rdi     # 0xd2870
addq $0x60, %rsp
popq %rbx
jmp 0x1822c