LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/plot.c
// Function: box_plot
void box_plot(char** names, int filecount)
{
 /*!Last Changed 20.09.2006*/
 /*!Last Changed 11.07.2005*/
 int count, i;
 Point p1, p2, p3;
 char* plotname, st2[3];
 plotname = file_only_name(names[0]); 
 if (!get_parameter_o("hold"))
   clear_image();
 for (i = 0; i < filecount; i++)
  {
   p1.x = file_percentile(names[i], 50);
   p1.y = file_percentile(names[i], 25);
   p2.x = file_percentile(names[i], 75);
   p2.y = i;
   file_whiskers(names[i], p1.y, p2.x, &(p3.x), &(p3.y));
   sprintf(st2, "%d", img.xaxis.namesavailable);
   add_object(OBJECT_BOXPLOT, p1, p2, p3, st2);
  }
 img.xaxis.namesavailable++;
 count = img.xaxis.namesavailable;
 img.xaxis.names = alloc(img.xaxis.names, count * sizeof(char *), count); 
 img.xaxis.names[count - 1] = strcopy(img.xaxis.names[count - 1], plotname);
 safe_free(plotname);
 img.xaxis.limitsset = 1;
 img.xaxis.lim.division = img.xaxis.namesavailable;
 img.xaxis.lim.min = 0;
 img.xaxis.lim.max = img.xaxis.namesavailable;
 img.xaxis.lim.precision = 0;
 export_image();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x38b30
movq %rax, 0x18(%rsp)
leaq 0x51311(%rip), %rdi     # 0xaa7b5
callq 0x54bec
testl %eax, %eax
jne 0x594b4
xorl %eax, %eax
callq 0x2e342
testl %ebp, %ebp
jle 0x59591
movl %ebp, %ebx
leaq 0x358bf3(%rip), %r15    # 0x3b20b8
leaq 0x57729(%rip), %r13     # 0xb0bf5
leaq 0x15(%rsp), %rbp
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
movsd 0x51788(%rip), %xmm0    # 0xaac68
callq 0x8f08c
movsd %xmm0, 0x30(%rsp)
movq (%r14,%r12,8), %rdi
movsd 0x51779(%rip), %xmm0    # 0xaac70
callq 0x8f08c
movsd %xmm0, 0x8(%rsp)
movq (%r14,%r12,8), %rdi
movsd 0x5176a(%rip), %xmm0    # 0xaac78
callq 0x8f08c
movaps %xmm0, %xmm1
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
movsd %xmm0, 0x28(%rsp)
movq (%r14,%r12,8), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x38(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x8ef0e
movl 0x38(%r15), %edx
movq %rbp, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x41b0
movsd 0x38(%rsp), %xmm4
movsd 0x40(%rsp), %xmm5
movl $0x4, %edi
movsd 0x30(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x28(%rsp), %xmm3
movq %rbp, %rsi
callq 0x2cc6c
incq %r12
cmpq %r12, %rbx
jne 0x594d4
leaq 0x358b20(%rip), %rbx    # 0x3b20b8
movslq 0x38(%rbx), %r14
leaq 0x1(%r14), %rdx
movl %edx, 0x38(%rbx)
movq 0x30(%rbx), %rdi
leaq 0x8(,%r14,8), %rsi
callq 0x3a0b4
movq %rax, 0x30(%rbx)
movq (%rax,%r14,8), %rdi
movq 0x18(%rsp), %r15
movq %r15, %rsi
callq 0x3b494
movq 0x30(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq %r15, %rdi
callq 0x3a180
movl 0x38(%rbx), %eax
movl %eax, 0x20(%rbx)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq $0x0, 0x10(%rbx)
movsd %xmm0, 0x18(%rbx)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x24(%rbx)
xorl %eax, %eax
callq 0x2e6d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/plot.c
// Function: plotmv
void plotmv(char** names, int filecount)
{
 /*!Last Changed 20.09.2006*/
 /*!Last Changed 11.07.2005*/
 int count, i;
 Point p1, p2;
 char* plotname;
 if (!get_parameter_o("hold"))
   clear_image();
 plotname = file_only_name(names[0]);
 for (i = 0; i < filecount; i++)
  {
   p1.x = file_mean(&(names[i]), 1);
   p1.y = file_variance(&(names[i]), 1);
   p2.x = img.xaxis.namesavailable;
   p2.y = i;
   add_object(OBJECT_MVBOX, p1, p2, dummyp, NULL);
  }
 img.xaxis.namesavailable++;
 count = img.xaxis.namesavailable;
 img.xaxis.names = alloc(img.xaxis.names, count * sizeof(char *), count); 
 img.xaxis.names[count - 1] = strcopy(img.xaxis.names[count - 1], plotname);
 safe_free(plotname);
 img.xaxis.lim.division = count;
 img.xaxis.lim.min = 0;
 img.xaxis.lim.max = count;
 img.xaxis.lim.precision = 0;
 export_image();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
leaq 0x51187(%rip), %rdi     # 0xaa7b5
callq 0x54bec
testl %eax, %eax
jne 0x5963e
xorl %eax, %eax
callq 0x2e342
movq (%r14), %rdi
callq 0x38b30
movq %rax, %rbx
testl %ebp, %ebp
jle 0x596ba
movl %ebp, %r15d
xorl %r12d, %r12d
leaq 0x358a5e(%rip), %r13    # 0x3b20b8
movq %r14, %rdi
movl $0x1, %esi
callq 0x8e3a1
movsd %xmm0, (%rsp)
movq %r14, %rdi
movl $0x1, %esi
callq 0x8f246
movaps %xmm0, %xmm1
xorps %xmm2, %xmm2
cvtsi2sdl 0x38(%r13), %xmm2
xorps %xmm3, %xmm3
cvtsi2sd %r12d, %xmm3
movsd 0x7b9db(%rip), %xmm4    # 0xd5070
movsd 0x7b9db(%rip), %xmm5    # 0xd5078
movl $0x3, %edi
movsd (%rsp), %xmm0
xorl %esi, %esi
callq 0x2cc6c
incq %r12
addq $0x8, %r14
cmpq %r12, %r15
jne 0x5965a
leaq 0x3589f7(%rip), %r15    # 0x3b20b8
movslq 0x38(%r15), %r12
leaq 0x1(%r12), %r14
movl %r14d, 0x38(%r15)
movq 0x30(%r15), %rdi
leaq 0x8(,%r12,8), %rsi
movl %r14d, %edx
callq 0x3a0b4
movq %rax, 0x30(%r15)
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x3b494
movq 0x30(%r15), %rcx
movq %rax, (%rcx,%r12,8)
movq %rbx, %rdi
callq 0x3a180
movl %r14d, 0x20(%r15)
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movq $0x0, 0x10(%r15)
movsd %xmm0, 0x18(%r15)
movl $0x0, 0x24(%r15)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e6d0
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/plot.c
// Function: plotxy
void plotxy(char* names)
{
 /*!Last Changed 06.09.2006 incremented legendcount*/
 /*!Last Changed 08.10.2004 added img.xaxis.lim and img.yaxis.lim*/
 /*!Last Changed 02.02.2004 added safemalloc*/
 double** observations;
 int counts, j, color;
 char st[2], st2[10];
 Point p1, p3;
 if (!get_parameter_o("hold"))
   clear_image();
 img.yaxis.available = YES;
 color = img.imagelegend.legendcount;
 p3.x = color;
 st[0] = plots[color];
 st[1] = '\0';
 sprintf(st2, "Class %d", img.imagelegend.legendcount + 1);
 add_legend(st[0], st2);
 observations = read_2d_observations(names, &counts);
 for (j = 0; j < counts; j++)
  {
   p1.x = (double) observations[0][j];
   p1.y = (double) observations[1][j];
   add_object(OBJECT_STRING, p1, dummyp, p3, st);
  }
 safe_free(observations[0]);
 safe_free(observations[1]);
 safe_free(observations);
 export_image();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x50c18(%rip), %rdi     # 0xaa7b5
callq 0x54bec
testl %eax, %eax
jne 0x59bad
xorl %eax, %eax
callq 0x2e342
leaq 0x358504(%rip), %rax    # 0x3b20b8
movl $0x1, 0x78(%rax)
movslq 0xec(%rax), %r15
leaq 0x7b497(%rip), %rax     # 0xd5060
movsbl (%r15,%rax), %ebp
movb %bpl, 0x6(%rsp)
movb $0x0, 0x7(%rsp)
leal 0x1(%r15), %edx
leaq 0x51134(%rip), %rsi     # 0xaad17
leaq 0x16(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x41b0
movl %ebp, %edi
movq %r14, %rsi
callq 0x2cbc4
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x59956
movq %rax, %rbx
movslq (%r14), %r12
testq %r12, %r12
jle 0x59c68
cvtsi2sd %r15d, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
leaq 0x6(%rsp), %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movsd (%rax,%r15,8), %xmm0
movsd (%rcx,%r15,8), %xmm1
movsd 0x7b42b(%rip), %xmm2    # 0xd5070
movsd 0x7b42b(%rip), %xmm3    # 0xd5078
movl $0x1, %edi
movsd 0x8(%rsp), %xmm4
movq %r14, %rsi
callq 0x2cc6c
incq %r15
cmpq %r15, %r12
jne 0x59c2a
movq (%rbx), %rdi
callq 0x3a180
movq 0x8(%rbx), %rdi
callq 0x3a180
movq %rbx, %rdi
callq 0x3a180
xorl %eax, %eax
callq 0x2e6d0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/plot.c
// Function: plotxyline
void plotxyline(char* names, int linecolor, double linewidth)
{
 /*!Last Changed 20.09.2006 added line types*/
 /*!Last Changed 06.09.2006 incremented legendcount*/
 /*!Last Changed 08.10.2004 added img.xaxis.lim and img.yaxis.lim*/
 /*!Last Changed 02.02.2004 added safemalloc*/
 double** observations;
 int j, counts;
 char st2[3], *legendname;
 Point p1, p2;
 Objectptr obj;
 if (!get_parameter_o("hold"))
   clear_image();
 img.yaxis.available = 1;
 legendname = file_only_name(names); 
 add_legend((char) ('a' + img.imagelegend.legendcount), legendname);
 safe_free(legendname);
 observations = read_2d_observations(names, &counts);
 sprintf(st2, "%d", img.imagelegend.legendcount - 1);
 for (j = 0; j < counts - 1; j++)
  {
   p1.x = (double) (observations[0][j]);
   p1.y = (double) (observations[1][j]);
   p2.x = (double) (observations[0][j+1]);
   p2.y = (double) (observations[1][j+1]);
   obj = add_object(OBJECT_LINE, p1, p2, dummyp, st2);
   obj->fnt.fontcolor = linecolor;
   obj->fnt.fontsize = linewidth;
  }
 safe_free(observations[0]);
 safe_free(observations[1]);
 safe_free(observations);
 export_image();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x10(%rsp)
movl %esi, %ebx
movq %rdi, %r14
leaq 0x5063f(%rip), %rdi     # 0xaa7b5
callq 0x54bec
testl %eax, %eax
jne 0x5a186
xorl %eax, %eax
callq 0x2e342
leaq 0x357f2b(%rip), %r12    # 0x3b20b8
movl $0x1, 0x78(%r12)
movq %r14, %rdi
callq 0x38b30
movq %rax, %r15
movb 0xec(%r12), %al
addb $0x61, %al
movsbl %al, %edi
movq %r15, %rsi
callq 0x2cbc4
movq %r15, %rdi
callq 0x3a180
leaq 0x1c(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x59956
movq %rax, %r14
movl 0xec(%r12), %edx
decl %edx
leaq 0x56a13(%rip), %rsi     # 0xb0bf5
leaq 0xd(%rsp), %rdi
xorl %eax, %eax
callq 0x41b0
movl (%r15), %r12d
cmpl $0x2, %r12d
jl 0x5a252
decl %r12d
xorl %eax, %eax
leaq 0xd(%rsp), %r15
movq (%r14), %rcx
movq 0x8(%r14), %rdx
leaq 0x1(%rax), %r13
movsd (%rcx,%rax,8), %xmm0
movsd 0x8(%rcx,%rax,8), %xmm2
movsd (%rdx,%rax,8), %xmm1
movsd 0x8(%rdx,%rax,8), %xmm3
movsd 0x7ae46(%rip), %xmm4    # 0xd5070
movsd 0x7ae46(%rip), %xmm5    # 0xd5078
xorl %edi, %edi
movq %r15, %rsi
callq 0x2cc6c
movsd 0x10(%rsp), %xmm0
movl %ebx, 0x18(%rax)
movsd %xmm0, 0x10(%rax)
movq %r13, %rax
cmpq %r13, %r12
jne 0x5a201
movq (%r14), %rdi
callq 0x3a180
movq 0x8(%r14), %rdi
callq 0x3a180
movq %r14, %rdi
callq 0x3a180
xorl %eax, %eax
callq 0x2e6d0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: readpolydata
double** readpolydata(char* fname, int* datacount)
{
	/*!Last Changed 22.01.2005*/
	char line[READLINELENGTH];
	FILE* infile;
	double** data;
	int i;
 *datacount = file_length(fname);
 infile = fopen(fname,"r");
	if (!infile)
		 return NULL;
	data = (double**) safemalloc_2d(sizeof(double*), sizeof(double), *datacount, 2, "read_polydata", 6);
 i = 0;
 while (fgets(line, READLINELENGTH, infile))
  {
   sscanf(line, "%lf %lf", &(data[i][0]), &(data[i][1]));
   i++;
  }
 fclose(infile);
	return data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a120, %rsp          # imm = 0x7A120
movq %rsi, %r14
movq %rdi, %rbx
callq 0x38a4a
movl %eax, (%r14)
leaq 0x514fe(%rip), %rsi     # 0xab95b
movq %rbx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x5a4f2
movq %rax, %rbx
movl (%r14), %edx
leaq 0x5091d(%rip), %r8      # 0xaad98
movl $0x8, %edi
movl $0x8, %esi
movl $0x2, %ecx
movl $0x6, %r9d
callq 0x3a3ac
movq %rax, %r14
movq %rsp, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rbx, %rdx
callq 0x4120
testq %rax, %rax
je 0x5a4e8
leaq 0x4e4b6(%rip), %r15     # 0xa896a
movq %rsp, %r12
movq %r14, %r13
movq (%r13), %rdx
leaq 0x8(%rdx), %rcx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r12, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rbx, %rdx
callq 0x4120
addq $0x8, %r13
testq %rax, %rax
jne 0x5a4ba
movq %rbx, %rdi
callq 0x42a0
jmp 0x5a4f5
xorl %r14d, %r14d
movq %r14, %rax
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: mean_of_polynoms
Polynomptr mean_of_polynoms(Polynomptr* polynoms, int polynomcount)
{
	/*!Last Changed 21.01.2005*/
	Polynomptr p;
	Polynodeptr* nodes;
	int i, currentdegree = -1, count;
	double sum;
	p = create_polynom();
	nodes = safemalloc(polynomcount * sizeof(Polynodeptr), "mean_of_polynoms", 6);
 for (i = 0; i < polynomcount; i++)
	 {
		 nodes[i] = polynoms[i]->start;
			if (nodes[i] && nodes[i]->power > currentdegree)
				 currentdegree = nodes[i]->power;
	 }
	while (currentdegree >= 0)
	 {
		 sum = 0;
			count = 0;
		 for (i = 0; i < polynomcount; i++)
				 if (nodes[i] && nodes[i]->power == currentdegree)
					 {
						 sum += nodes[i]->coefficient;
							count++;
						 nodes[i] = nodes[i]->next;
					 }
   if (count > 0)
				 add_polynode_to_polynom(p, currentdegree, sum / count);
		 currentdegree--;
	 }
	safe_free(nodes);
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r13
leaq 0x508d2(%rip), %rsi     # 0xaadf2
movl $0x10, %edi
movl $0x1, %edx
callq 0x3a0e1
movq %rax, %r14
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
movslq %ebx, %r12
leaq (,%r12,8), %rdi
leaq 0x5085a(%rip), %rsi     # 0xaada6
movl $0x6, %edx
callq 0x3a0e1
movq %rax, %r15
testl %r12d, %r12d
jle 0x5a5ec
movl %ebx, %ebp
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
xorl %eax, %eax
movq (%r13,%rax,8), %rcx
movq (%rcx), %rcx
movq %rcx, (%r15,%rax,8)
testq %rcx, %rcx
je 0x5a587
movl 0x8(%rcx), %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
incq %rax
cmpq %rax, %rbp
jne 0x5a56c
testl %r12d, %r12d
js 0x5a5ec
testl %ebx, %ebx
jle 0x5a5df
xorl %ecx, %ecx
xorpd %xmm0, %xmm0
xorl %eax, %eax
movq (%r15,%rcx,8), %rdx
testq %rdx, %rdx
je 0x5a5bd
cmpl %r12d, 0x8(%rdx)
jne 0x5a5bd
addsd (%rdx), %xmm0
incl %eax
movq 0x10(%rdx), %rdx
movq %rdx, (%r15,%rcx,8)
incq %rcx
cmpq %rcx, %rbp
jne 0x5a5a0
testl %eax, %eax
jle 0x5a5df
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movq %r14, %rdi
movl %r12d, %esi
callq 0x5a606
leal -0x1(%r12), %eax
testl %r12d, %r12d
movl %eax, %r12d
jg 0x5a594
movq %r15, %rdi
callq 0x3a180
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: add_polynode_to_polynom
void add_polynode_to_polynom(Polynomptr p, int power, double coefficient)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 Polynodeptr result, tmp, tmpbefore;
 result = (Polynodeptr)safemalloc(sizeof(Polynode), "add_polynode_to_polynom", 2);
 result->power=power;
 result->coefficient=coefficient;
 result->next=NULL;
 if (p->start==NULL)/*If the list is empty*/
  {
   p->start=result;
   p->end=result;
   return;
  }
 tmp=p->start;
 tmpbefore=NULL;/*Finds the position to put the new node*/
 while (tmp && tmp->power>power)
  {
   tmpbefore=tmp;
   tmp=tmp->next;
  }
 if (tmp)/*If the new element has a higher power than at least one of the the existing powers*/
  {
   if (tmp->power==power)/*If the power already exists return from function*/
    {
     safe_free(result);
     return;
    }
   result->next=tmp;
   if (tmpbefore)
     tmpbefore->next=result;
   else
     p->start=result;
  }
 else
  {
   p->end->next=result;
   p->end=result;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x507ed(%rip), %rsi     # 0xaae07
movl $0x18, %edi
movl $0x2, %edx
callq 0x3a0e1
movl %ebp, 0x8(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x5a661
movl 0x8(%rcx), %esi
cmpl %ebp, %esi
jle 0x5a666
movq %rcx, %rdx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x5a689
movl 0x8(%rcx), %esi
cmpl %ebp, %esi
jg 0x5a64c
jmp 0x5a668
movq %rax, (%rbx)
jmp 0x5a691
xorl %edx, %edx
cmpl %ebp, %esi
jne 0x5a67a
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3a180
movq %rcx, 0x10(%rax)
testq %rdx, %rdx
je 0x5a69c
movq %rax, 0x10(%rdx)
jmp 0x5a695
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, (%rbx)
jmp 0x5a695
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: find_function_bounds
void find_function_bounds(Functionptr fx, int functioncount, double* min, double* max)
{
	/*!Last Changed 21.01.2005*/
	int i;
	*min = fx[0].min;
	*max = fx[0].max;
	for (i = 1; i < functioncount; i++)
	 {
		 if (fx[i].min < *min)
				 *min = fx[i].min;
		 if (fx[i].max > *max)
				 *max = fx[i].max;
	 }
}

// Assembly:
movsd 0x10(%rdi), %xmm0
movsd %xmm0, (%rdx)
movsd 0x18(%rdi), %xmm0
movsd %xmm0, (%rcx)
cmpl $0x2, %esi
jl 0x5a6f9
movl %esi, %eax
shlq $0x5, %rax
addq $-0x20, %rax
xorl %esi, %esi
movsd 0x30(%rdi,%rsi), %xmm1
movsd (%rdx), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x5a6dc
movsd %xmm1, (%rdx)
movsd (%rcx), %xmm0
movsd 0x38(%rdi,%rsi), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5a6f0
movsd %xmm1, (%rcx)
movapd %xmm1, %xmm0
addq $0x20, %rsi
cmpq %rsi, %rax
jne 0x5a6c4
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: functiondatagenerate
double** functiondatagenerate(int datasize, Functionptr fx, int functioncount, int noisy)
{
	/*!Last Changed 21.01.2005*/
 int i;
 double x, value, **values, start, end;
	values = (double**) safemalloc_2d(sizeof(double *), sizeof(double), datasize, 2, "functiondatagenerate", 3);
 find_function_bounds(fx, functioncount, &start, &end);
 for (i = 0; i < datasize; i++)
  {
   x = produce_random_value(start, end);
   value = function_value(fx, functioncount, 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 $0x38, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movl %edi, %r12d
leaq 0x5069e(%rip), %r8      # 0xaadb7
movl $0x8, %edi
movl $0x8, %esi
movl %r12d, %edx
movl $0x2, %ecx
movl $0x3, %r9d
callq 0x3a3ac
movq %rax, %r15
movsd 0x10(%r14), %xmm6
movsd 0x18(%r14), %xmm5
cmpl $0x2, %ebp
jl 0x5a7b5
movl %ebp, %eax
shlq $0x5, %rax
addq $-0x20, %rax
xorl %ecx, %ecx
movapd %xmm5, %xmm2
movsd 0x30(%r14,%rcx), %xmm3
movapd %xmm3, %xmm0
cmpltsd %xmm6, %xmm3
movapd %xmm3, %xmm4
andnpd %xmm2, %xmm3
movsd 0x38(%r14,%rcx), %xmm2
minsd %xmm6, %xmm0
andpd %xmm5, %xmm4
orpd %xmm4, %xmm3
movapd %xmm3, %xmm1
cmpltsd %xmm2, %xmm1
movapd %xmm1, %xmm4
andpd %xmm2, %xmm4
andnpd %xmm5, %xmm1
orpd %xmm4, %xmm1
maxsd %xmm3, %xmm2
addq $0x20, %rcx
movapd %xmm0, %xmm6
movapd %xmm1, %xmm5
cmpq %rcx, %rax
jne 0x5a75a
jmp 0x5a7bd
movapd %xmm6, %xmm0
movapd %xmm5, %xmm1
testl %r12d, %r12d
jle 0x5a841
movl %r12d, %r13d
xorl %r12d, %r12d
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, 0x20(%rsp)
callq 0x3af6a
movq %r14, %rdi
movl %ebp, %esi
movsd %xmm0, 0x18(%rsp)
callq 0x5a853
movapd %xmm0, %xmm1
testl %ebx, %ebx
je 0x5a81a
leaq 0x4be49(%rip), %rdi     # 0xa6641
movsd %xmm1, 0x10(%rsp)
callq 0x549ba
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
callq 0x8f4b0
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movq (%r15,%r12,8), %rax
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
incq %r12
cmpq %r12, %r13
movsd 0x8(%rsp), %xmm0
movapd 0x20(%rsp), %xmm1
jne 0x5a7d4
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: function_value
double function_value(Functionptr fx, int functioncount, double x)
{
	/*!Last Changed 21.01.2005*/
	int i, which = -1;
	Functionnodeptr tmp;
	double value, sum = 0, polynomvalue;
	for (i = 0; i < functioncount; i++)
		 if (x >= fx[i].min && x <= fx[i].max)
			 {
				 which = i;
				 break;
			 }
 tmp = fx[which].start;
	while (tmp)
	 {
		 value = tmp->coefficient;
			if (tmp->xpower != 0)
				 value *= fpow(x, tmp->xpower);
			if (tmp->sinpower != 0)
			 {
				 polynomvalue = polynom_value(tmp->sinus, x);
					value *= fpow(sin(polynomvalue), tmp->sinpower);
			 }
			if (tmp->cospower != 0)
			 {
				 polynomvalue = polynom_value(tmp->cosinus, x);
					value *= fpow(cos(polynomvalue), tmp->cospower);
			 }
			sum += value;
		 tmp = tmp->next;
	 }
	return sum;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq $-0x1, %rax
testl %esi, %esi
jle 0x5a88f
movl %esi, %ecx
leaq 0x18(%rdi), %rsi
xorl %edx, %edx
ucomisd -0x8(%rsi), %xmm0
jb 0x5a87e
movsd (%rsi), %xmm1
ucomisd %xmm0, %xmm1
jae 0x5a88c
incq %rdx
addq $0x20, %rsi
cmpq %rdx, %rcx
jne 0x5a86d
jmp 0x5a88f
movq %rdx, %rax
shlq $0x5, %rax
movq (%rdi,%rax), %rbx
testq %rbx, %rbx
je 0x5a9dd
xorpd %xmm1, %xmm1
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd (%rbx), %xmm2
movl 0x8(%rbx), %edi
testl %edi, %edi
je 0x5a8ce
movsd %xmm2, (%rsp)
callq 0x39b12
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
cmpl $0x0, 0xc(%rbx)
je 0x5a944
movq 0x10(%rbx), %rax
movq (%rax), %r14
testq %r14, %r14
movsd %xmm2, (%rsp)
xorpd %xmm0, %xmm0
je 0x5a92e
movsd %xmm0, 0x10(%rsp)
movsd (%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x8(%r14), %edi
movsd 0x8(%rsp), %xmm0
callq 0x39b12
mulsd 0x20(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x5a8e9
callq 0x4320
movl 0xc(%rbx), %edi
callq 0x39b12
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
cmpl $0x0, 0x18(%rbx)
je 0x5a9be
movq 0x20(%rbx), %rax
movq (%rax), %r14
testq %r14, %r14
movsd %xmm2, (%rsp)
xorpd %xmm1, %xmm1
je 0x5a99e
movsd %xmm1, 0x10(%rsp)
movsd (%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x8(%r14), %edi
movsd 0x8(%rsp), %xmm0
callq 0x39b12
movsd 0x10(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm0
addsd %xmm0, %xmm1
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x5a965
movapd %xmm1, %xmm0
callq 0x4110
movl 0x18(%rbx), %edi
callq 0x39b12
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x18(%rsp)
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x5a8b0
jmp 0x5a9e7
xorpd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: functiondatageneratefile
double** functiondatageneratefile(int datasize, char* functiondefinition, int noisy)
{
	/*!Last Changed 21.01.2005*/
	int functioncount, i;
	double** data;
	Functionptr fx;
	fx = read_function_definition(functiondefinition, &functioncount);
	data = functiondatagenerate(datasize, fx, functioncount, noisy);
 for (i = 0;i < functioncount; i++)
	  free_function(fx[i]);
	safe_free(fx);
	return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %edi, %r15d
leaq 0x4(%rsp), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x5aa85
movq %rax, %rbx
movslq (%r14), %r14
movl %r15d, %edi
movq %rax, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x5a6fa
movq %rax, %r15
testq %r14, %r14
jle 0x5aa6b
xorl %r13d, %r13d
movq %r13, %rax
shlq $0x5, %rax
movq (%rbx,%rax), %r12
testq %r12, %r12
je 0x5aa63
movq 0x28(%r12), %rbp
movq %r12, %rdi
callq 0x5ac01
movq %r12, %rdi
callq 0x3a180
movq %rbp, %r12
testq %rbp, %rbp
jne 0x5aa46
incq %r13
cmpq %r14, %r13
jne 0x5aa36
movq %rbx, %rdi
callq 0x3a180
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: read_function_definition
Functionptr read_function_definition(char* functiondefinition, int* functioncount)
{
	/*!Last Changed 19.01.2005*/
	FILE* infile;
	Functionptr fx = NULL;
	Function tmp;
	char line[READLINELENGTH];
	*functioncount = 0;
	infile = fopen(functiondefinition, "r");
	if (!infile)
		 return NULL;
 while (fgets(line, READLINELENGTH, infile))
	 {
		 tmp = create_function(line);
			if (tmp.min > tmp.max)
				 return fx;
			fx = alloc(fx, (*functioncount + 1) * sizeof(Function), *functioncount + 1);
			fx[*functioncount] = tmp;
			(*functioncount)++;
	 }
	fclose(infile);
	return fx;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a160, %rsp          # imm = 0x7A160
movq %rsi, %rbx
movl $0x0, (%rsi)
leaq 0x50eb6(%rip), %rsi     # 0xab95b
callq 0x40f0
testq %rax, %rax
je 0x5ab60
movq %rax, %r14
leaq 0x40(%rsp), %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
xorl %r15d, %r15d
testq %rax, %rax
je 0x5ab56
leaq 0x20(%rsp), %r12
leaq 0x40(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x5b089
movups 0x20(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movupd 0x30(%rsp), %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
ucomisd %xmm0, %xmm1
ja 0x5ab63
movslq (%rbx), %rdx
incq %rdx
movq %rdx, %rsi
shlq $0x5, %rsi
movq %r15, %rdi
movapd %xmm1, (%rsp)
callq 0x3a0b4
movq %rax, %r15
movslq (%rbx), %rax
shlq $0x5, %rax
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r15,%rax)
movaps (%rsp), %xmm0
movups %xmm0, 0x10(%r15,%rax)
incl (%rbx)
movq %r13, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r14, %rdx
callq 0x4120
testq %rax, %rax
jne 0x5aade
movq %r14, %rdi
callq 0x42a0
jmp 0x5ab63
xorl %r15d, %r15d
movq %r15, %rax
addq $0x7a160, %rsp          # imm = 0x7A160
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: free_function
void free_function(Function fx)
{
	/*!Last Changed 19.01.2005*/
	Functionnodeptr tmp, next;
	tmp = fx.start;
	while (tmp)
	 {
		 next = tmp->next;
			free_functionnode(tmp);
			safe_free(tmp);
			tmp = next;
	 }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rsp), %rbx
testq %rbx, %rbx
je 0x5aba1
movq 0x28(%rbx), %r14
movq %rbx, %rdi
callq 0x5ac01
movq %rbx, %rdi
callq 0x3a180
movq %r14, %rbx
testq %r14, %r14
jne 0x5ab85
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: polynom_value
double polynom_value(Polynomptr p, double value)
{
 double result = 0;
 Polynodeptr tmp = p->start;
 while (tmp)
  {
   result += tmp->coefficient * fpow(value,tmp->power);
   tmp = tmp->next;
  }
 return result;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rbx
xorpd %xmm1, %xmm1
testq %rbx, %rbx
je 0x5abf7
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd (%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0x8(%rbx), %edi
movsd 0x8(%rsp), %xmm0
callq 0x39b12
movsd 0x18(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm1
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x5abc0
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: free_functionnode
void free_functionnode(Functionnodeptr fnode)
{
	/*!Last Changed 19.01.2005*/
	if (fnode->sinpower != 0)
  	free_polynom(fnode->sinus);
	if (fnode->cospower != 0)
  	free_polynom(fnode->cosinus);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
je 0x5ac14
movq 0x10(%rbx), %rdi
callq 0x5ac26
cmpl $0x0, 0x18(%rbx)
je 0x5ac24
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x5ac26
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: free_polynom
void free_polynom(Polynomptr p)
{
 Polynodeptr tmp, tmpnxt;
 tmp = p->start;
 while (tmp)
  {
   tmpnxt = tmp->next;
   safe_free(tmp);
   tmp = tmpnxt;
  }
 safe_free(p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5ac46
movq 0x10(%rdi), %r14
callq 0x3a180
movq %r14, %rdi
testq %r14, %r14
jne 0x5ac35
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: print_polynom
void print_polynom(Polynomptr p, char* st)
{
	/*!Last Changed 23.01.2005*/
 Polynodeptr tmp;
	char literal[20], pst[READLINELENGTH];
	strcpy(st, "");
 tmp = p->start;
 while (tmp)
  {
   if (tmp->coefficient < 0)
     if (tmp->power > 1)
					 {
    			set_precision(pst, NULL, "x%d");
       sprintf(literal, pst, tmp->coefficient, tmp->power);
					 }
     else
       if (tmp->power == 1)
							 {
			      set_precision(pst, NULL, "x");
         sprintf(literal, pst, tmp->coefficient);
							 }
       else
							 {
      			set_precision(pst, NULL, NULL);
         sprintf(literal, pst, tmp->coefficient);
							 }
   else
     if (tmp->power > 1)
					 {
			    set_precision(pst, "+", "x%d");
       sprintf(literal, pst, tmp->coefficient, tmp->power);
					 }
     else
       if (tmp->power == 1)
							 {
			      set_precision(pst, "+", "x");
         sprintf(literal, pst, tmp->coefficient);
							 }
       else
							 {
			      set_precision(pst, "+", NULL);
         sprintf(literal, pst, tmp->coefficient);
							 }
   strcat(st, literal);
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a148, %rsp          # imm = 0x7A148
movb $0x0, (%rsi)
movq (%rdi), %r13
testq %r13, %r13
je 0x5b529
movq %rsi, %rbx
leaq 0x4f963(%rip), %r14     # 0xaae01
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq 0x4f958(%rip), %rbp     # 0xaae05
xorpd %xmm0, %xmm0
ucomisd (%r13), %xmm0
movl 0x8(%r13), %eax
movq %r15, %rdi
jbe 0x5b4c4
xorl %esi, %esi
jmp 0x5b4c7
movq %rbp, %rsi
cmpl $0x2, %eax
jl 0x5b4ed
movq %r14, %rdx
callq 0x3a535
movsd (%r13), %xmm0
movl 0x8(%r13), %edx
movq %r12, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x41b0
jmp 0x5b515
cmpl $0x1, %eax
jne 0x5b4fb
leaq 0x4a99b(%rip), %rdx     # 0xa5e94
jmp 0x5b4fd
xorl %edx, %edx
callq 0x3a535
movsd (%r13), %xmm0
movq %r12, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x41b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x41e0
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x5b4ad
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/poly.c
// Function: calculate_poly_clserror
double calculate_poly_clserror(double** data, int datasize, Polynomptr p)
{
	/*!Last Changed 26.01.2005*/
 double sum = 0, r, y, o;
	int i;
	for (i = 0; i < datasize; i++)
	 {
		 y = polynom_value(p, data[i][0]);
			if (sigmoid(y) > 0.5)
				 o = 1;
			else
				 o = 0;
			r = data[i][1];
			if (r != o)
     sum++;
	 }
 if (datasize == 0)
   return 0;
 return sum / datasize;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
xorpd %xmm1, %xmm1
testl %esi, %esi
jle 0x5b620
movq %rdx, %r14
movq %rdi, %r15
movl %ebx, %r12d
xorpd %xmm0, %xmm0
xorl %r13d, %r13d
movapd %xmm0, 0x20(%rsp)
movq (%r14), %rbp
xorpd %xmm0, %xmm0
testq %rbp, %rbp
je 0x5b5ce
movq (%r15,%r13,8), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rbp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x8(%rbp), %edi
movsd 0x10(%rsp), %xmm0
callq 0x39b12
mulsd 0x18(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x10(%rbp), %rbp
testq %rbp, %rbp
jne 0x5b58a
callq 0x55a80
movsd 0x4a73d(%rip), %xmm1    # 0xa5d18
cmpltsd %xmm0, %xmm1
movsd 0x49f38(%rip), %xmm2    # 0xa5520
andpd %xmm2, %xmm1
movq (%r15,%r13,8), %rax
movapd 0x20(%rsp), %xmm3
movapd %xmm3, %xmm0
addsd %xmm2, %xmm0
cmpneqsd 0x8(%rax), %xmm1
andpd %xmm1, %xmm0
andnpd %xmm3, %xmm1
orpd %xmm0, %xmm1
incq %r13
movapd %xmm1, %xmm0
cmpq %r12, %r13
jne 0x5b567
testl %ebx, %ebx
xorpd %xmm0, %xmm0
je 0x5b637
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5b732
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 0x5b6d3
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 0x39b12
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 0x5b68d
callq 0x55a80
movq (%r14,%r12,8), %rax
movsd 0x8(%rax), %xmm1
movsd 0x49e37(%rip), %xmm2    # 0xa5520
ucomisd %xmm2, %xmm1
movapd %xmm2, %xmm1
jne 0x5b701
jp 0x5b701
ucomisd 0x4a60b(%rip), %xmm0    # 0xa5d08
jne 0x5b711
jp 0x5b711
ucomisd %xmm1, %xmm0
jne 0x5b709
jnp 0x5b724
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x4160
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r12
cmpq %r15, %r12
jne 0x5b670
jmp 0x5b73b
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_O3/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 0x5b7f6
movq %rdx, %r14
movq %rdi, %r15
movl %ebx, %r12d
xorl %r13d, %r13d
movq (%r15,%r13,8), %rax
movq (%r14), %rbp
testq %rbp, %rbp
je 0x5b7d9
movsd %xmm1, 0x8(%rsp)
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm2, %xmm2
movsd %xmm2, 0x20(%rsp)
movsd (%rbp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x8(%rbp), %edi
movsd 0x10(%rsp), %xmm0
callq 0x39b12
movsd 0x20(%rsp), %xmm2
mulsd 0x18(%rsp), %xmm0
addsd %xmm0, %xmm2
movq 0x10(%rbp), %rbp
testq %rbp, %rbp
jne 0x5b795
movq (%r15,%r13,8), %rax
movsd 0x8(%rsp), %xmm1
jmp 0x5b7dd
xorpd %xmm2, %xmm2
movsd 0x8(%rax), %xmm0
subsd %xmm2, %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
incq %r13
cmpq %r12, %r13
jne 0x5b776
testl %ebx, %ebx
xorpd %xmm0, %xmm0
je 0x5b80d
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_O3/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, %rbx
leaq 0x50124(%rip), %rsi     # 0xab95b
callq 0x40f0
testq %rax, %rax
je 0x5b937
movq %rax, %r14
leaq 0x30(%rsp), %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
testq %rax, %rax
je 0x5b941
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x30(%rsp), %r12
leaq 0x20(%rsp), %rbp
xorl %r15d, %r15d
movq %r12, %rdi
leaq 0x4d0e7(%rip), %rsi     # 0xa896a
leaq 0x28(%rsp), %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x40b0
movq (%rbx), %r13
xorpd %xmm1, %xmm1
testq %r13, %r13
je 0x5b8e4
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 0x39b12
movsd 0x18(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm1
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x5b8aa
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 %r14, %rdx
callq 0x4120
testq %rax, %rax
jne 0x5b879
movq %r14, %rdi
callq 0x42a0
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x5b94d
movsd 0x4a9f1(%rip), %xmm0    # 0xa6330
jmp 0x5b94d
movq %r14, %rdi
callq 0x42a0
xorpd %xmm0, %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_O3/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, %r15d
movl %esi, %ebp
movq %rdi, %r12
leal 0x1(%r15), %ebx
movl %ebx, %edi
movl %ebx, %esi
callq 0x3d79d
movq %rdx, %r13
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movl %ebx, %edi
movl $0x1, %esi
callq 0x3d79d
movq %rax, (%rsp)
movq %rdx, %r14
movl %ebx, %ebx
testl %ebp, %ebp
jle 0x5ba14
movl %ebp, %eax
xorl %ecx, %ecx
movsd 0x49b6c(%rip), %xmm0    # 0xa5520
testl %r15d, %r15d
js 0x5ba0c
movq (%r12,%rcx,8), %rdx
xorl %esi, %esi
movapd %xmm0, %xmm1
movq (%r13,%rsi,8), %rdi
xorl %r8d, %r8d
movapd %xmm1, %xmm2
movsd (%rdi,%r8,8), %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%rdi,%r8,8)
mulsd (%rdx), %xmm2
incq %r8
cmpq %r8, %rbx
jne 0x5b9cf
movq (%r14,%rsi,8), %rdi
movsd 0x8(%rdx), %xmm2
mulsd %xmm1, %xmm2
addsd (%rdi), %xmm2
movsd %xmm2, (%rdi)
mulsd (%rdx), %xmm1
incq %rsi
cmpq %rbx, %rsi
jne 0x5b9c3
incq %rcx
cmpq %rax, %rcx
jne 0x5b9b4
leaq 0x4f3d7(%rip), %rsi     # 0xaadf2
movl $0x10, %edi
movl $0x1, %edx
callq 0x3a0e1
movq %rax, %r12
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x409b7
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq (%rsp), %rdx
movq %r14, %rcx
callq 0x3ee2f
movq %rax, %r13
movq %rdx, %rbp
testl %r15d, %r15d
js 0x5ba80
xorl %r15d, %r15d
movq (%rbp,%r15,8), %rax
movsd (%rax), %xmm0
movq %r12, %rdi
movl %r15d, %esi
callq 0x5a606
incq %r15
cmpq %r15, %rbx
jne 0x5ba64
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3ed51
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3ed51
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x3ed51
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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 0x5a438
movq %rax, %r12
movl (%r15), %r15d
movq %rax, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x5b95f
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x5b81c
movsd %xmm0, (%rbx)
movq %r12, %rdi
movl %r15d, %esi
callq 0x3a14b
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_O3/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 0x5a438
movq %rax, %r15
movl (%r14), %r14d
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x5bb7b
movq %rax, %r12
movq %r15, %rdi
movl %r14d, %esi
movq %rax, %rdx
callq 0x5b53b
movsd %xmm0, (%rbx)
movq %r15, %rdi
movl %r14d, %esi
callq 0x3a14b
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5b29e
movq %rax, %r14
leaq 0x4f016(%rip), %r8      # 0xaae1f
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl $0x2, %ecx
movl $0x4, %r9d
callq 0x3a3ac
movq %rax, %r15
testl %ebp, %ebp
jle 0x5bee2
movl %ebp, %r13d
xorl %ebp, %ebp
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x3af6a
movq (%r14), %r12
xorpd %xmm1, %xmm1
testq %r12, %r12
movsd %xmm0, 0x8(%rsp)
je 0x5be98
movsd %xmm1, (%rsp)
movsd (%r12), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x8(%r12), %edi
movsd 0x8(%rsp), %xmm0
callq 0x39b12
movsd (%rsp), %xmm1
mulsd 0x20(%rsp), %xmm0
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x5be58
testl %ebx, %ebx
je 0x5bec9
leaq 0x4a79e(%rip), %rdi     # 0xa6641
movsd %xmm1, (%rsp)
callq 0x549ba
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
callq 0x8f4b0
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 0x5be35
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_O3/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 0x4fa5c(%rip), %rsi     # 0xab96d
callq 0x40f0
testq %rax, %rax
je 0x5bf8a
movq %rax, %r14
testl %ebp, %ebp
jle 0x5bf82
movl %ebp, %ebp
xorl %r12d, %r12d
movq %rsp, %r15
leaq 0x4d26a(%rip), %r13     # 0xa919b
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3a535
movq (%rbx,%r12,8), %rax
movsd (%rax), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
movq %r15, %rdi
leaq 0x4c789(%rip), %rsi     # 0xa86e5
movq %r13, %rdx
callq 0x3a535
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 0x5bf31
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_O3/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 0x5d519
leaq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x783de(%rip), %rsi     # 0xd5870
movsd 0x48856(%rip), %xmm0    # 0xa5cf0
cmpl $0x0, 0x1bc(%rsi)
jle 0x5d510
movl $0x61e1, %ecx           # imm = 0x61E1
xorl %edx, %edx
movl (%rsi,%rcx,8), %esi
cmpl $0x2, %esi
je 0x5d4dc
cmpl $0x1, %esi
je 0x5d4c9
testl %esi, %esi
jne 0x5d4f6
movq (%rdi), %rsi
cmpl $0x75bcd15, (%rsi,%rdx,8) # imm = 0x75BCD15
je 0x5d4d2
jmp 0x5d4f6
movq (%rdi), %rsi
cmpl $-0x1, (%rsi,%rdx,8)
jne 0x5d4f6
movl (%rax,%rdx,8), %r8d
movl %r8d, (%rsi,%rdx,8)
jmp 0x5d4f6
movq (%rdi), %rsi
movsd (%rsi,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x5d4f6
jp 0x5d4f6
movsd (%rax,%rdx,8), %xmm1
movsd %xmm1, (%rsi,%rdx,8)
incq %rdx
movq 0x78370(%rip), %rsi     # 0xd5870
movslq 0x1bc(%rsi), %r8
addq $0x68, %rcx
cmpq %r8, %rdx
jl 0x5d4aa
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0x5d49a
retq