LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/partition.c
// Function: get_two_class_partition_for_one_vs_all
Partition get_two_class_partition_for_one_vs_all(Datasetptr d, int positive)
{
 /*!Last Changed 18.02.2008*/
 Partition result;
 int i;
 result.classes = (int *)safemalloc(d->classno * sizeof(int), "get_two_class_partition_for_one_vs_all", 3);
 for (i = 0; i < d->classno; i++)
   result.classes[i] = i;
 result.count = d->classno;
 result.assignments = (int *)safemalloc(d->classno * sizeof(int), "get_two_class_partition_for_one_vs_all", 7);
 for (i = 0; i < d->classno; i++)
   if (i != positive)
     result.assignments[i] = RIGHT;
   else
     result.assignments[i] = LEFT;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
leaq 0x6cf96(%rip), %rsi     # 0xe7620
movl $0x3, %edx
callq 0x52d70
movq -0x18(%rbp), %rdi
movq %rax, (%rdi)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x7a6ca
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %edx
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7a6a2
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
leaq 0x6cf35(%rip), %rsi     # 0xe7620
movl $0x7, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x7a750
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x7a730
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
jmp 0x7a743
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x7a745
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7a707
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/partition.c
// Function: get_two_class_partition
Partition get_two_class_partition()
{
	/*!Last Changed 21.06.2005*/
 Partition result;
 result.classes = (int *)safemalloc(2 * sizeof(int), "get_initial_partition", 2);
	result.classes[0] = 0;
	result.classes[1] = 1;
 result.count = 2;
 result.assignments = (int *)safemalloc(2 * sizeof(int), "get_initial_partition", 6);
 result.assignments[0] = LEFT;
 result.assignments[1] = RIGHT;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x8, %edi
leaq 0x69da6(%rip), %rsi     # 0xe4522
movl $0x2, %edx
callq 0x52d70
movq -0x10(%rbp), %rdi
movq %rax, (%rdi)
movq (%rdi), %rax
movl $0x0, (%rax)
movq (%rdi), %rax
movl $0x1, 0x4(%rax)
movl $0x2, 0x10(%rdi)
movl $0x8, %edi
leaq 0x69d6f(%rip), %rsi     # 0xe4522
movl $0x6, %edx
callq 0x52d70
movq -0x10(%rbp), %rdi
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rdi)
movq 0x8(%rdi), %rcx
movl $0x0, (%rcx)
movq 0x8(%rdi), %rcx
movl $0x1, 0x4(%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/partition.c
// Function: all_same_side
BOOLEAN all_same_side(Partition p)
{
/*!Last Changed 16.04.2003*/
	int i, sum = 0;
	for (i = 0; i < p.count; i++)
		 sum += p.assignments[i];
	if ((sum == p.count) || (sum == 0))
		 return BOOLEAN_TRUE;
	return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movq -0x18(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x7a836
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x7a80a
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
je 0x7a848
cmpl $0x0, -0xc(%rbp)
jne 0x7a851
movl $0x1, -0x4(%rbp)
jmp 0x7a858
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/partition.c
// Function: find_class_assignments
int* find_class_assignments(Partition p)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 16.03.2003*/
	int *classassignments, max = -1, i;
 for (i = 0; i < p.count; i++)
   if (p.classes[i] > max)
     max = p.classes[i];
 classassignments = (int *) safemalloc((max + 1) * sizeof(int), "find_class_assignments", 5);
 for (i = 0; i < p.count; i++)
   classassignments[p.classes[i]] = p.assignments[i];
	return classassignments;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x7a8bb
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jle 0x7a8ae
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0x7a8b0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7a87e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
leaq 0x6cd78(%rip), %rsi     # 0xe7647
movl $0x5, %edx
callq 0x52d70
movq %rax, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x7a91c
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movslq -0x10(%rbp), %rdx
movl (%rax,%rdx,4), %edx
movq -0x8(%rbp), %rax
movq (%rcx), %rcx
movslq -0x10(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7a8e4
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/partition.c
// Function: increment_partition
void increment_partition(Partition* p)
{
/*!Last Changed 04.02.2003*/
	int i = (*p).count - 1;
	while (i >= 0)
	{
		(*p).assignments[i] = 1 - (*p).assignments[i];
		if ((*p).assignments[i] == LEFT)
			 break;
  else
		  i--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x7a98d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl $0x1, %edx
subl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x7a982
jmp 0x7a98d
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7a945
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/partition.c
// Function: create_copy
Partition create_copy(Partition p)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 26.01.2003*/
 Partition result;
 int i;
 result.count = p.count;
 result.assignments = (int *)safemalloc((p.count)*sizeof(int), "create_copy", 4);
 for (i = 0; i < p.count; i++)
   result.assignments[i] = p.assignments[i];
 result.classes = (int *)safemalloc(p.count*sizeof(int), "create_copy", 7);
 for (i = 0; i<p.count; i++)
   result.classes[i] = p.classes[i];
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, 0x10(%rdi)
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
leaq 0x6cc9e(%rip), %rsi     # 0xe765e
movl $0x4, %edx
callq 0x52d70
movq -0x10(%rbp), %rdi
movq %rax, 0x8(%rdi)
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x7aa0e
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x4(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7a9d9
movq -0x18(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
leaq 0x6cc3d(%rip), %rsi     # 0xe765e
movl $0x7, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x7aa6f
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x4(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7aa3c
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/perceptron.c
// Function: softmax
void softmax(double *myarray, int size)
{
 int i;
 double sum = 0.0;
 for (i = 0; i < size; i++)
  {
   myarray[i] = safeexp(myarray[i]);
   sum += myarray[i];
  }
 for (i = 0; i < size; i++)
   myarray[i] /= sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7ab67
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x52a40
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7ab1e
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7ab9c
movsd -0x18(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7ab6e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/perceptron.c
// Function: two_dimensional_initialize
double **two_dimensional_initialize(int dim1, int dim2, double constant)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 int i,j;
 double **myarray;
 myarray = (double **)safemalloc_2d(sizeof(double *), sizeof(double), dim1, dim2, "two_dimensional_initialize", 3);
 for (i = 0; i < dim1; i++)
   for (j = 0; j < dim2; j++)
     myarray[i][j] = constant * ((double) produce_random_value(-1, 1));
 return myarray;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
movl $0x8, %esi
leaq 0x6ca95(%rip), %r8      # 0xe766a
movl $0x3, %r9d
movq %rsi, %rdi
callq 0x53120
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x7ac5d
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x7ac50
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x67e31(%rip), %xmm0    # 0xe2a48
movsd 0x673f9(%rip), %xmm1    # 0xe2018
callq 0x545a0
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7abfd
jmp 0x7ac52
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7abee
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/perceptron.c
// Function: one_dimensional_initialize
double *one_dimensional_initialize(int dim, double constant)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 int i;
 double *myarray;
 myarray = safemalloc(dim*sizeof(double), "one_dimensional_initialize", 3);
 for (i = 0; i < dim; i++)
   myarray[i] = constant * ((double) produce_random_value(-1, 1));
 return myarray;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x6c9f6(%rip), %rsi     # 0xe7685
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x7acef
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x67d8a(%rip), %xmm0    # 0xe2a48
movsd 0x67352(%rip), %xmm1    # 0xe2018
callq 0x545a0
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7aca4
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/plot.c
// Function: solve_sigmoid
void solve_sigmoid(double* observations[2], int obscount, double* besta, double* bestb)
{
 /*!Last Changed 27.10.2004*/
 int i, j, k;
 double sum, a, b, adiff, bdiff, power, bestsum = +LONG_MAX;
 adiff = 10.0 / DIVISIONS;
 bdiff = 10.0 / DIVISIONS;
 for (i = 0; i < DIVISIONS; i++)
   for (j = 0; j < DIVISIONS; j++)
    {
     sum = 0;
     a = -5 + adiff * i;
     b = -5 + bdiff * j;
     for (k = 0; k < obscount; k++)
      {
       power = observations[1][k] - sigmoid(a * observations[0][k] + b);
       sum += power * power;
      }
     if (sum < bestsum)
      {
       bestsum = sum;
       *besta = a;
       *bestb = b;
      }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movsd 0x68291(%rip), %xmm0    # 0xe2fb0
movsd %xmm0, -0x68(%rbp)
movsd 0x6c974(%rip), %xmm0    # 0xe76a0
movsd %xmm0, -0x50(%rbp)
movsd 0x6c967(%rip), %xmm0    # 0xe76a0
movsd %xmm0, -0x58(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x64, -0x24(%rbp)
jge 0x7ae7e
movl $0x0, -0x28(%rbp)
cmpl $0x64, -0x28(%rbp)
jge 0x7ae6e
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x50(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x6c92a(%rip), %xmm1    # 0xe76a8
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x58(%rbp), %xmm0
cvtsi2sdl -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x6c90b(%rip), %xmm1    # 0xe76a8
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7ae2a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x48(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x7aab0
movaps %xmm0, %xmm1
movsd -0x70(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movsd -0x60(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7adad
movsd -0x38(%rbp), %xmm1
movsd -0x68(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x7ae5e
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x48(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x7ae60
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7ad56
jmp 0x7ae70
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7ad45
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x673d5(%rip), %rdi     # 0xe7308
callq 0x79440
cmpl $0x0, %eax
jne 0x7ff44
movb $0x0, %al
callq 0x41a40
leaq 0x36213d(%rip), %rax    # 0x3e2088
movl $0x1, 0x78(%rax)
leaq 0x36212f(%rip), %rax    # 0x3e2088
movl 0xec(%rax), %eax
movl %eax, -0x1c(%rbp)
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x850b9(%rip), %rax     # 0x105030
movb (%rax,%rcx), %al
movb %al, -0x1e(%rbp)
movb $0x0, -0x1d(%rbp)
leaq -0x28(%rbp), %rdi
leaq 0x3620fc(%rip), %rax    # 0x3e2088
movl 0xec(%rax), %edx
addl $0x1, %edx
leaq 0x677e5(%rip), %rsi     # 0xe7781
movb $0x0, %al
callq 0x4170
movb -0x1e(%rbp), %al
leaq -0x28(%rbp), %rsi
movsbl %al, %edi
callq 0x3efa0
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x7fca0
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8003a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x1e(%rbp), %rsi
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd 0x8502d(%rip), %xmm2    # 0x105040
movsd 0x8502d(%rip), %xmm3    # 0x105048
movsd -0x48(%rbp), %xmm4
movsd -0x40(%rbp), %xmm5
movl $0x1, %edi
callq 0x3f100
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7ffca
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movq -0x10(%rbp), %rdi
callq 0x52e80
movb $0x0, %al
callq 0x42280
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x7a160, %rsp          # imm = 0x7A160
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50f90
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x67627(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x7a148(%rbp)
cmpq $0x0, -0x7a148(%rbp)
jne 0x80ba2
movq $0x0, -0x8(%rbp)
jmp 0x80c5b
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl $0x8, %esi
movl $0x2, %ecx
leaq 0x66c2f(%rip), %r8      # 0xe77e8
movl $0x6, %r9d
movq %rsi, %rdi
callq 0x53120
movq %rax, -0x7a150(%rbp)
movl $0x0, -0x7a154(%rbp)
leaq -0x7a140(%rbp), %rdi
movq -0x7a148(%rbp), %rdx
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
cmpq $0x0, %rax
je 0x80c44
leaq -0x7a140(%rbp), %rdi
movq -0x7a150(%rbp), %rax
movslq -0x7a154(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x7a150(%rbp), %rax
movslq -0x7a154(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
addq $0x8, %rcx
leaq 0x6486e(%rip), %rsi     # 0xe549a
movb $0x0, %al
callq 0x4090
movl -0x7a154(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7a154(%rbp)
jmp 0x80bd8
movq -0x7a148(%rbp), %rdi
callq 0x4250
movq -0x7a150(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x7a160, %rsp          # imm = 0x7A160
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
callq 0x82340
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x66b58(%rip), %rsi     # 0xe77f6
movl $0x6, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x80d18
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x80d0b
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x8(%rax), %eax
cmpl -0x28(%rbp), %eax
jle 0x80d0b
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x80d0d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x80cb3
jmp 0x80d1a
cmpl $0x0, -0x28(%rbp)
jl 0x80ddf
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x80db1
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x80da4
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x8(%rax), %eax
cmpl -0x28(%rbp), %eax
jne 0x80da4
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x80da6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x80d3a
cmpl $0x0, -0x2c(%rbp)
jle 0x80dd1
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %esi
movsd -0x38(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0x80e00
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x80d1a
movq -0x20(%rbp), %rdi
callq 0x52e80
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movl $0x18, %edi
leaq 0x66a35(%rip), %rsi     # 0xe7855
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x80e77
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x80f2d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0x80ea6
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x80eaf
jmp 0x80ec5
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x80e8a
cmpq $0x0, -0x28(%rbp)
je 0x80f11
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x80ee3
movq -0x20(%rbp), %rdi
callq 0x52e80
jmp 0x80f2d
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x30(%rbp)
je 0x80f04
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x80f0f
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x80f2d
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x81010
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x80fc6
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0x18(%rax), %xmm0
movq -0x20(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x81000
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0x18(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x81002
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x80f7c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x4(%rbp), %edx
movl $0x8, %esi
movl $0x2, %ecx
leaq 0x667be(%rip), %r8      # 0xe7807
movl $0x3, %r9d
movq %rsi, %rdi
callq 0x53120
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x80f40
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x8111d
movsd -0x40(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
callq 0x545a0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movsd -0x28(%rbp), %xmm0
callq 0x81130
movsd %xmm0, -0x30(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x810e4
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
leaq 0x6215e(%rip), %rdi     # 0xe3221
callq 0x79040
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
callq 0xc4710
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x81076
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x811b1
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
ucomisd 0x10(%rax), %xmm0
jb 0x811a4
movsd -0x18(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x811a4
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x811b1
jmp 0x811a6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8115a
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x812a6
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x81204
movsd -0x18(%rbp), %xmm0
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x52840
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x81245
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x81500
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
callq 0x42c0
movq -0x28(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x52840
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x81286
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x81500
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
callq 0x40e0
movq -0x28(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x52840
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x811c7
movsd -0x38(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x81360
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %edi
movq -0x30(%rbp), %rsi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x81020
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x81349
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x814b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x81300
movq -0x30(%rbp), %rdi
callq 0x52e80
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x7a190, %rsp          # imm = 0x7A190
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x66e16(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x813ad
movq $0x0, -0x8(%rbp)
jmp 0x8149b
jmp 0x813af
leaq -0x7a170(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
cmpq $0x0, %rax
je 0x8148a
leaq -0x7a170(%rbp), %rsi
leaq -0x7a190(%rbp), %rdi
callq 0x81db0
movq -0x7a190(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x7a188(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x7a180(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x7a178(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x81423
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8149b
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x5, %rsi
movq -0x18(%rbp), %rax
movl (%rax), %edx
addl $0x1, %edx
callq 0x52d10
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x813af
movq -0x20(%rbp), %rdi
callq 0x4250
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x7a190, %rsp          # imm = 0x7A190
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x814f2
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x81580
movq -0x8(%rbp), %rdi
callq 0x52e80
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x814c3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x81571
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x52840
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x81524
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x815a3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x815c0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x815ba
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x815c0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x815fd
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52e80
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x815d7
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/poly.c
// Function: create_polynom
Polynomptr create_polynom()
{
	/*!Last Changed 02.02.2004 added create_polynom*/
 Polynomptr result = (Polynomptr)safemalloc(sizeof(Polynom), "create_polynom", 1);
 result->start = NULL;
 result->end = NULL;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
leaq 0x654ee(%rip), %rsi     # 0xe7842
movl $0x1, %edx
callq 0x52d70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x82643
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
callq 0x81500
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x7aab0
movsd 0x603da(%rip), %xmm1    # 0xe29b8
ucomisd %xmm1, %xmm0
jbe 0x825f3
movsd 0x5fa2c(%rip), %xmm0    # 0xe2018
movsd %xmm0, -0x40(%rbp)
jmp 0x825fb
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
ucomisd -0x40(%rbp), %xmm0
jne 0x82621
jp 0x82621
jmp 0x82633
movsd 0x5f9ef(%rip), %xmm0    # 0xe2018
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x82635
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x825a2
cmpl $0x0, -0x14(%rbp)
jne 0x82653
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x82666
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x82769
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
callq 0x81500
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x7aab0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x8(%rax), %xmm0
movsd 0x5f924(%rip), %xmm1    # 0xe2018
ucomisd %xmm1, %xmm0
jne 0x82724
jp 0x82724
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x8270e
jp 0x8270e
jmp 0x82724
movsd -0x30(%rbp), %xmm0
callq 0x4120
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x82759
movsd -0x30(%rbp), %xmm0
movsd 0x5f8e7(%rip), %xmm1    # 0xe2018
ucomisd %xmm1, %xmm0
jne 0x8273b
jp 0x8273b
jmp 0x82757
movsd 0x5f8d5(%rip), %xmm0    # 0xe2018
subsd -0x30(%rbp), %xmm0
callq 0x4120
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x82759
jmp 0x8275b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x826a2
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8280f
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax), %xmm0
callq 0x81500
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
subsd -0x38(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x827a2
cmpl $0x0, -0x14(%rbp)
jne 0x8281f
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x82832
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x7a170, %rsp          # imm = 0x7A170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x7a158(%rbp)
movl $0x0, -0x7a164(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x65933(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x82895
movsd 0x60725(%rip), %xmm0    # 0xe2fb0
movsd %xmm0, -0x8(%rbp)
jmp 0x82973
jmp 0x82897
leaq -0x7a140(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
cmpq $0x0, %rax
je 0x8293e
leaq -0x7a140(%rbp), %rdi
leaq 0x62bd6(%rip), %rsi     # 0xe549a
leaq -0x7a148(%rbp), %rdx
leaq -0x7a150(%rbp), %rcx
movb $0x0, %al
callq 0x4090
movq -0x18(%rbp), %rdi
movsd -0x7a148(%rbp), %xmm0
callq 0x81500
movsd %xmm0, -0x7a160(%rbp)
movsd -0x7a160(%rbp), %xmm0
subsd -0x7a150(%rbp), %xmm0
movsd -0x7a160(%rbp), %xmm2
subsd -0x7a150(%rbp), %xmm2
movsd -0x7a158(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x7a158(%rbp)
movl -0x7a164(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7a164(%rbp)
jmp 0x82897
movq -0x20(%rbp), %rdi
callq 0x4250
cmpl $0x0, -0x7a164(%rbp)
jne 0x8295a
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x82973
movsd -0x7a158(%rbp), %xmm0
cvtsi2sdl -0x7a164(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x7a170, %rsp          # imm = 0x7A170
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x80b50
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x82990
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x82840
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x52e20
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x80b50
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x82ca0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x82580
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x52e20
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)