LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/part.c
// Function: learn_ruleset_part
Ruleset learn_ruleset_part(Instanceptr* instances, Instanceptr* cvdata)
{
 int* counts;
 Instanceptr covered = NULL, cvcovered = NULL;
 Ruleset result;
 Decisionruleptr newrule;
 Decisionnodeptr rootnode;
 empty_ruleset(&result);
 counts = find_class_counts(*instances);
 result.defaultclass = find_max_in_list(counts, current_dataset->classno);
 safe_free(counts);
 while (data_size(*instances) > 0)
  {
   rootnode = createnewnode(NULL, 1);
   rootnode->instances = *instances;
   create_partial_tree(rootnode, *cvdata);
   newrule = extract_rule_from_partial_tree(rootnode);
   add_rule(&result, newrule);
   *instances = NULL;
   accumulate_instances_tree(instances, rootnode);
   deallocate_tree(rootnode);
   safe_free(rootnode);
   remove_covered(instances, &covered, newrule);
   remove_covered(cvdata, &cvcovered, newrule);
  }
 merge_instancelist(instances, covered);
 merge_instancelist(cvdata, cvcovered);
 return result; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
callq 0x7aa63
movq (%r15), %rdi
callq 0x115e1
movq %rax, %r12
leaq 0x7e653(%rip), %rax     # 0xd2870
movq (%rax), %rax
movl 0x10(%rax), %esi
movq %r12, %rdi
callq 0x37504
movl %eax, 0x14(%rbx)
movq %r12, %rdi
callq 0x39194
movq (%r15), %rdi
callq 0x2fa14
testl %eax, %eax
jle 0x542e8
leaq 0x8(%rsp), %rbp
xorl %edi, %edi
movl $0x1, %esi
callq 0x1c996
movq %rax, %r12
movq (%r15), %rax
movq %rax, 0x20(%r12)
movq (%r14), %rsi
movq %r12, %rdi
callq 0x53ff0
movl $0x0, 0x4(%rsp)
movq %r12, %rdi
leaq 0x4(%rsp), %rsi
callq 0x53dd0
movq %rax, %rdi
callq 0x7a629
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7b0fb
movq $0x0, (%r15)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1c787
movq %r12, %rdi
callq 0x1cfd1
movq %r12, %rdi
callq 0x39194
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
callq 0x9c951
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x9c951
movq (%r15), %rdi
callq 0x2fa14
testl %eax, %eax
jg 0x5424b
movq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x2fd59
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2fd59
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x10(%rsi), %rdi
shlq $0x2, %rdi
leaq 0x537e6(%rip), %rsi     # 0xa7b15
movl $0x3, %edx
callq 0x390f5
movq %rax, (%rbx)
movl 0x10(%r14), %ecx
testl %ecx, %ecx
jle 0x54355
xorl %edx, %edx
movl %edx, (%rax,%rdx,4)
incq %rdx
movslq 0x10(%r14), %rcx
cmpq %rcx, %rdx
jl 0x54346
movl %ecx, 0x10(%rbx)
movslq %ecx, %rdi
shlq $0x2, %rdi
leaq 0x537af(%rip), %rsi     # 0xa7b15
movl $0x7, %edx
callq 0x390f5
movq %rax, 0x8(%rbx)
cmpl $0x0, 0x10(%r14)
jle 0x54397
movl %ebp, %ecx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rdx, %rcx
setne %sil
movl %esi, (%rax,%rdx,4)
incq %rdx
movslq 0x10(%r14), %rsi
cmpq %rsi, %rdx
jl 0x5437f
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x50564(%rip), %r14     # 0xa4912
movl $0x8, %edi
movq %r14, %rsi
movl $0x2, %edx
callq 0x390f5
movq %rax, (%rbx)
movabsq $0x100000000, %r15      # imm = 0x100000000
movq %r15, (%rax)
movl $0x2, 0x10(%rbx)
movl $0x8, %edi
movq %r14, %rsi
movl $0x6, %edx
callq 0x390f5
movq %rax, 0x8(%rbx)
movq %r15, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movslq 0x18(%rsp), %rax
testq %rax, %rax
jle 0x5441d
leaq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdx
xorl %esi, %esi
xorl %ecx, %ecx
addl (%rdx,%rsi,4), %ecx
incq %rsi
cmpq %rsi, %rax
jne 0x54410
jmp 0x5441f
xorl %ecx, %ecx
cmpl %eax, %ecx
sete %al
testl %ecx, %ecx
sete %cl
orb %al, %cl
movzbl %cl, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0x20(%rsp), %r14
movslq 0x10(%r14), %rbx
testq %rbx, %rbx
jle 0x54463
movq (%r14), %rax
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movl (%rax,%rcx,4), %edx
cmpl %edi, %edx
cmovgl %edx, %edi
incq %rcx
cmpq %rcx, %rbx
jne 0x5444b
incl %edi
shlq $0x2, %rdi
jmp 0x54465
xorl %edi, %edi
leaq 0x536d0(%rip), %rsi     # 0xa7b3c
movl $0x5, %edx
callq 0x390f5
testl %ebx, %ebx
jle 0x54496
movq (%r14), %rcx
movq 0x8(%r14), %rdx
xorl %esi, %esi
movl (%rdx,%rsi,4), %edi
movslq (%rcx,%rsi,4), %r8
movl %edi, (%rax,%r8,4)
incq %rsi
cmpq %rsi, %rbx
jne 0x54483
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0x10(%rdi), %eax
testl %eax, %eax
jle 0x544bd
movq 0x8(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %edx
leal -0x1(%rdx), %esi
negl %esi
movl %esi, -0x4(%rcx,%rax,4)
decq %rax
decl %edx
jne 0x544a1
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movslq 0x10(%r12), %r15
movl %r15d, 0x10(%rdi)
leaq (,%r15,4), %r14
leaq 0x5366d(%rip), %rsi     # 0xa7b53
movq %r14, %rdi
movl $0x4, %edx
callq 0x390f5
movq %rax, 0x8(%rbx)
testq %r15, %r15
jle 0x54511
movq 0x8(%r12), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %r15
jne 0x54503
leaq 0x5363b(%rip), %rsi     # 0xa7b53
movq %r14, %rdi
movl $0x7, %edx
callq 0x390f5
movq %rax, (%rbx)
testl %r15d, %r15d
jle 0x54541
movq (%r12), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %r15
jne 0x54533
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
xorpd %xmm1, %xmm1
testl %esi, %esi
jle 0x545cd
xorl %r15d, %r15d
movsd %xmm1, (%rsp)
movsd (%rbx,%r15,8), %xmm0
callq 0x38e72
movsd (%rsp), %xmm1
movsd %xmm0, (%rbx,%r15,8)
addsd %xmm0, %xmm1
incq %r15
cmpq %r15, %r14
jne 0x545a6
testl %ebp, %ebp
jle 0x545e9
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x545d3
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl %esi, %ebx
movl %edi, %ebp
leaq 0x53550(%rip), %r8      # 0xa7b5f
movl $0x8, %edi
movl $0x8, %esi
movl %ebp, %edx
movl %ebx, %ecx
movl $0x3, %r9d
callq 0x393b5
movq %rax, %r14
testl %ebp, %ebp
jle 0x54675
movl %ebp, %r15d
movl %ebx, %r12d
xorl %r13d, %r13d
testl %ebx, %ebx
jle 0x5466d
xorl %ebp, %ebp
movsd 0x4e762(%rip), %xmm0    # 0xa2da8
movsd 0x4ded2(%rip), %xmm1    # 0xa2520
callq 0x39f62
movsd (%rsp), %xmm1
mulsd %xmm1, %xmm0
movq (%r14,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %r12
jne 0x5463e
incq %r13
cmpq %r15, %r13
jne 0x54638
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl %edi, %ebp
movslq %edi, %r14
leaq (,%r14,8), %rdi
leaq 0x534d3(%rip), %rsi     # 0xa7b7a
movl $0x3, %edx
callq 0x390f5
movq %rax, %rbx
testl %r14d, %r14d
jle 0x546e7
movl %ebp, %r14d
xorl %r15d, %r15d
movsd 0x4e6e1(%rip), %xmm0    # 0xa2da8
movsd 0x4de51(%rip), %xmm1    # 0xa2520
callq 0x39f62
mulsd (%rsp), %xmm0
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x546bf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl %esi, %r12d
xorl %eax, %eax
xorpd %xmm0, %xmm0
movsd 0x4ec0c(%rip), %xmm1    # 0xa3330
movsd %xmm1, (%rsp)
movq %rax, 0x8(%rsp)
movapd %xmm0, %xmm1
mulsd 0x5345e(%rip), %xmm1    # 0xa7b98
addsd 0x50656(%rip), %xmm1    # 0xa4d98
xorpd %xmm2, %xmm2
xorl %r13d, %r13d
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
mulsd 0x53435(%rip), %xmm2    # 0xa7b98
addsd 0x5062d(%rip), %xmm2    # 0xa4d98
xorpd %xmm3, %xmm3
testl %ebp, %ebp
jle 0x547d1
xorl %ebx, %ebx
movsd %xmm2, 0x30(%rsp)
movsd %xmm3, 0x40(%rsp)
movq (%r15), %rax
movq 0x8(%r15), %rcx
movsd (%rcx,%rbx,8), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd (%rax,%rbx,8), %xmm0
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
callq 0x54568
movsd 0x40(%rsp), %xmm3
movsd 0x30(%rsp), %xmm2
movsd 0x28(%rsp), %xmm1
movsd 0x38(%rsp), %xmm4
subsd %xmm0, %xmm4
mulsd %xmm4, %xmm4
addsd %xmm4, %xmm3
incq %rbx
cmpq %rbx, %r12
jne 0x5477b
movsd (%rsp), %xmm0
ucomisd %xmm3, %xmm0
jbe 0x547ef
movsd %xmm1, (%r14)
movq 0x10(%rsp), %rax
movsd %xmm2, (%rax)
movsd %xmm3, (%rsp)
movsd 0x20(%rsp), %xmm2
addsd 0x4dd23(%rip), %xmm2    # 0xa2520
incl %r13d
cmpl $0x64, %r13d
movsd 0x18(%rsp), %xmm0
jne 0x54755
addsd 0x4dd08(%rip), %xmm0    # 0xa2520
movq 0x8(%rsp), %rax
incl %eax
cmpl $0x64, %eax
jne 0x54729
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/plot.c
// Function: solve_inv_gauss
void solve_inv_gauss(double* observations[2], int obscount, double meanstart, double meanend, double stdevstart, double stdevend, double* mean, double* stdev)
{
 /*!Last Changed 27.10.2004*/
 int i, j, k;
 double sum, m, s, mdiff, sdiff, power, bestsum = +LONG_MAX;
 mdiff = (meanend - meanstart) / DIVISIONS;
 sdiff = (stdevend - stdevstart) / DIVISIONS;
 for (i = 0; i < DIVISIONS; i++)
   for (j = 1; j < DIVISIONS; j++)
    {
     sum = 0;
     m = meanstart + mdiff * i;
     s = stdevstart + sdiff * j;
     for (k = 0; k < obscount; k++)
      {
       power = observations[1][k] - 1 + s * sqrt(2 * PI) * gaussian(observations[0][k], m, s);
       sum += power * power;
      }
     if (sum < bestsum)
      {
       bestsum = sum;
       *mean = m;
       *stdev = s;
      }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x28(%rsp)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movsd %xmm0, 0x10(%rsp)
subsd %xmm0, %xmm1
movsd 0x4e53c(%rip), %xmm0    # 0xa2da0
divsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rsp)
movsd %xmm2, 0x30(%rsp)
subsd %xmm2, %xmm3
divsd %xmm0, %xmm3
movsd %xmm3, 0x38(%rsp)
movl %esi, %r12d
xorl %eax, %eax
xorpd %xmm0, %xmm0
movsd 0x4ea9d(%rip), %xmm1    # 0xa3330
movsd %xmm1, 0x8(%rsp)
movsd 0x4dc7f(%rip), %xmm1    # 0xa2520
movsd 0x4e4ff(%rip), %xmm2    # 0xa2da8
movq %rax, 0x20(%rsp)
movsd 0x18(%rsp), %xmm3
mulsd %xmm0, %xmm3
addsd 0x10(%rsp), %xmm3
movl $0x1, %r13d
movapd %xmm1, %xmm4
movsd %xmm0, 0x40(%rsp)
movsd %xmm3, 0x50(%rsp)
movsd 0x38(%rsp), %xmm5
movsd %xmm4, 0x48(%rsp)
mulsd %xmm4, %xmm5
addsd 0x30(%rsp), %xmm5
testl %ebp, %ebp
jle 0x54976
movapd %xmm5, %xmm0
mulsd 0x532a2(%rip), %xmm0    # 0xa7ba0
movsd %xmm0, 0x58(%rsp)
xorpd %xmm1, %xmm1
xorl %ebx, %ebx
movsd %xmm5, 0x60(%rsp)
movsd %xmm1, 0x70(%rsp)
movq (%r15), %rax
movq 0x8(%r15), %rcx
movsd (%rcx,%rbx,8), %xmm0
addsd %xmm2, %xmm0
movsd %xmm0, 0x68(%rsp)
movsd (%rax,%rbx,8), %xmm0
movapd %xmm3, %xmm1
movapd %xmm5, %xmm2
callq 0x8b5f2
movsd 0x70(%rsp), %xmm1
movsd 0x60(%rsp), %xmm5
movsd 0x50(%rsp), %xmm3
movsd 0x4e450(%rip), %xmm2    # 0xa2da8
mulsd 0x58(%rsp), %xmm0
addsd 0x68(%rsp), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
incq %rbx
cmpq %rbx, %r12
jne 0x54910
jmp 0x5497a
xorpd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5499a
movsd %xmm3, (%r14)
movq 0x28(%rsp), %rax
movsd %xmm5, (%rax)
movsd %xmm1, 0x8(%rsp)
movsd 0x4db7e(%rip), %xmm1    # 0xa2520
movsd 0x48(%rsp), %xmm4
addsd %xmm1, %xmm4
incl %r13d
cmpl $0x64, %r13d
movsd 0x40(%rsp), %xmm0
jne 0x548d4
addsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
incl %eax
cmpl $0x64, %eax
jne 0x548a9
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/plot.c
// Function: box_plot
void box_plot(char** names, int filecount)
{
 /*!Last Changed 20.09.2006*/
 /*!Last Changed 11.07.2005*/
 int count, i;
 Point p1, p2, p3;
 char* plotname, st2[3];
 plotname = file_only_name(names[0]); 
 if (!get_parameter_o("hold"))
   clear_image();
 for (i = 0; i < filecount; i++)
  {
   p1.x = file_percentile(names[i], 50);
   p1.y = file_percentile(names[i], 25);
   p2.x = file_percentile(names[i], 75);
   p2.y = i;
   file_whiskers(names[i], p1.y, p2.x, &(p3.x), &(p3.y));
   sprintf(st2, "%d", img.xaxis.namesavailable);
   add_object(OBJECT_BOXPLOT, p1, p2, p3, st2);
  }
 img.xaxis.namesavailable++;
 count = img.xaxis.namesavailable;
 img.xaxis.names = alloc(img.xaxis.names, count * sizeof(char *), count); 
 img.xaxis.names[count - 1] = strcopy(img.xaxis.names[count - 1], plotname);
 safe_free(plotname);
 img.xaxis.limitsset = 1;
 img.xaxis.lim.division = img.xaxis.namesavailable;
 img.xaxis.lim.min = 0;
 img.xaxis.lim.max = img.xaxis.namesavailable;
 img.xaxis.lim.precision = 0;
 export_image();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x37f08
movq %rax, 0x18(%rsp)
leaq 0x4f814(%rip), %rdi     # 0xa7715
callq 0x536e7
testl %eax, %eax
jne 0x57f11
xorl %eax, %eax
callq 0x2da74
testl %ebp, %ebp
jle 0x57fee
movl %ebp, %ebx
leaq 0x357196(%rip), %r15    # 0x3af0b8
leaq 0x55c34(%rip), %r13     # 0xadb5d
leaq 0x15(%rsp), %rbp
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
movsd 0x4fc7b(%rip), %xmm0    # 0xa7bb8
callq 0x8c8ef
movsd %xmm0, 0x30(%rsp)
movq (%r14,%r12,8), %rdi
movsd 0x4fc6c(%rip), %xmm0    # 0xa7bc0
callq 0x8c8ef
movsd %xmm0, 0x8(%rsp)
movq (%r14,%r12,8), %rdi
movsd 0x4fc5d(%rip), %xmm0    # 0xa7bc8
callq 0x8c8ef
movaps %xmm0, %xmm1
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
movsd %xmm0, 0x28(%rsp)
movq (%r14,%r12,8), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x38(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x8c771
movl 0x38(%r15), %edx
movq %rbp, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x41b0
movsd 0x38(%rsp), %xmm4
movsd 0x40(%rsp), %xmm5
movl $0x4, %edi
movsd 0x30(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x28(%rsp), %xmm3
movq %rbp, %rsi
callq 0x2c3cc
incq %r12
cmpq %r12, %rbx
jne 0x57f31
leaq 0x3570c3(%rip), %rbx    # 0x3af0b8
movslq 0x38(%rbx), %r14
leaq 0x1(%r14), %rdx
movl %edx, 0x38(%rbx)
movq 0x30(%rbx), %rdi
leaq 0x8(,%r14,8), %rsi
callq 0x390c8
movq %rax, 0x30(%rbx)
movq (%rax,%r14,8), %rdi
movq 0x18(%rsp), %r15
movq %r15, %rsi
callq 0x3a404
movq 0x30(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
movq %r15, %rdi
callq 0x39194
movl 0x38(%rbx), %eax
movl %eax, 0x20(%rbx)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq $0x0, 0x10(%rbx)
movsd %xmm0, 0x18(%rbx)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x24(%rbx)
xorl %eax, %eax
callq 0x2de4a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/plot.c
// Function: plotmv
void plotmv(char** names, int filecount)
{
 /*!Last Changed 20.09.2006*/
 /*!Last Changed 11.07.2005*/
 int count, i;
 Point p1, p2;
 char* plotname;
 if (!get_parameter_o("hold"))
   clear_image();
 plotname = file_only_name(names[0]);
 for (i = 0; i < filecount; i++)
  {
   p1.x = file_mean(&(names[i]), 1);
   p1.y = file_variance(&(names[i]), 1);
   p2.x = img.xaxis.namesavailable;
   p2.y = i;
   add_object(OBJECT_MVBOX, p1, p2, dummyp, NULL);
  }
 img.xaxis.namesavailable++;
 count = img.xaxis.namesavailable;
 img.xaxis.names = alloc(img.xaxis.names, count * sizeof(char *), count); 
 img.xaxis.names[count - 1] = strcopy(img.xaxis.names[count - 1], plotname);
 safe_free(plotname);
 img.xaxis.lim.division = count;
 img.xaxis.lim.min = 0;
 img.xaxis.lim.max = count;
 img.xaxis.lim.precision = 0;
 export_image();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
leaq 0x4f68a(%rip), %rdi     # 0xa7715
callq 0x536e7
testl %eax, %eax
jne 0x5809b
xorl %eax, %eax
callq 0x2da74
movq (%r14), %rdi
callq 0x37f08
movq %rax, %rbx
testl %ebp, %ebp
jle 0x58117
movl %ebp, %r15d
xorl %r12d, %r12d
leaq 0x357001(%rip), %r13    # 0x3af0b8
movq %r14, %rdi
movl $0x1, %esi
callq 0x8bbed
movsd %xmm0, (%rsp)
movq %r14, %rdi
movl $0x1, %esi
callq 0x8caa9
movaps %xmm0, %xmm1
xorps %xmm2, %xmm2
cvtsi2sdl 0x38(%r13), %xmm2
xorps %xmm3, %xmm3
cvtsi2sd %r12d, %xmm3
movsd 0x79f7e(%rip), %xmm4    # 0xd2070
movsd 0x79f7e(%rip), %xmm5    # 0xd2078
movl $0x3, %edi
movsd (%rsp), %xmm0
xorl %esi, %esi
callq 0x2c3cc
incq %r12
addq $0x8, %r14
cmpq %r12, %r15
jne 0x580b7
leaq 0x356f9a(%rip), %r15    # 0x3af0b8
movslq 0x38(%r15), %r12
leaq 0x1(%r12), %r14
movl %r14d, 0x38(%r15)
movq 0x30(%r15), %rdi
leaq 0x8(,%r12,8), %rsi
movl %r14d, %edx
callq 0x390c8
movq %rax, 0x30(%r15)
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x3a404
movq 0x30(%r15), %rcx
movq %rax, (%rcx,%r12,8)
movq %rbx, %rdi
callq 0x39194
movl %r14d, 0x20(%r15)
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movq $0x0, 0x10(%r15)
movsd %xmm0, 0x18(%r15)
movl $0x0, 0x24(%r15)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2de4a
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x4f10f(%rip), %rdi     # 0xa7715
callq 0x536e7
testl %eax, %eax
jne 0x58616
xorl %eax, %eax
callq 0x2da74
leaq 0x356a9b(%rip), %rax    # 0x3af0b8
movl $0x1, 0x78(%rax)
movslq 0xec(%rax), %r15
leaq 0x79a2e(%rip), %rax     # 0xd2060
movb (%r15,%rax), %al
movb %al, 0xe(%rsp)
movb $0x0, 0xf(%rsp)
leal 0x1(%r15), %edx
leaq 0x4f61d(%rip), %rsi     # 0xa7c67
leaq 0x1e(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x41b0
movsbl 0xe(%rsp), %edi
movq %r14, %rsi
callq 0x2c324
leaq 0x18(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x583ba
movq %rax, %rbx
movslq (%r14), %r12
testq %r12, %r12
jle 0x586d2
cvtsi2sd %r15d, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %r15d, %r15d
leaq 0xe(%rsp), %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movsd (%rax,%r15,8), %xmm0
movsd (%rcx,%r15,8), %xmm1
movsd 0x799c1(%rip), %xmm2    # 0xd2070
movsd 0x799c1(%rip), %xmm3    # 0xd2078
movl $0x1, %edi
movsd 0x10(%rsp), %xmm4
movq %r14, %rsi
callq 0x2c3cc
incq %r15
cmpq %r15, %r12
jne 0x58694
movq (%rbx), %rdi
callq 0x39194
movq 0x8(%rbx), %rdi
callq 0x39194
movq %rbx, %rdi
callq 0x39194
xorl %eax, %eax
callq 0x2de4a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/plot.c
// Function: plotxyline
void plotxyline(char* names, int linecolor, double linewidth)
{
 /*!Last Changed 20.09.2006 added line types*/
 /*!Last Changed 06.09.2006 incremented legendcount*/
 /*!Last Changed 08.10.2004 added img.xaxis.lim and img.yaxis.lim*/
 /*!Last Changed 02.02.2004 added safemalloc*/
 double** observations;
 int j, counts;
 char st2[3], *legendname;
 Point p1, p2;
 Objectptr obj;
 if (!get_parameter_o("hold"))
   clear_image();
 img.yaxis.available = 1;
 legendname = file_only_name(names); 
 add_legend((char) ('a' + img.imagelegend.legendcount), legendname);
 safe_free(legendname);
 observations = read_2d_observations(names, &counts);
 sprintf(st2, "%d", img.imagelegend.legendcount - 1);
 for (j = 0; j < counts - 1; j++)
  {
   p1.x = (double) (observations[0][j]);
   p1.y = (double) (observations[1][j]);
   p2.x = (double) (observations[0][j+1]);
   p2.y = (double) (observations[1][j+1]);
   obj = add_object(OBJECT_LINE, p1, p2, dummyp, st2);
   obj->fnt.fontcolor = linecolor;
   obj->fnt.fontsize = linewidth;
  }
 safe_free(observations[0]);
 safe_free(observations[1]);
 safe_free(observations);
 export_image();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x10(%rsp)
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4eb2a(%rip), %rdi     # 0xa7715
callq 0x536e7
testl %eax, %eax
jne 0x58bfb
xorl %eax, %eax
callq 0x2da74
leaq 0x3564b6(%rip), %r12    # 0x3af0b8
movl $0x1, 0x78(%r12)
movq %r14, %rdi
callq 0x37f08
movq %rax, %r15
movb 0xec(%r12), %al
addb $0x61, %al
movsbl %al, %edi
movq %r15, %rsi
callq 0x2c324
movq %r15, %rdi
callq 0x39194
leaq 0x1c(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x583ba
movq %rax, %r14
movl 0xec(%r12), %edx
decl %edx
leaq 0x54f06(%rip), %rsi     # 0xadb5d
leaq 0xd(%rsp), %rdi
xorl %eax, %eax
callq 0x41b0
movl (%r15), %r12d
cmpl $0x2, %r12d
jl 0x58cc7
decl %r12d
xorl %eax, %eax
leaq 0xd(%rsp), %r15
movq (%r14), %rcx
movq 0x8(%r14), %rdx
leaq 0x1(%rax), %r13
movsd (%rcx,%rax,8), %xmm0
movsd 0x8(%rcx,%rax,8), %xmm2
movsd (%rdx,%rax,8), %xmm1
movsd 0x8(%rdx,%rax,8), %xmm3
movsd 0x793d1(%rip), %xmm4    # 0xd2070
movsd 0x793d1(%rip), %xmm5    # 0xd2078
xorl %edi, %edi
movq %r15, %rsi
callq 0x2c3cc
movsd 0x10(%rsp), %xmm0
movl %ebx, 0x18(%rax)
movsd %xmm0, 0x10(%rax)
movq %r13, %rax
cmpq %r13, %r12
jne 0x58c76
movq (%r14), %rdi
callq 0x39194
movq 0x8(%r14), %rdi
callq 0x39194
movq %r14, %rdi
callq 0x39194
xorl %eax, %eax
callq 0x2de4a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/poly.c
// Function: 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 0x37e22
movl %eax, (%r14)
leaq 0x4f9ba(%rip), %rsi     # 0xa888f
movq %rbx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x58f6a
movq %rax, %rbx
movl (%r14), %edx
leaq 0x4edf5(%rip), %r8      # 0xa7ce8
movl $0x8, %edi
movl $0x8, %esi
movl $0x2, %ecx
movl $0x6, %r9d
callq 0x393b5
movq %rax, %r14
movq %rsp, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rbx, %rdx
callq 0x4120
testq %rax, %rax
je 0x58f60
leaq 0x4c9c6(%rip), %r15     # 0xa58f2
movq %rsp, %r12
movq %r14, %r13
movq (%r13), %rdx
leaq 0x8(%rdx), %rcx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x40b0
movq %r12, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rbx, %rdx
callq 0x4120
addq $0x8, %r13
testq %rax, %rax
jne 0x58f32
movq %rbx, %rdi
callq 0x42a0
jmp 0x58f6d
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_O1/olcaytaner[P]Isell/poly.c
// Function: mean_of_polynoms
Polynomptr mean_of_polynoms(Polynomptr* polynoms, int polynomcount)
{
	/*!Last Changed 21.01.2005*/
	Polynomptr p;
	Polynodeptr* nodes;
	int i, currentdegree = -1, count;
	double sum;
	p = create_polynom();
	nodes = safemalloc(polynomcount * sizeof(Polynodeptr), "mean_of_polynoms", 6);
 for (i = 0; i < polynomcount; i++)
	 {
		 nodes[i] = polynoms[i]->start;
			if (nodes[i] && nodes[i]->power > currentdegree)
				 currentdegree = nodes[i]->power;
	 }
	while (currentdegree >= 0)
	 {
		 sum = 0;
			count = 0;
		 for (i = 0; i < polynomcount; i++)
				 if (nodes[i] && nodes[i]->power == currentdegree)
					 {
						 sum += nodes[i]->coefficient;
							count++;
						 nodes[i] = nodes[i]->next;
					 }
   if (count > 0)
				 add_polynode_to_polynom(p, currentdegree, sum / count);
		 currentdegree--;
	 }
	safe_free(nodes);
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r13
leaq 0x4edaa(%rip), %rsi     # 0xa7d42
movl $0x10, %edi
movl $0x1, %edx
callq 0x390f5
movq %rax, %r14
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
movslq %ebx, %r12
leaq (,%r12,8), %rdi
leaq 0x4ed32(%rip), %rsi     # 0xa7cf6
movl $0x6, %edx
callq 0x390f5
movq %rax, %r15
movl %ebx, %ebp
testl %r12d, %r12d
jle 0x59005
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
xorl %eax, %eax
movq (%r13,%rax,8), %rcx
movq (%rcx), %rcx
movq %rcx, (%r15,%rax,8)
testq %rcx, %rcx
je 0x58ffb
movl 0x8(%rcx), %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
incq %rax
cmpq %rax, %rbp
jne 0x58fe0
jmp 0x5900b
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testl %r12d, %r12d
js 0x59070
testl %ebx, %ebx
jle 0x59043
xorl %ecx, %ecx
xorpd %xmm0, %xmm0
xorl %eax, %eax
movq (%r15,%rcx,8), %rdx
testq %rdx, %rdx
je 0x59039
cmpl %r12d, 0x8(%rdx)
jne 0x59039
addsd (%rdx), %xmm0
incl %eax
movq 0x10(%rdx), %rdx
movq %rdx, (%r15,%rcx,8)
incq %rcx
cmpq %rcx, %rbp
jne 0x5901c
jmp 0x59049
xorpd %xmm0, %xmm0
xorl %eax, %eax
testl %eax, %eax
jle 0x59063
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movq %r14, %rdi
movl %r12d, %esi
callq 0x5908a
leal -0x1(%r12), %eax
testl %r12d, %r12d
movl %eax, %r12d
jg 0x59010
movq %r15, %rdi
callq 0x39194
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4ecb7(%rip), %rsi     # 0xa7d55
movl $0x18, %edi
movl $0x2, %edx
callq 0x390f5
movl %ebp, 0x8(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x590e5
movl 0x8(%rcx), %esi
cmpl %ebp, %esi
jle 0x590ea
movq %rcx, %rdx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x5910d
movl 0x8(%rcx), %esi
cmpl %ebp, %esi
jg 0x590d0
jmp 0x590ec
movq %rax, (%rbx)
jmp 0x59115
xorl %edx, %edx
cmpl %ebp, %esi
jne 0x590fe
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x39194
movq %rcx, 0x10(%rax)
testq %rdx, %rdx
je 0x59120
movq %rax, 0x10(%rdx)
jmp 0x59119
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, (%rbx)
jmp 0x59119
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/poly.c
// Function: find_function_bounds
void find_function_bounds(Functionptr fx, int functioncount, double* min, double* max)
{
	/*!Last Changed 21.01.2005*/
	int i;
	*min = fx[0].min;
	*max = fx[0].max;
	for (i = 1; i < functioncount; i++)
	 {
		 if (fx[i].min < *min)
				 *min = fx[i].min;
		 if (fx[i].max > *max)
				 *max = fx[i].max;
	 }
}

// Assembly:
movsd 0x10(%rdi), %xmm0
movsd %xmm0, (%rdx)
movsd 0x18(%rdi), %xmm0
movsd %xmm0, (%rcx)
cmpl $0x2, %esi
jl 0x59175
movl %esi, %eax
shlq $0x5, %rax
addq $-0x20, %rax
xorl %esi, %esi
movsd 0x30(%rdi,%rsi), %xmm0
movsd (%rdx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5915c
movsd %xmm0, (%rdx)
movsd 0x38(%rdi,%rsi), %xmm0
ucomisd (%rcx), %xmm0
jbe 0x5916c
movsd %xmm0, (%rcx)
addq $0x20, %rsi
cmpq %rsi, %rax
jne 0x59148
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movl %edi, %r12d
leaq 0x4eb72(%rip), %r8      # 0xa7d07
movl $0x8, %edi
movl $0x8, %esi
movl %r12d, %edx
movl $0x2, %ecx
movl $0x3, %r9d
callq 0x393b5
movq %rax, %r15
movsd 0x10(%r14), %xmm3
movsd 0x18(%r14), %xmm2
cmpl $0x2, %ebp
jl 0x591fb
movl %ebp, %eax
shlq $0x5, %rax
addq $-0x20, %rax
xorl %ecx, %ecx
movsd 0x30(%r14,%rcx), %xmm0
minsd %xmm3, %xmm0
movsd 0x38(%r14,%rcx), %xmm1
maxsd %xmm2, %xmm1
addq $0x20, %rcx
movapd %xmm0, %xmm3
movapd %xmm1, %xmm2
cmpq %rcx, %rax
jne 0x591d2
jmp 0x59203
movapd %xmm3, %xmm0
movapd %xmm2, %xmm1
testl %r12d, %r12d
jle 0x59287
movl %r12d, %r13d
xorl %r12d, %r12d
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x39f62
movq %r14, %rdi
movl %ebp, %esi
movsd %xmm0, 0x20(%rsp)
callq 0x59299
movapd %xmm0, %xmm1
testl %ebx, %ebx
je 0x59260
leaq 0x4a3bf(%rip), %rdi     # 0xa35fd
movsd %xmm1, 0x18(%rsp)
callq 0x534b6
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
callq 0x8cd13
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movq (%r15,%r12,8), %rax
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd %xmm1, 0x8(%rax)
incq %r12
cmpq %r12, %r13
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
jne 0x5921a
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/poly.c
// Function: function_value
double function_value(Functionptr fx, int functioncount, double x)
{
	/*!Last Changed 21.01.2005*/
	int i, which = -1;
	Functionnodeptr tmp;
	double value, sum = 0, polynomvalue;
	for (i = 0; i < functioncount; i++)
		 if (x >= fx[i].min && x <= fx[i].max)
			 {
				 which = i;
				 break;
			 }
 tmp = fx[which].start;
	while (tmp)
	 {
		 value = tmp->coefficient;
			if (tmp->xpower != 0)
				 value *= fpow(x, tmp->xpower);
			if (tmp->sinpower != 0)
			 {
				 polynomvalue = polynom_value(tmp->sinus, x);
					value *= fpow(sin(polynomvalue), tmp->sinpower);
			 }
			if (tmp->cospower != 0)
			 {
				 polynomvalue = polynom_value(tmp->cosinus, x);
					value *= fpow(cos(polynomvalue), tmp->cospower);
			 }
			sum += value;
		 tmp = tmp->next;
	 }
	return sum;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq $-0x1, %rax
testl %esi, %esi
jle 0x592d5
movl %esi, %ecx
leaq 0x18(%rdi), %rsi
xorl %edx, %edx
ucomisd -0x8(%rsi), %xmm0
jb 0x592c4
movsd (%rsi), %xmm1
ucomisd %xmm0, %xmm1
jae 0x592d2
incq %rdx
addq $0x20, %rsi
cmpq %rdx, %rcx
jne 0x592b3
jmp 0x592d5
movq %rdx, %rax
shlq $0x5, %rax
movq (%rdi,%rax), %rbx
testq %rbx, %rbx
je 0x59423
xorpd %xmm1, %xmm1
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd (%rbx), %xmm2
movl 0x8(%rbx), %edi
testl %edi, %edi
je 0x59314
movsd %xmm2, (%rsp)
callq 0x38db2
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
cmpl $0x0, 0xc(%rbx)
je 0x5938a
movq 0x10(%rbx), %rax
movq (%rax), %r14
testq %r14, %r14
movsd %xmm2, (%rsp)
xorpd %xmm0, %xmm0
je 0x59374
movsd %xmm0, 0x10(%rsp)
movsd (%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x8(%r14), %edi
movsd 0x8(%rsp), %xmm0
callq 0x38db2
mulsd 0x20(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x5932f
callq 0x4320
movl 0xc(%rbx), %edi
callq 0x38db2
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
cmpl $0x0, 0x18(%rbx)
je 0x59404
movq 0x20(%rbx), %rax
movq (%rax), %r14
testq %r14, %r14
movsd %xmm2, (%rsp)
xorpd %xmm1, %xmm1
je 0x593e4
movsd %xmm1, 0x10(%rsp)
movsd (%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x8(%r14), %edi
movsd 0x8(%rsp), %xmm0
callq 0x38db2
movsd 0x10(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm0
addsd %xmm0, %xmm1
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x593ab
movapd %xmm1, %xmm0
callq 0x4110
movl 0x18(%rbx), %edi
callq 0x38db2
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x18(%rsp)
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x592f6
jmp 0x5942d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/poly.c
// Function: functiondatageneratefile
double** functiondatageneratefile(int datasize, char* functiondefinition, int noisy)
{
	/*!Last Changed 21.01.2005*/
	int functioncount, i;
	double** data;
	Functionptr fx;
	fx = read_function_definition(functiondefinition, &functioncount);
	data = functiondatagenerate(datasize, fx, functioncount, noisy);
 for (i = 0;i < functioncount; i++)
	  free_function(fx[i]);
	safe_free(fx);
	return data;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a160, %rsp          # imm = 0x7A160
movq %rsi, %rbx
movl $0x0, (%rsi)
leaq 0x4f3a4(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x595bd
movq %rax, %r14
leaq 0x40(%rsp), %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
xorl %r15d, %r15d
testq %rax, %rax
je 0x595b3
leaq 0x20(%rsp), %r12
leaq 0x40(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x59b08
movups 0x20(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
ucomisd %xmm1, %xmm0
ja 0x595c0
movslq (%rbx), %rdx
incq %rdx
movq %rdx, %rsi
shlq $0x5, %rsi
movq %r15, %rdi
movsd %xmm0, (%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x390c8
movq %rax, %r15
movslq (%rbx), %rax
shlq $0x5, %rax
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r15,%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%r15,%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%r15,%rax)
incl (%rbx)
movq %r13, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r14, %rdx
callq 0x4120
testq %rax, %rax
jne 0x59524
movq %r14, %rdi
callq 0x42a0
jmp 0x595c0
xorl %r15d, %r15d
movq %r15, %rax
addq $0x7a160, %rsp          # imm = 0x7A160
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x595fe
movq 0x28(%rbx), %r14
movq %rbx, %rdi
callq 0x5965e
movq %rbx, %rdi
callq 0x39194
movq %r14, %rbx
testq %r14, %r14
jne 0x595e2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/poly.c
// Function: polynom_value
double polynom_value(Polynomptr p, double value)
{
 double result = 0;
 Polynodeptr tmp = p->start;
 while (tmp)
  {
   result += tmp->coefficient * fpow(value,tmp->power);
   tmp = tmp->next;
  }
 return result;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rbx
xorpd %xmm1, %xmm1
testq %rbx, %rbx
je 0x59654
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd (%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0x8(%rbx), %edi
movsd 0x8(%rsp), %xmm0
callq 0x38db2
movsd 0x18(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm1
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x5961d
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x59671
movq 0x10(%rbx), %rdi
callq 0x59683
cmpl $0x0, 0x18(%rbx)
je 0x59681
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x59683
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x596a3
movq 0x10(%rdi), %r14
callq 0x39194
movq %r14, %rdi
testq %r14, %r14
jne 0x59692
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/poly.c
// Function: print_polynom
void print_polynom(Polynomptr p, char* st)
{
	/*!Last Changed 23.01.2005*/
 Polynodeptr tmp;
	char literal[20], pst[READLINELENGTH];
	strcpy(st, "");
 tmp = p->start;
 while (tmp)
  {
   if (tmp->coefficient < 0)
     if (tmp->power > 1)
					 {
    			set_precision(pst, NULL, "x%d");
       sprintf(literal, pst, tmp->coefficient, tmp->power);
					 }
     else
       if (tmp->power == 1)
							 {
			      set_precision(pst, NULL, "x");
         sprintf(literal, pst, tmp->coefficient);
							 }
       else
							 {
      			set_precision(pst, NULL, NULL);
         sprintf(literal, pst, tmp->coefficient);
							 }
   else
     if (tmp->power > 1)
					 {
			    set_precision(pst, "+", "x%d");
       sprintf(literal, pst, tmp->coefficient, tmp->power);
					 }
     else
       if (tmp->power == 1)
							 {
			      set_precision(pst, "+", "x");
         sprintf(literal, pst, tmp->coefficient);
							 }
       else
							 {
			      set_precision(pst, "+", NULL);
         sprintf(literal, pst, tmp->coefficient);
							 }
   strcat(st, literal);
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a148, %rsp          # imm = 0x7A148
movb $0x0, (%rsi)
movq (%rdi), %r13
testq %r13, %r13
je 0x59fbf
movq %rsi, %rbx
leaq 0x4de1d(%rip), %r14     # 0xa7d51
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq 0x4c254(%rip), %rbp     # 0xa6197
xorpd %xmm0, %xmm0
ucomisd (%r13), %xmm0
movl 0x8(%r13), %eax
movq %r15, %rdi
jbe 0x59f5a
xorl %esi, %esi
jmp 0x59f5d
movq %rbp, %rsi
cmpl $0x2, %eax
jl 0x59f83
movq %r14, %rdx
callq 0x39529
movsd (%r13), %xmm0
movl 0x8(%r13), %edx
movq %r12, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x41b0
jmp 0x59fab
cmpl $0x1, %eax
jne 0x59f91
leaq 0x48f05(%rip), %rdx     # 0xa2e94
jmp 0x59f93
xorl %edx, %edx
callq 0x39529
movsd (%r13), %xmm0
movq %r12, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x41b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x41e0
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x59f43
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/poly.c
// Function: calculate_poly_clserror
double calculate_poly_clserror(double** data, int datasize, Polynomptr p)
{
	/*!Last Changed 26.01.2005*/
 double sum = 0, r, y, o;
	int i;
	for (i = 0; i < datasize; i++)
	 {
		 y = polynom_value(p, data[i][0]);
			if (sigmoid(y) > 0.5)
				 o = 1;
			else
				 o = 0;
			r = data[i][1];
			if (r != o)
     sum++;
	 }
 if (datasize == 0)
   return 0;
 return sum / datasize;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
xorpd %xmm1, %xmm1
testl %esi, %esi
jle 0x5a0b6
movq %rdx, %r14
movq %rdi, %r15
movl %ebx, %r12d
xorpd %xmm0, %xmm0
xorl %r13d, %r13d
movapd %xmm0, 0x20(%rsp)
movq (%r14), %rbp
xorpd %xmm0, %xmm0
testq %rbp, %rbp
je 0x5a064
movq (%r15,%r13,8), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rbp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x8(%rbp), %edi
movsd 0x10(%rsp), %xmm0
callq 0x38db2
mulsd 0x18(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x10(%rbp), %rbp
testq %rbp, %rbp
jne 0x5a020
callq 0x54568
movsd 0x48ca7(%rip), %xmm1    # 0xa2d18
cmpltsd %xmm0, %xmm1
movsd 0x484a2(%rip), %xmm2    # 0xa2520
andpd %xmm2, %xmm1
movq (%r15,%r13,8), %rax
movapd 0x20(%rsp), %xmm3
movapd %xmm3, %xmm0
addsd %xmm2, %xmm0
cmpneqsd 0x8(%rax), %xmm1
andpd %xmm1, %xmm0
andnpd %xmm3, %xmm1
orpd %xmm0, %xmm1
incq %r13
movapd %xmm1, %xmm0
cmpq %r12, %r13
jne 0x59ffd
testl %ebx, %ebx
xorpd %xmm0, %xmm0
je 0x5a0cd
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq