LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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, %r14
leaq 0x48af6(%rip), %rdi     # 0x9a6e5
callq 0x4cff1
testl %eax, %eax
jne 0x51bff
xorl %eax, %eax
callq 0x2a510
leaq 0x3584b2(%rip), %rax    # 0x3aa0b8
movl $0x1, 0x78(%rax)
movslq 0xec(%rax), %rax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x7b43b(%rip), %rcx     # 0xcd060
movsbl (%rax,%rcx), %ebp
leaq 0x6(%rsp), %rbx
movb %bpl, (%rbx)
movb $0x0, 0x1(%rbx)
leal 0x1(%rax), %edx
leaq 0x49008(%rip), %rsi     # 0x9ac47
xorl %r12d, %r12d
leaq 0x16(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x41b0
movl %ebp, %edi
movq %r15, %rsi
callq 0x28ee8
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x51a2a
movq %rax, %r14
movslq (%r15), %r15
pushq $0x1
popq %rbp
movq (%r14), %rdi
cmpq %r15, %r12
jge 0x51cb1
movsd (%rdi,%r12,8), %xmm0
movq 0x8(%r14), %rax
movsd (%rax,%r12,8), %xmm1
movsd 0x7b3dc(%rip), %xmm2    # 0xcd070
movsd 0x7b3dc(%rip), %xmm3    # 0xcd078
movl %ebp, %edi
movsd 0x8(%rsp), %xmm4
movq %rbx, %rsi
callq 0x28f8d
incq %r12
jmp 0x51c74
callq 0x34ff7
movq 0x8(%r14), %rdi
callq 0x34ff7
movq %r14, %rdi
callq 0x34ff7
xorl %eax, %eax
callq 0x2a858
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movq %rdi, %r14
leaq 0x485e2(%rip), %rdi     # 0x9a6e5
callq 0x4cff1
testl %eax, %eax
jne 0x52113
xorl %eax, %eax
callq 0x2a510
leaq 0x357f9e(%rip), %r13    # 0x3aa0b8
movl $0x1, 0x78(%r13)
movq %r14, %rdi
callq 0x34033
movq %rax, %r15
movb 0xec(%r13), %al
addb $0x61, %al
movsbl %al, %edi
movq %r15, %rsi
callq 0x28ee8
movq %r15, %rdi
callq 0x34ff7
leaq 0x14(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x51a2a
movq %rax, %r14
movl 0xec(%r13), %edx
decl %edx
leaq 0x4e9ed(%rip), %rsi     # 0xa0b59
xorl %r13d, %r13d
leaq 0x5(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x41b0
movslq (%r12), %r12
decq %r12
movq (%r14), %rdi
cmpq %r12, %r13
jge 0x521dc
movq 0x8(%r14), %rax
leaq 0x1(%r13), %rbp
movsd (%rdi,%r13,8), %xmm0
movsd 0x8(%rdi,%r13,8), %xmm2
movsd (%rax,%r13,8), %xmm1
movsd 0x8(%rax,%r13,8), %xmm3
movsd 0x7aeb9(%rip), %xmm4    # 0xcd070
movsd 0x7aeb9(%rip), %xmm5    # 0xcd078
xorl %edi, %edi
movq %r15, %rsi
callq 0x28f8d
movl %ebx, 0x18(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movq %rbp, %r13
jmp 0x52185
callq 0x34ff7
movq 0x8(%r14), %rdi
callq 0x34ff7
movq %r14, %rdi
callq 0x34ff7
xorl %eax, %eax
callq 0x2a858
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0x33f62
movl %eax, (%r14)
leaq 0x494a2(%rip), %rsi     # 0x9b87f
movq %rbx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x52453
movq %rax, %rbx
movl (%r14), %edx
leaq 0x488d1(%rip), %r8      # 0x9acc8
pushq $0x8
popq %rdi
pushq $0x2
popq %rcx
pushq $0x6
popq %r9
movq %rdi, %rsi
callq 0x351c3
movq %rax, %r14
movq %rsp, %r15
leaq 0x464d4(%rip), %r12     # 0x988ea
movq %rax, %r13
movq %r15, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rbx, %rdx
callq 0x4120
testq %rax, %rax
je 0x52449
movq (%r13), %rdx
leaq 0x8(%rdx), %rcx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x40b0
addq $0x8, %r13
jmp 0x52419
movq %rbx, %rdi
callq 0x42a0
jmp 0x52456
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_O2/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 %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r15
callq 0x53230
movq %rax, %rbx
movslq %ebp, %r12
leaq (,%r12,8), %rdi
leaq 0x48845(%rip), %rsi     # 0x9acd6
pushq $0x6
popq %rdx
callq 0x34f59
movq %rax, %r14
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
pushq $-0x1
popq %rbp
cmpq %rax, %r12
je 0x52510
movq (%r15,%rax,8), %rcx
movq (%rcx), %rcx
movq %rcx, (%r14,%rax,8)
testq %rcx, %rcx
je 0x524c5
movl 0x8(%rcx), %ecx
cmpl %ebp, %ecx
cmovgl %ecx, %ebp
incq %rax
jmp 0x524a8
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %rcx, %r12
je 0x524f8
movq (%r14,%rcx,8), %rdx
testq %rdx, %rdx
je 0x524f3
cmpl %ebp, 0x8(%rdx)
jne 0x524f3
addsd (%rdx), %xmm0
incl %eax
movq 0x10(%rdx), %rdx
movq %rdx, (%r14,%rcx,8)
incq %rcx
jmp 0x524d2
testl %eax, %eax
jle 0x5250e
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x52528
decl %ebp
testl %ebp, %ebp
jns 0x524ca
movq %r14, %rdi
callq 0x34ff7
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x487fb(%rip), %rsi     # 0x9ad37
pushq $0x18
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movl %ebp, 0x8(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x52578
xorl %ecx, %ecx
testq %rdx, %rdx
je 0x5257d
movq %rdx, %rsi
cmpl %ebp, 0x8(%rdx)
jle 0x52590
movq 0x10(%rsi), %rdx
movq %rsi, %rcx
jmp 0x52562
movq %rax, (%rbx)
jmp 0x52585
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
jne 0x525a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x34ff7
movq %rsi, 0x10(%rax)
testq %rcx, %rcx
je 0x525af
movq %rax, 0x10(%rcx)
jmp 0x52589
movq %rax, (%rbx)
jmp 0x52589
// File: /workspace/github_c_makefile_star2_O2/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)
movslq %esi, %rax
addq $0x38, %rdi
pushq $0x1
popq %rsi
cmpq %rax, %rsi
jge 0x52607
movsd -0x8(%rdi), %xmm1
movsd (%rdx), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x525ec
movsd %xmm1, (%rdx)
movsd (%rcx), %xmm0
movsd (%rdi), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x525fe
movsd %xmm1, (%rcx)
movapd %xmm1, %xmm0
incq %rsi
addq $0x20, %rdi
jmp 0x525d0
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15d
leaq 0x486c0(%rip), %r8      # 0x9ace7
pushq $0x8
popq %rdi
pushq $0x2
popq %rcx
pushq $0x3
popq %r9
movq %rdi, %rsi
movl %r15d, %edx
callq 0x351c3
movq %rax, %r12
leaq 0x30(%rsp), %r13
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x525b4
movsd (%r13), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x28(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r13, %r15
je 0x526ea
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x35cae
movq %r14, %rdi
movl %ebp, %esi
movsd %xmm0, 0x20(%rsp)
callq 0x526fc
movapd %xmm0, %xmm1
testl %ebx, %ebx
je 0x526d2
leaq 0x43f31(%rip), %rdi     # 0x965e1
movsd %xmm1, 0x18(%rsp)
callq 0x4cdcf
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
callq 0x81937
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movq (%r12,%r13,8), %rax
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
incq %r13
jmp 0x5267b
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 %rbx
subq $0x20, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
leaq 0x18(%rdi), %rdx
pushq $-0x1
popq %rax
cmpq %rcx, %rsi
je 0x52742
movsd 0x8(%rsp), %xmm0
ucomisd -0x8(%rdx), %xmm0
jb 0x52736
movsd (%rdx), %xmm0
ucomisd 0x8(%rsp), %xmm0
jae 0x5273f
incq %rcx
addq $0x20, %rdx
jmp 0x52718
movq %rcx, %rax
shlq $0x5, %rax
addq %rax, %rbx
xorpd %xmm0, %xmm0
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x527fc
movsd %xmm0, 0x18(%rsp)
movsd (%rbx), %xmm1
movl 0x8(%rbx), %edi
testl %edi, %edi
je 0x52785
movsd 0x8(%rsp), %xmm0
movsd %xmm1, 0x10(%rsp)
callq 0x34c9a
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
cmpl $0x0, 0xc(%rbx)
je 0x527b7
movq 0x10(%rbx), %rdi
movsd 0x8(%rsp), %xmm0
movsd %xmm1, 0x10(%rsp)
callq 0x5298b
callq 0x4320
movl 0xc(%rbx), %edi
callq 0x34c9a
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
cmpl $0x0, 0x18(%rbx)
je 0x527e9
movq 0x20(%rbx), %rdi
movsd 0x8(%rsp), %xmm0
movsd %xmm1, 0x10(%rsp)
callq 0x5298b
callq 0x4110
movl 0x18(%rbx), %edi
callq 0x34c9a
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
addq $0x28, %rbx
jmp 0x5274d
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movl %edi, %r15d
leaq 0x2c(%rsp), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x52886
movq %rax, %rbx
movl (%r14), %r14d
movl %r15d, %edi
movq %rax, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x52608
movq %rax, %r15
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
shlq $0x5, %r14
cmpq %r12, %r14
je 0x5286e
movups (%rbx,%r12), %xmm0
movups 0x10(%rbx,%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x5295c
addq $0x20, %r12
jmp 0x5284a
movq %rbx, %rdi
callq 0x34ff7
movq %r15, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, (%rsi)
leaq 0x48fdc(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x5293b
movq %rax, %r15
xorl %r14d, %r14d
leaq 0x40(%rsp), %r12
leaq 0x20(%rsp), %r13
movq %r12, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r15, %rdx
callq 0x4120
testq %rax, %rax
je 0x52940
movq %r13, %rdi
movq %r12, %rsi
callq 0x52ebc
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 0x52948
movslq (%rbx), %rdx
incq %rdx
movq %rdx, %rsi
shlq $0x5, %rsi
movq %r14, %rdi
movapd %xmm1, (%rsp)
callq 0x34f30
movq %rax, %r14
movslq (%rbx), %rax
shlq $0x5, %rax
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r14,%rax)
movaps (%rsp), %xmm0
movups %xmm0, 0x10(%r14,%rax)
incl (%rbx)
jmp 0x528c1
xorl %r14d, %r14d
jmp 0x52948
movq %r15, %rdi
callq 0x42a0
movq %r14, %rax
addq $0x7a160, %rsp          # imm = 0x7A160
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x52983
movq 0x28(%rbx), %r14
movq %rbx, %rdi
callq 0x529ea
movq %rbx, %rdi
callq 0x34ff7
movq %r14, %rbx
jmp 0x52965
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
movsd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x529e4
movsd (%rbx), %xmm1
movsd %xmm1, 0x18(%rsp)
movl 0x8(%rbx), %edi
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x34c9a
mulsd 0x18(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x10, %rbx
jmp 0x5299c
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x529fd
movq 0x10(%rbx), %rdi
callq 0x52a0f
cmpl $0x0, 0x18(%rbx)
je 0x52a0d
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x52a0f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x52a2c
movq 0x10(%rdi), %r14
callq 0x34ff7
movq %r14, %rdi
jmp 0x52a19
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, (%rsi)
leaq 0x47ac5(%rip), %r15     # 0x9ad31
leaq 0x20(%rsp), %r12
movq %rsp, %r13
leaq 0x47aba(%rip), %rbp     # 0x9ad35
movq (%r14), %r14
testq %r14, %r14
je 0x532f9
xorpd %xmm0, %xmm0
ucomisd (%r14), %xmm0
movl 0x8(%r14), %eax
movq %r12, %rdi
jbe 0x53299
xorl %esi, %esi
jmp 0x5329c
movq %rbp, %rsi
cmpl $0x2, %eax
jl 0x532c1
movq %r15, %rdx
callq 0x35305
movsd (%r14), %xmm0
movl 0x8(%r14), %edx
movq %r13, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x41b0
jmp 0x532e8
cmpl $0x1, %eax
jne 0x532cf
leaq 0x42bcf(%rip), %rdx     # 0x95e9c
jmp 0x532d1
xorl %edx, %edx
callq 0x35305
movsd (%r14), %xmm0
movq %r13, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x41b0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x41e0
addq $0x10, %r14
jmp 0x5327b
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebx
xorl %r12d, %r12d
testl %esi, %esi
movl $0x0, %r13d
cmovgl %esi, %r13d
movq %rdi, %r15
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
cmpq %r12, %r13
je 0x53398
movq (%r15,%r12,8), %rax
movsd (%rax), %xmm0
movq %r14, %rdi
callq 0x5298b
callq 0x4dd58
movsd 0x429c6(%rip), %xmm1    # 0x95d20
cmpltsd %xmm0, %xmm1
movsd 0x421b9(%rip), %xmm3    # 0x95520
andpd %xmm3, %xmm1
movq (%r15,%r12,8), %rax
movapd (%rsp), %xmm2
movapd %xmm2, %xmm0
addsd %xmm3, %xmm0
cmpneqsd 0x8(%rax), %xmm1
andpd %xmm1, %xmm0
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
incq %r12
movapd %xmm1, (%rsp)
jmp 0x53338
xorpd %xmm0, %xmm0
testl %ebx, %ebx
je 0x533b1
cvtsi2sd %ebx, %xmm0
movapd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
xorl %r12d, %r12d
testl %esi, %esi
cmovlel %r12d, %r14d
movq %rdi, %r15
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
cmpq %r12, %r14
je 0x5344d
movq (%r15,%r12,8), %rax
movsd (%rax), %xmm0
movq %rbx, %rdi
callq 0x5298b
callq 0x4dd58
movq (%r15,%r12,8), %rax
movsd 0x8(%rax), %xmm1
ucomisd 0x42113(%rip), %xmm1    # 0x95520
movsd 0x4210b(%rip), %xmm1    # 0x95520
jne 0x53425
jp 0x53425
ucomisd 0x428f7(%rip), %xmm0    # 0x95d18
jne 0x53435
jp 0x53435
ucomisd %xmm1, %xmm0
jne 0x5342d
jnp 0x53448
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x4160
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r12
jmp 0x533e2
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
xorl %r12d, %r12d
testl %esi, %esi
movl $0x0, %r13d
cmovgl %esi, %r13d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
cmpq %r12, %r13
je 0x534c7
movq (%r15,%r12,8), %rax
movsd (%rax), %xmm0
movq %r14, %rdi
callq 0x5298b
movq (%r15,%r12,8), %rax
movsd 0x8(%rax), %xmm1
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
incq %r12
jmp 0x5348c
xorpd %xmm0, %xmm0
testl %ebx, %ebx
je 0x534e1
cvtsi2sd %ebx, %xmm0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x7a148, %rsp          # imm = 0x7A148
movq %rsi, %rbx
leaq 0x48375(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x535b2
movq %rax, %r14
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x20(%rsp), %r15
leaq 0x18(%rsp), %r13
leaq 0x10(%rsp), %rbp
xorl %r12d, %r12d
movq %r15, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r14, %rdx
callq 0x4120
testq %rax, %rax
je 0x53590
movq %r15, %rdi
leaq 0x45394(%rip), %rsi     # 0x988ea
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x40b0
movsd 0x18(%rsp), %xmm0
movq %rbx, %rdi
callq 0x5298b
subsd 0x10(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incl %r12d
jmp 0x53537
movq %r14, %rdi
callq 0x42a0
testl %r12d, %r12d
je 0x535bc
cvtsi2sd %r12d, %xmm0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x535c0
movsd 0x42d76(%rip), %xmm0    # 0x96330
jmp 0x535c0
xorpd %xmm0, %xmm0
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14d
movl %esi, %r15d
movq %rdi, %r12
leal 0x1(%r14), %r13d
movl %r13d, %edi
movl %r13d, %esi
callq 0x380d3
movq %rdx, %rbp
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
pushq $0x1
popq %rsi
movl %r13d, %edi
callq 0x380d3
movq %rax, (%rsp)
movq %rdx, %rbx
movslq %r14d, %r14
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
movsd 0x41ef5(%rip), %xmm0    # 0x95520
cmpq %r15, %rax
je 0x5368d
xorl %ecx, %ecx
movapd %xmm0, %xmm1
cmpq %r14, %rcx
jg 0x53688
xorl %edx, %edx
movapd %xmm1, %xmm2
cmpq %rdx, %r13
je 0x53666
movq (%rbp,%rcx,8), %rsi
movsd (%rsi,%rdx,8), %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%rsi,%rdx,8)
movq (%r12,%rax,8), %rsi
mulsd (%rsi), %xmm2
incq %rdx
jmp 0x53641
movq (%r12,%rax,8), %rdx
movq (%rbx,%rcx,8), %rsi
movsd 0x8(%rdx), %xmm2
mulsd %xmm1, %xmm2
addsd (%rsi), %xmm2
movsd %xmm2, (%rsi)
mulsd (%rdx), %xmm1
incq %rcx
jmp 0x53636
incq %rax
jmp 0x5362b
callq 0x53230
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x3a9f7
movq (%r12), %rdi
movq 0x8(%r12), %rsi
movq (%rsp), %rdx
movq %rbx, %rcx
callq 0x3933d
movq %rax, %r12
movq %rdx, %r13
xorl %ebp, %ebp
cmpq %r14, %rbp
jg 0x536dc
movq (%r13,%rbp,8), %rax
movsd (%rax), %xmm0
movq %r15, %rdi
movl %ebp, %esi
callq 0x52528
incq %rbp
jmp 0x536bf
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3929f
movq %r12, %rdi
movq %r13, %rsi
callq 0x3929f
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x3929f
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0x523b8
movq %rax, %r12
movl (%r15), %r15d
movq %rax, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x535d2
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x534ef
movsd %xmm0, (%rbx)
movq %r12, %rdi
movl %r15d, %esi
callq 0x34fc3
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_O2/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 0x523b8
movq %rax, %r15
movl (%r14), %r14d
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x537d7
movq %rax, %r12
movq %r15, %rdi
movl %r14d, %esi
movq %rax, %rdx
callq 0x5330b
movsd %xmm0, (%rbx)
movq %r15, %rdi
movl %r14d, %esi
callq 0x34fc3
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/poly.c
// Function: polyfitcls
Polynomptr polyfitcls(double** data, int datasize, int degree)
{
	/*!Last Changed 26.01.2005*/
	int i, j, *array;
	double random_value, o, y, eta, *deltaw, update;
	Polynomptr p = create_polynom();
	Polynodeptr node;
 for (i = 0; i <= degree; i++)
	 {
		 random_value = produce_random_value(-0.01, 0.01);
		 add_polynode_to_polynom(p, i, random_value);
	 }
	eta = get_parameter_f("learning_rate");
	deltaw = safecalloc((degree + 1), sizeof(double), "polyfitcls", 11);
	for (j = 0; j < get_parameter_i("perceptronrun"); j++)
	 {
			array = random_array(datasize);
			for (i = 0; i < datasize; i++)
			 {
				 o = polynom_value(p, data[array[i]][0]);
					y = sigmoid(o);
     node = p->start;
					while (node)
					 {
						 update = (eta * (data[array[i]][1] - y) * fpow(data[array[i]][0], node->power) + get_parameter_f("alpha") * deltaw[node->power]);
						 node->coefficient += update;
							deltaw[node->power] = update;
						 node = node->next;
					 }
			 }
			safe_free(array);
			eta *= get_parameter_f("etadecrease");
	 }
	safe_free(deltaw);
 return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movl %esi, 0xc(%rsp)
movq %rdi, %r15
xorl %r12d, %r12d
callq 0x53230
movq %rax, 0x10(%rsp)
cmpl %ebp, %r12d
jg 0x53827
movsd 0x425b8(%rip), %xmm0    # 0x95dc0
movsd 0x425b8(%rip), %xmm1    # 0x95dc8
callq 0x35cae
movq 0x10(%rsp), %rdi
movl %r12d, %esi
callq 0x52528
incl %r12d
jmp 0x537fb
leaq 0x420aa(%rip), %rdi     # 0x958d8
callq 0x4cdcf
movsd %xmm0, 0x18(%rsp)
incl %ebp
movslq %ebp, %rdi
leaq 0x4751b(%rip), %rdx     # 0x9ad60
pushq $0x8
popq %rsi
pushq $0xb
popq %rcx
callq 0x35067
xorl %ebx, %ebx
movl 0xc(%rsp), %ecx
testl %ecx, %ecx
movl $0x0, %edx
cmovgl %ecx, %edx
movq %rdx, 0x28(%rsp)
movq %rax, %r12
leaq 0x42161(%rip), %rbp     # 0x959d0
leaq 0x42070(%rip), %rdi     # 0x958e6
callq 0x4cd35
cmpl %eax, %ebx
jge 0x53975
movq %rbx, 0x20(%rsp)
movl 0xc(%rsp), %edi
callq 0x35cf7
movq %rax, %r13
xorl %ebx, %ebx
cmpq 0x28(%rsp), %rbx
je 0x53945
movslq (%r13,%rbx,4), %rax
movq (%r15,%rax,8), %rax
movsd (%rax), %xmm0
movq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x5298b
callq 0x4dd58
movsd %xmm0, 0x30(%rsp)
movq (%r14), %r14
testq %r14, %r14
je 0x5393d
movslq (%r13,%rbx,4), %rax
movq (%r15,%rax,8), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
subsd 0x30(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
movsd %xmm1, 0x40(%rsp)
movl 0x8(%r14), %edi
callq 0x34c9a
movsd %xmm0, 0x38(%rsp)
movq %rbp, %rdi
callq 0x4cdcf
movslq 0x8(%r14), %rax
mulsd (%r12,%rax,8), %xmm0
movsd 0x38(%rsp), %xmm1
mulsd 0x40(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd (%r14), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%r14)
movsd %xmm1, (%r12,%rax,8)
addq $0x10, %r14
jmp 0x538c6
incq %rbx
jmp 0x53896
movq %r13, %rdi
callq 0x34ff7
leaq 0x41f78(%rip), %rdi     # 0x958cc
callq 0x4cdcf
movsd 0x18(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
movq 0x20(%rsp), %rbx
incl %ebx
jmp 0x5386f
movq %r12, %rdi
callq 0x34ff7
movq 0x10(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %edi, %r14d
movq %rsi, %rdi
callq 0x530be
movq %rax, %r15
leaq 0x4738d(%rip), %r8      # 0x9ad4f
pushq $0x8
popq %rdi
pushq $0x2
popq %rcx
pushq $0x4
popq %r9
movq %rdi, %rsi
movl %r14d, %edx
callq 0x351c3
movq %rax, %r12
xorl %ebp, %ebp
testl %r14d, %r14d
cmovlel %ebp, %r14d
leaq 0x42bf7(%rip), %r13     # 0x965e1
cmpq %rbp, %r14
je 0x53a53
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x35cae
movq %r15, %rdi
movsd %xmm0, 0x20(%rsp)
callq 0x5298b
movapd %xmm0, %xmm1
testl %ebx, %ebx
je 0x53a3b
movq %r13, %rdi
movsd %xmm1, 0x18(%rsp)
callq 0x4cdcf
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
callq 0x81937
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movq (%r12,%rbp,8), %rax
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
incq %rbp
jmp 0x539ea
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
movq %rsi, %r14
leaq 0x47e0f(%rip), %rsi     # 0x9b891
callq 0x40f0
testq %rax, %rax
je 0x53afd
movq %rax, %r15
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
movq %rsp, %r12
leaq 0x45669(%rip), %rbp     # 0x9910b
cmpq %r13, %rbx
je 0x53af5
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x35305
movq (%r14,%r13,8), %rax
movsd (%rax), %xmm0
movq %r15, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
movq %r12, %rdi
leaq 0x44b93(%rip), %rsi     # 0x98665
movq %rbp, %rdx
callq 0x35305
movq (%r14,%r13,8), %rax
movsd 0x8(%rax), %xmm0
movq %r15, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
incq %r13
jmp 0x53aa2
movq %r15, %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_O2/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:
movq 0x8(%rsp), %rax
movsd 0x40dc1(%rip), %xmm0    # 0x95cf8
testq %rdi, %rdi
je 0x54fb1
movl $0x61e1, %ecx           # imm = 0x61E1
xorl %edx, %edx
movq 0x78926(%rip), %rsi     # 0xcd870
movslq 0x1bc(%rsi), %r8
cmpq %r8, %rdx
jge 0x54fab
movl (%rsi,%rcx,8), %esi
cmpl $0x2, %esi
je 0x54f88
cmpl $0x1, %esi
je 0x54f75
testl %esi, %esi
jne 0x54fa2
movq (%rdi), %rsi
cmpl $0x75bcd15, (%rsi,%rdx,8) # imm = 0x75BCD15
je 0x54f7e
jmp 0x54fa2
movq (%rdi), %rsi
cmpl $-0x1, (%rsi,%rdx,8)
jne 0x54fa2
movl (%rax,%rdx,8), %r8d
movl %r8d, (%rsi,%rdx,8)
jmp 0x54fa2
movq (%rdi), %rsi
movsd (%rsi,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x54fa2
jp 0x54fa2
movsd (%rax,%rdx,8), %xmm1
movsd %xmm1, (%rsi,%rdx,8)
incq %rdx
addq $0x68, %rcx
jmp 0x54f43
movq 0x10(%rdi), %rdi
jmp 0x54f37
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, (%rsp)
cmpl $0x1, %ecx
jg 0x54fe0
leaq 0x49688(%rip), %rdi     # 0x9e655
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %r15
movq 0x78889(%rip), %rdi     # 0xcd878
movq %r15, %rsi
callq 0x13da6
movq %rax, 0x78872(%rip)     # 0xcd870
testq %rax, %rax
je 0x550c9
leaq 0x2dae22(%rip), %rdx    # 0x32fe30
movq %rax, %rdi
movq %r14, %rsi
callq 0x550f7
testl %eax, %eax
je 0x550e8
leaq 0x2dae08(%rip), %rdi    # 0x32fe30
movl %ebp, %esi
callq 0x2cdc7
movq %rax, %r14
movl %ebp, %r12d
xorl %r13d, %r13d
pushq $-0x1
popq %r15
cmpq %r13, %r12
je 0x55096
movq 0x78828(%rip), %rdi     # 0xcd870
leaq 0x1(%r13), %rbx
pushq $0x4
popq %rsi
movl %r15d, %edx
movl %r15d, %ecx
movl %ebx, %r8d
callq 0x551d4
movq %rax, %rdi
leaq 0x4682a(%rip), %rsi     # 0x9b891
callq 0x40f0
movq %rax, %rbp
movq (%rsp), %rax
movsbl (%rax), %esi
movq 0x787f3(%rip), %rdx     # 0xcd870
movq (%r14,%r13,8), %rcx
movq %rbp, %rdi
callq 0x2c563
movq %rbp, %rdi
callq 0x42a0
movq %rbx, %r13
jmp 0x5503c
andq $0x0, 0x2dad92(%rip)    # 0x32fe30
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x550b3
movq (%r14,%rbx,8), %rdi
callq 0x2c010
incq %rbx
jmp 0x550a0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
leaq 0x467c3(%rip), %rdi     # 0x9b893
movq %r15, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4030
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x46765(%rip), %rsi     # 0x9b87f
movq %r12, %rdi
callq 0x40f0
testq %rax, %rax
je 0x551ad
movq %rax, %r15
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
leaq 0x467a7(%rip), %r13     # 0x9b8e3
xorl %ebp, %ebp
movq %r12, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r15, %rdx
callq 0x4120
testq %rax, %rax
je 0x55187
movq %r13, %rdi
callq 0x4cff1
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x16e32
testq %rax, %rax
je 0x5513e
leaq 0x10(%rbx), %rcx
testq %rbx, %rbx
cmoveq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movl %ebp, 0x18(%rax)
incl %ebp
movq %rax, %rbx
jmp 0x5513e
movq %r15, %rdi
callq 0x42a0
pushq $0x1
popq %rbp
cmpl $0x0, 0x78113(%rip)     # 0xcd2ac
je 0x551c0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq %rdi, %rsi
callq 0x54edc
jmp 0x551c0
leaq 0x41d4d(%rip), %rdi     # 0x96f01
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_O2/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
andl $0x0, 0x2daa96(%rip)    # 0x32fe70
leaq 0x464b0(%rip), %rsi     # 0x9b891
movq %rcx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x55474
movq %rax, %rbx
movq 0x7847c(%rip), %rdi     # 0xcd878
movq %r12, %rsi
callq 0x13da6
movq %rax, 0x78465(%rip)     # 0xcd870
testq %rax, %rax
je 0x55480
leaq 0x2daa19(%rip), %rdx    # 0x32fe30
movq %rax, %rdi
movq %r15, %rsi
callq 0x550f7
testl %eax, %eax
je 0x55474
callq 0x56f57
movsbl (%r14), %esi
movq 0x7843a(%rip), %rdx     # 0xcd870
movq 0x2da9f3(%rip), %rcx    # 0x32fe30
movq %rbx, %rdi
callq 0x2c563
pushq $0x1
popq %rdi
callq 0x5549c
movq 0x2da9dc(%rip), %rdi    # 0x32fe30
callq 0x2c010
andq $0x0, 0x2da9cf(%rip)    # 0x32fe30
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 0x4640c(%rip), %rdi     # 0x9b893
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_O2/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, 0x354afe(%rip)    # 0x3a9fa4
je 0x554b4
movq 0x783c1(%rip), %rdi     # 0xcd870
callq 0x11d5c
cmpl $0x0, 0x2da9b5(%rip)    # 0x32fe70
je 0x554e2
testl %ebx, %ebx
je 0x554d9
movq 0x354ae0(%rip), %rdi    # 0x3a9fa8
callq 0x34ff7
movq 0x354b04(%rip), %rdi    # 0x3a9fd8
callq 0x34ff7
cmpl $0x0, 0x354ac4(%rip)    # 0x3a9fa4
je 0x554e4
popq %rbx
retq
movq 0x78385(%rip), %rdi     # 0xcd870
popq %rbx
jmp 0x16cc6