LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/cn2.c
// Function: rule_significantly_better
int rule_significantly_better(Decisionruleptr current, double positive_ratio)
{
 double pvalue, sum = 0.0;
 double falsepositives, covered;
 if (current->covered == 0 || error_rate_of_rule(*current) > 0.5)
   return NO;
 covered = positive_ratio * (current->covered + current->falsepositives);
 falsepositives = (1 - positive_ratio) * (current->covered + current->falsepositives);
 if (current->covered != 0 && covered != 0.0)
   sum += current->covered * log(current->covered / covered);
 if (current->falsepositives != 0 && falsepositives != 0.0)
   sum += current->falsepositives * log(current->falsepositives / falsepositives);
 sum *= 2;
 pvalue = chi_square(1, sum);
 if (pvalue > get_parameter_f("confidencelevel"))
   return NO;
 return YES;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x58, %rsp
xorl %ebp, %ebp
cmpl $0x0, 0x4(%rdi)
je 0xd9a8
movq %rdi, %rbx
movsd %xmm0, 0x40(%rsp)
movq 0x30(%rdi), %rax
movq %rax, 0x30(%rsp)
movupd (%rdi), %xmm0
movupd 0x10(%rdi), %xmm1
movupd 0x20(%rdi), %xmm2
movupd %xmm2, 0x20(%rsp)
movupd %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
callq 0x7b300
ucomisd 0x95469(%rip), %xmm0    # 0xa2d18
ja 0xd9a8
movl 0x4(%rbx), %eax
movl 0x8(%rbx), %ecx
addl %eax, %ecx
cvtsi2sd %ecx, %xmm3
xorpd %xmm2, %xmm2
testl %eax, %eax
je 0xd91f
movapd %xmm3, %xmm1
movsd 0x40(%rsp), %xmm0
mulsd %xmm0, %xmm1
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm1
jne 0xd8e3
jnp 0xd925
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x50(%rsp)
divsd %xmm1, %xmm0
movsd %xmm3, 0x48(%rsp)
callq 0x4160
movsd 0x48(%rsp), %xmm3
movapd %xmm0, %xmm2
movsd 0x40(%rsp), %xmm0
mulsd 0x50(%rsp), %xmm2
addsd 0x953eb(%rip), %xmm2    # 0xa2d08
jmp 0xd925
movsd 0x40(%rsp), %xmm0
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0xd974
movsd 0x94bec(%rip), %xmm1    # 0xa2520
subsd %xmm0, %xmm1
mulsd %xmm3, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0xd948
jnp 0xd974
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x48(%rsp)
divsd %xmm1, %xmm0
movsd %xmm2, 0x40(%rsp)
callq 0x4160
movsd 0x40(%rsp), %xmm2
mulsd 0x48(%rsp), %xmm0
addsd %xmm0, %xmm2
addsd %xmm2, %xmm2
movl $0x1, %edi
movapd %xmm2, %xmm0
callq 0x1f4cd
movsd %xmm0, 0x40(%rsp)
leaq 0x94f95(%rip), %rdi     # 0xa2928
callq 0x534b6
xorl %ebp, %ebp
movsd 0x40(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setbe %bpl
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/combine.c
// Function: mean_combine
int mean_combine(int* predicted, matrix posteriors)
{
 int i,j;
 int numclass = posteriors.col;
 int numlearner = posteriors.row;
 int res = -1;
 double *classtotal;
 classtotal = (double *) safecalloc(numclass, sizeof(double), "mean_combine", 5);
 for (i = 0 ; i < numclass ; i++)
	 {
   for (j = 0 ; j < numlearner ; j++)
			 {
     classtotal[i] += posteriors.values[j][i];
			 }
	 }
 res = find_max_in_list_double(classtotal, numclass);
 safe_free(classtotal);
 return (res);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rbx
shrq $0x20, %rbx
movq %rsi, %rdi
sarq $0x20, %rdi
leaq 0x9529d(%rip), %rdx     # 0xa3048
movl $0x8, %esi
movl $0x5, %ecx
callq 0x39210
movq %rax, %r12
testl %ebx, %ebx
jle 0xddf7
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
testl %r15d, %r15d
jle 0xddef
movsd (%r12,%rcx,8), %xmm0
xorl %edx, %edx
movq (%r14,%rdx,8), %rsi
addsd (%rsi,%rcx,8), %xmm0
movsd %xmm0, (%r12,%rcx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xddd8
incq %rcx
cmpq %rbx, %rcx
jne 0xddcb
movq %r12, %rdi
movl %ebx, %esi
callq 0x37533
movl %eax, %ebx
movq %r12, %rdi
callq 0x39194
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/combine.c
// Function: max_combine
int max_combine(int* predicted, matrix posteriors)
{
 int i,j;
 int numclass = posteriors.col;
 int numlearner = posteriors.row;
 int res = -1;
 double *classmax, max;
 classmax = (double *) safecalloc(numclass, sizeof(double), "max_combine", 5);
 for (i = 0 ; i < numclass ; i++)
	 {
   max = -1.0;
   for (j = 0 ; j < numlearner ; j++)
    {
     if (posteriors.values[j][i] > max)
					 {
	      classmax[i] = posteriors.values[j][i];
					 }	  
			 }
	 }
 res = find_max_in_list_double(classmax, numclass);
 safe_free(classmax);
 return (res);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rbx
shrq $0x20, %rbx
movq %rsi, %rdi
sarq $0x20, %rdi
leaq 0x95219(%rip), %rdx     # 0xa3055
movl $0x8, %esi
movl $0x5, %ecx
callq 0x39210
movq %rax, %r12
testl %ebx, %ebx
jle 0xde90
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movsd 0x94f44(%rip), %xmm0    # 0xa2da8
testl %r15d, %r15d
jle 0xde88
xorl %edx, %edx
movq (%r14,%rdx,8), %rsi
movsd (%rsi,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xde80
movsd %xmm1, (%r12,%rcx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xde6b
incq %rcx
cmpq %rbx, %rcx
jne 0xde64
movq %r12, %rdi
movl %ebx, %esi
callq 0x37533
movl %eax, %ebx
movq %r12, %rdi
callq 0x39194
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/combine.c
// Function: min_combine
int min_combine(int* predicted, matrix posteriors)
{
 int i,j;
 int numclass = posteriors.col;
 int numlearner = posteriors.row;
 int res = -1;
 double *classmin, min;
 classmin = (double *) safecalloc(numclass, sizeof(double), "min_combine", 5);
 for (i = 0 ; i < numclass ; i++)
	 {
   min = 2.0;
   for (j = 0 ; j < numlearner ; j++)
			 {
     if (posteriors.values[j][i] < min)
					 {
	      classmin[i] = posteriors.values[j][i];
					 }
			 }
	 }
 res = find_max_in_list_double(classmin, numclass);
 safe_free(classmin);
 return (res);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rbx
shrq $0x20, %rbx
movq %rsi, %rdi
sarq $0x20, %rdi
leaq 0x9518c(%rip), %rdx     # 0xa3061
movl $0x8, %esi
movl $0x5, %ecx
callq 0x39210
movq %rax, %r12
testl %ebx, %ebx
jle 0xdf29
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movsd 0x95143(%rip), %xmm0    # 0xa3040
testl %r15d, %r15d
jle 0xdf21
xorl %edx, %edx
movq (%r14,%rdx,8), %rsi
movsd (%rsi,%rcx,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xdf19
movsd %xmm1, (%r12,%rcx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xdf04
incq %rcx
cmpq %rbx, %rcx
jne 0xdefd
movq %r12, %rdi
movl %ebx, %esi
callq 0x37533
movl %eax, %ebx
movq %r12, %rdi
callq 0x39194
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/combine.c
// Function: prod_combine
int prod_combine(int* predicted, matrix posteriors)
{
 int i,j;
 int numclass = posteriors.col;
 int numlearner = posteriors.row;
 int res = -1;
 double *classprod;
 classprod = (double *) safecalloc(numclass, sizeof(double), "prod_combine", 5);
 for (i = 0 ; i < numclass ; i++)
	 {
   classprod[i] = 1.0;
   for (j = 0 ; j < numlearner ; j++)
    {
     classprod[i] *= posteriors.values[j][i];
			 }
	 }
 res = find_max_in_list_double(classprod, numclass);
 safe_free(classprod);
 return (res);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rbx
shrq $0x20, %rbx
movq %rsi, %rdi
sarq $0x20, %rdi
leaq 0x950ff(%rip), %rdx     # 0xa306d
movl $0x8, %esi
movl $0x5, %ecx
callq 0x39210
movq %rax, %r12
testl %ebx, %ebx
jle 0xdfc8
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
movq %rdx, (%r12,%rcx,8)
testl %r15d, %r15d
jle 0xdfc0
movsd (%r12,%rcx,8), %xmm0
xorl %esi, %esi
movq (%r14,%rsi,8), %rdi
mulsd (%rdi,%rcx,8), %xmm0
movsd %xmm0, (%r12,%rcx,8)
incq %rsi
cmpq %rsi, %rax
jne 0xdfa9
incq %rcx
cmpq %rbx, %rcx
jne 0xdf98
movq %r12, %rdi
movl %ebx, %esi
callq 0x37533
movl %eax, %ebx
movq %r12, %rdi
callq 0x39194
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/combine.c
// Function: median_combine
int median_combine(int* predicted, matrix posteriors)
{
 int i,j;
 int numclass = posteriors.col;
 int numlearner = posteriors.row;
 int res = -1;
 double *classmedian;
 double *foldmedian;
 classmedian = (double *) safecalloc(numclass, sizeof(double), "median_combine", 5);
 foldmedian = (double *) safecalloc(numlearner, sizeof(double), "median_combine", 6);
 for (i = 0; i < numclass; i++)
	 { 
   foldmedian[i] = 1.0;
   for (j = 0 ; j < numlearner ; j++)
			 {
     foldmedian[i] *= posteriors.values[j][i];
			 }
   classmedian[i] = find_median_in_list_double(foldmedian, numlearner);
	 }
 res = find_max_in_list_double(classmedian, numclass);
 safe_free(classmedian);
 return (res);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rbx
shrq $0x20, %rbx
movq %rsi, %rdi
sarq $0x20, %rdi
leaq 0x9506a(%rip), %r13     # 0xa307a
movl $0x8, %esi
movq %r13, %rdx
movl $0x5, %ecx
callq 0x39210
movq %rax, (%rsp)
movslq %r15d, %rdi
movl $0x8, %esi
movq %r13, %rdx
movl $0x6, %ecx
callq 0x39210
movq %rbx, %r12
testl %ebx, %ebx
jle 0xe0a1
movq %rax, %r13
movl %r15d, %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %ebx, %ebx
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%r13,%rbx,8)
testl %r15d, %r15d
jle 0xe085
movsd (%r13,%rbx,8), %xmm0
xorl %eax, %eax
movq (%r14,%rax,8), %rcx
mulsd (%rcx,%rbx,8), %xmm0
movsd %xmm0, (%r13,%rbx,8)
incq %rax
cmpq %rax, %rbp
jne 0xe06d
movq %r13, %rdi
movl %r15d, %esi
callq 0x37708
movq (%rsp), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
cmpq %r12, %rbx
jne 0xe050
movq (%rsp), %r14
movq %r14, %rdi
movl %r12d, %esi
callq 0x37533
movl %eax, %ebx
movq %r14, %rdi
callq 0x39194
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/command.c
// Function: get_order_index
int get_order_index(char* order)
{
	/*!Last Changed 08.01.2006*/
	int i;
	if (!order)
		 return -2;
	for (i = 0; i < ordercount; i++)
		 if (strcmp(order, orders[i].command) == 0)
				 return i;
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xe12a
movslq 0xc43bb(%rip), %r15     # 0xd24b0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r15, %r15
jle 0xe134
movq %rdi, %r14
movq 0xc439f(%rip), %r13     # 0xd24a8
xorl %r12d, %r12d
movq (%r13), %rsi
movq %r14, %rdi
callq 0x4260
testl %eax, %eax
je 0xe131
incq %r12
addq $0x68, %r13
cmpq %r12, %r15
jne 0xe10c
jmp 0xe134
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0xe134
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/command.c
// Function: search_help
void search_help(char* st)
{
	/*!Last Changed 19.01.2005 changed the instr*/
	/*!Last Changed 03.02.2004*/
	int i;
	for (i = 0; i < ordercount; i++)
		 if (instr(orders[i].command, st) != -1)
				 printf("%s ", orders[i].command);
			else
				 if (instr(orders[i].usage, st) != -1)
						 printf("%s ", orders[i].command);
					else
						 if (instr(orders[i].help_messages, st) != -1)
								 printf("%s ", orders[i].command);
	printf("\n");
}

// Assembly:
cmpl $0x0, 0xc4369(%rip)     # 0xd24b0
jle 0xe1e2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9fc54(%rip), %r14     # 0xaddb3
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0xc433c(%rip), %rax     # 0xd24a8
movq (%rax,%r15), %rdi
movq %rbx, %rsi
callq 0x3a23d
movq 0xc4329(%rip), %rcx     # 0xd24a8
cmpl $-0x1, %eax
jne 0xe1b6
movq 0x28(%rcx,%r15), %rdi
movq %rbx, %rsi
callq 0x3a23d
movq 0xc4310(%rip), %rcx     # 0xd24a8
cmpl $-0x1, %eax
jne 0xe1b6
movq 0x30(%rcx,%r15), %rdi
movq %rbx, %rsi
callq 0x3a23d
cmpl $-0x1, %eax
je 0xe1c4
movq 0xc42f2(%rip), %rcx     # 0xd24a8
movq (%rcx,%r15), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x4030
incq %r12
movslq 0xc42e2(%rip), %rax     # 0xd24b0
addq $0x68, %r15
cmpq %rax, %r12
jl 0xe165
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xa, %edi
jmp 0x40d0
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/command.c
// Function: deallocate_orders
void deallocate_orders()
{
 /*!Last Changed 18.01.2009 added memory deallocation functions for examples*/
	/*!Last Changed 05.08.2007*/
	int i, j;
	for (i = 0; i < ordercount; i++)
	 {
		 if (orders[i].command)
				 safe_free(orders[i].command);
		 if (orders[i].command_group)
				 safe_free(orders[i].command_group);
		 if (orders[i].command_subgroup)
				 safe_free(orders[i].command_subgroup);
		 if (orders[i].function_return)
				 safe_free(orders[i].function_return);
		 if (orders[i].grammar)
				 safe_free(orders[i].grammar);
		 if (orders[i].usage)
				 safe_free(orders[i].usage);
		 if (orders[i].help_messages)
				 safe_free(orders[i].help_messages);
   for (j = 0; j < orders[i].examplecount; j++)
     safe_free(orders[i].examples[j]);
	 }
	safe_free(orders);
}

// Assembly:
cmpl $0x0, 0xc42bd(%rip)     # 0xd24b0
jle 0xe2fa
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x38, %ebx
xorl %r14d, %r14d
movq 0xc4298(%rip), %rax     # 0xd24a8
imulq $0x68, %r14, %r15
movq (%rax,%r15), %rdi
testq %rdi, %rdi
je 0xe222
callq 0x39194
movq 0xc427f(%rip), %rax     # 0xd24a8
movq 0x8(%rax,%r15), %rdi
testq %rdi, %rdi
je 0xe238
callq 0x39194
movq 0xc4269(%rip), %rax     # 0xd24a8
movq 0x10(%rax,%r15), %rdi
testq %rdi, %rdi
je 0xe24e
callq 0x39194
movq 0xc4253(%rip), %rax     # 0xd24a8
movq 0x18(%rax,%r15), %rdi
testq %rdi, %rdi
je 0xe264
callq 0x39194
movq 0xc423d(%rip), %rax     # 0xd24a8
movq 0x20(%rax,%r15), %rdi
testq %rdi, %rdi
je 0xe27a
callq 0x39194
movq 0xc4227(%rip), %rax     # 0xd24a8
movq 0x28(%rax,%r15), %rdi
testq %rdi, %rdi
je 0xe290
callq 0x39194
movq 0xc4211(%rip), %rax     # 0xd24a8
movq 0x30(%rax,%r15), %rdi
testq %rdi, %rdi
je 0xe2a6
callq 0x39194
movq 0xc41fb(%rip), %rax     # 0xd24a8
cmpl $0x0, 0x60(%rax,%r15)
jle 0xe2d8
xorl %r12d, %r12d
addq %rbx, %rax
movq (%rax,%r12,8), %rdi
callq 0x39194
incq %r12
movq 0xc41da(%rip), %rax     # 0xd24a8
movslq 0x60(%rax,%r15), %rcx
cmpq %rcx, %r12
jl 0xe2b8
incq %r14
movslq 0xc41ce(%rip), %rax     # 0xd24b0
addq $0x68, %rbx
cmpq %rax, %r14
jl 0xe209
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movq 0xc41a7(%rip), %rdi     # 0xd24a8
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/command.c
// Function: print_order
void print_order(int res)
{
 int i;
 char tmp[MAXLENGTH];
 printf("%s %s\n", m1284, orders[res].command);
 printf("%s %s\n", m1285, orders[res].command_group);
 printf("%s %s\n", m1286, orders[res].command_subgroup);
 printf("%s %s\n", m1287, orders[res].grammar);
	printf("%s %s\n", m1288, orders[res].function_return);
 printf("%s %s\n", m1289, orders[res].usage);
 printf("%s %s\n", m1290, orders[res].help_messages);
 for (i = 0; i < orders[res].examplecount; i++)
  {
   printf("%s %d\n", m1412, i + 1);
   sprintf(tmp, "examples/%s", orders[res].examples[i]);
   display_file(tmp);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq 0xc418a(%rip), %rax     # 0xd24a8
movslq %edi, %rcx
imulq $0x68, %rcx, %rbp
movq (%rax,%rbp), %rdx
leaq 0x94d80(%rip), %rbx     # 0xa30b0
leaq 0x94d80(%rip), %rsi     # 0xa30b7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc4160(%rip), %rax     # 0xd24a8
movq 0x8(%rax,%rbp), %rdx
leaq 0x94d6c(%rip), %rsi     # 0xa30c0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc4143(%rip), %rax     # 0xd24a8
movq 0x10(%rax,%rbp), %rdx
leaq 0x94d5e(%rip), %rsi     # 0xa30cf
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc4126(%rip), %rax     # 0xd24a8
movq 0x20(%rax,%rbp), %rdx
leaq 0x94d53(%rip), %rsi     # 0xa30e1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc4109(%rip), %rax     # 0xd24a8
movq 0x18(%rax,%rbp), %rdx
leaq 0x94d3f(%rip), %rsi     # 0xa30ea
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc40ec(%rip), %rax     # 0xd24a8
movq 0x28(%rax,%rbp), %rdx
leaq 0x94d2b(%rip), %rsi     # 0xa30f3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc40cf(%rip), %rax     # 0xd24a8
movq 0x30(%rax,%rbp), %rdx
leaq 0x94d15(%rip), %rsi     # 0xa30fa
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc40b2(%rip), %rax     # 0xd24a8
cmpl $0x0, 0x60(%rax,%rbp)
jle 0xe461
leaq 0x38(%rbp), %rbx
leaq 0x94d07(%rip), %r15     # 0xa310f
movq %rsp, %r12
xorl %r13d, %r13d
leaq 0x1(%r13), %r14
leaq 0x9a7ff(%rip), %rdi     # 0xa8c18
leaq 0x94ce7(%rip), %rsi     # 0xa3107
movl %r14d, %edx
xorl %eax, %eax
callq 0x4030
movq 0xc4077(%rip), %rax     # 0xd24a8
addq %rbx, %rax
movq (%rax,%r13,8), %rdx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x41b0
movq %r12, %rdi
callq 0x87f5f
movq 0xc4054(%rip), %rax     # 0xd24a8
movslq 0x60(%rax,%rbp), %rax
movq %r14, %r13
cmpq %rax, %r14
jl 0xe40e
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/command.c
// Function: add_command_child
Command_nodeptr add_command_child(Command_nodeptr root, char* st)
{
	/*!Last Changed 23.10.2005*/
	Command_nodeptr tmp = root->child, before = NULL, newnode;
 newnode = safemalloc(sizeof(Command_node), "add_command_child", 2);
	newnode->command = strcopy(newnode->command, st);
	newnode->child = NULL;
	newnode->next = NULL;
 while (tmp)
		{
	  if (strIcmp(st, tmp->command) < 0)
		  	break;
			before = tmp;
			tmp = tmp->next;
		}
	if (before)
		{
  	newnode->next = before->next;
			before->next = newnode;
		}
	else
		{
			newnode->next = root->child;
			root->child = newnode;
		}
	return newnode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %r12
addq $0x10, %rbx
leaq 0x949c8(%rip), %rsi     # 0xa3139
movl $0x18, %edi
movl $0x2, %edx
callq 0x390f5
movq %rax, %r14
movq (%rax), %rdi
movq %r15, %rsi
callq 0x3a404
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
testq %r12, %r12
je 0xe7cd
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3a318
testl %eax, %eax
js 0xe7cd
movq %r12, %r13
movq 0x8(%r12), %r12
testq %r12, %r12
je 0xe7d0
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3a318
testl %eax, %eax
jns 0xe7ae
jmp 0xe7d0
xorl %r13d, %r13d
leaq 0x8(%r13), %rax
testq %r13, %r13
cmoveq %rbx, %rax
movq (%rax), %rcx
movq %rcx, 0x8(%r14)
movq %r14, (%rax)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/command.c
// Function: generate_command_tree
Command_nodeptr generate_command_tree()
{
	/*!Last Changed 23.10.2005*/
	int i;
	Command_nodeptr root, group, subgroup;
	root = safemalloc(sizeof(Command_node), "generate_command_tree", 3);
	root->child = NULL;
	root->next = NULL;
	root->command = strcopy(root->command, "COMMANDS");
	for (i = 0; i < ordercount; i++)
		 if (strcmp(orders[i].command, "!!!") != 0)
			 {
	  	 group = child_of_command(root, orders[i].command_group);
		  	if (!group)
			  	 group = add_command_child(root, orders[i].command_group);
		  	subgroup = child_of_command(group, orders[i].command_subgroup);
		  	if (!subgroup)
		  		 subgroup = add_command_child(group, orders[i].command_subgroup);
		  	add_command_child(subgroup, orders[i].command);
			 }
	return root;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x94912(%rip), %rsi     # 0xa314b
movl $0x18, %edi
movl $0x3, %edx
callq 0x390f5
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq (%rax), %rdi
leaq 0x94905(%rip), %rsi     # 0xa3161
callq 0x3a404
movq %rax, (%rbx)
cmpl $0x0, 0xc3c45(%rip)     # 0xd24b0
jle 0xe968
xorl %ebp, %ebp
leaq 0x948f0(%rip), %r13     # 0xa316a
movq %rbx, (%rsp)
movq 0xc3c23(%rip), %r12     # 0xd24a8
imulq $0x68, %rbp, %r14
movq (%r12,%r14), %rdi
movq %r13, %rsi
callq 0x4260
testl %eax, %eax
je 0xe955
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0xe8c6
addq %r14, %r12
movq 0x8(%r12), %r12
movq (%r15), %rsi
movq %r12, %rdi
callq 0x3a318
testl %eax, %eax
je 0xe8c9
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xe8ae
xorl %r15d, %r15d
testq %r15, %r15
jne 0xe8e5
movq 0xc3bd3(%rip), %rax     # 0xd24a8
movq 0x8(%rax,%r14), %rsi
movq %rbx, %rdi
callq 0xe753
movq %rax, %r15
movq 0x10(%r15), %r12
testq %r12, %r12
je 0xe923
movq %r13, %rbx
movq 0xc3bb0(%rip), %rax     # 0xd24a8
movq 0x10(%rax,%r14), %r13
movq (%r12), %rsi
movq %r13, %rdi
callq 0x3a318
testl %eax, %eax
je 0xe91a
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0xe8fd
xorl %r12d, %r12d
movq %rbx, %r13
movq (%rsp), %rbx
jmp 0xe926
xorl %r12d, %r12d
testq %r12, %r12
jne 0xe942
movq 0xc3b76(%rip), %rax     # 0xd24a8
movq 0x10(%rax,%r14), %rsi
movq %r15, %rdi
callq 0xe753
movq %rax, %r12
movq 0xc3b5f(%rip), %rax     # 0xd24a8
movq (%rax,%r14), %rsi
movq %r12, %rdi
callq 0xe753
incq %rbp
movslq 0xc3b51(%rip), %rax     # 0xd24b0
cmpq %rax, %rbp
jl 0xe87e
movq %rbx, %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/command.c
// Function: print_command_node
void print_command_node(Command_nodeptr root, int level)
{
	/*!Last Changed 23.10.2005*/
	Command_nodeptr tmp;
	int i;
	for (i = 0; i < level; i++)
		 printf("\t");
	printf("%s\n", root->command);
 tmp = root->child;
	while (tmp)
	 {
		 print_command_node(tmp, level + 1);
		 tmp = tmp->next;
	 }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0xe997
movl %ebx, %ebp
movl $0x9, %edi
callq 0x40d0
decl %ebp
jne 0xe989
movq (%r14), %rdi
callq 0x4090
movq 0x10(%r14), %r14
testq %r14, %r14
je 0xe9bd
incl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0xe97a
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xe9aa
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/command.c
// Function: deallocate_command_tree
void deallocate_command_tree(Command_nodeptr root)
{
	/*!Last Changed 23.10.2005*/
	if (root->child)
  	deallocate_command_tree(root->child);
	if (root->next)
		 deallocate_command_tree(root->next);
	safe_free(root->command);
	safe_free(root);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xe9db
callq 0xe9c9
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xe9e9
callq 0xe9c9
movq (%rbx), %rdi
callq 0x39194
movq %rbx, %rdi
popq %rbx
jmp 0x39194
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/convex.c
// Function: copy_of_quadratic_program
Quadraticprogramptr copy_of_quadratic_program(Quadraticprogramptr src)
{
 Quadraticprogramptr dst;
 dst = safemalloc(sizeof(Quadraticprogram), "copy_of_quadratic_program", 2);
 dst->constraintcount = src->constraintcount;
 dst->m = src->m;
 dst->n = src->n;
 dst->variablecount = src->variablecount;
 dst->Q = matrix_copy(src->Q);
 dst->constraints = matrix_copy(src->constraints);
 dst->c = (double*) clone_void_array(src->c, src->n * sizeof(double));
 dst->objectives = (double*) clone_void_array(src->objectives, src->constraints.col * sizeof(double));
 dst->basic = (int*) clone_void_array(src->basic, src->constraintcount * sizeof(int));
 dst->isbasic = (BOOLEAN*) clone_void_array(src->isbasic, (src->constraints.col - 1) * sizeof(BOOLEAN));
 return dst;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x947e6(%rip), %rsi     # 0xa31f0
movl $0x50, %edi
movl $0x2, %edx
callq 0x390f5
movq %rax, %rbx
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movl 0x4(%r14), %eax
movl %eax, 0x4(%rbx)
movl (%r14), %eax
movl %eax, (%rbx)
movl 0xc(%r14), %eax
movl %eax, 0xc(%rbx)
movq 0x20(%r14), %rdi
movq 0x28(%r14), %rsi
callq 0x3ca3c
movq %rax, 0x20(%rbx)
movq %rdx, 0x28(%rbx)
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
callq 0x3ca3c
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movq 0x30(%r14), %rdi
movl (%r14), %esi
shll $0x3, %esi
callq 0x370bf
movq %rax, 0x30(%rbx)
movq 0x38(%r14), %rdi
movl 0x14(%r14), %esi
shll $0x3, %esi
callq 0x370bf
movq %rax, 0x38(%rbx)
movq 0x48(%r14), %rdi
movl 0x8(%r14), %esi
shll $0x2, %esi
callq 0x370bf
movq %rax, 0x48(%rbx)
movq 0x40(%r14), %rdi
movl 0x14(%r14), %eax
leal -0x4(,%rax,4), %esi
callq 0x370bf
movq %rax, 0x40(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/convex.c
// Function: free_linear_program
void free_linear_program(Linearprogramptr program)
{
 safe_free(program->objectives);
 safe_free(program->isbasic);
 safe_free(program->basic);
 matrix_free(program->constraints);
 safe_free(program);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x39194
movq 0x20(%rbx), %rdi
callq 0x39194
movq 0x28(%rbx), %rdi
callq 0x39194
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x3dbad
movq %rbx, %rdi
popq %rbx
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/convex.c
// Function: free_quadratic_program
void free_quadratic_program(Quadraticprogramptr program)
{
 safe_free(program->basic);
 safe_free(program->isbasic);
 safe_free(program->objectives);
 safe_free(program->c);
 matrix_free(program->Q);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0x39194
movq 0x40(%rbx), %rdi
callq 0x39194
movq 0x38(%rbx), %rdi
callq 0x39194
movq 0x30(%rbx), %rdi
callq 0x39194
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rsi
popq %rbx
jmp 0x3dbad
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/convex.c
// Function: find_variable_to_bring_into_basis
int find_variable_to_bring_into_basis(Linearprogramptr program)
{
 int i, index = -2;
 double mincoefficient = +INT_MAX;
 for (i = 0; i < program->variablecount + program->constraintcount; i++)
   if (!program->isbasic[i] && program->objectives[i] < mincoefficient)
    {
     index = i;
     mincoefficient = program->objectives[i];
    }
 if (mincoefficient == 0.0)
   return -1;
 else
   if (mincoefficient > 0.0)
     return -2;
   else
     return index;
}

// Assembly:
movl 0x4(%rdi), %ecx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addl (%rdi), %ecx
jle 0xf428
movq 0x20(%rdi), %rdx
movl %ecx, %esi
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
movsd 0x9311b(%rip), %xmm0    # 0xa2518
xorl %r8d, %r8d
cmpl $0x0, (%rdx,%r8,4)
jne 0xf41e
movq 0x18(%rdi), %r9
movsd (%r9,%r8,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xf41e
movl %r8d, %ecx
movapd %xmm1, %xmm0
incq %r8
cmpq %r8, %rsi
jne 0xf400
jmp 0xf435
movsd 0x930e8(%rip), %xmm0    # 0xa2518
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
cmoval %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnel %ecx, %eax
cmovpl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/convex.c
// Function: find_variable_to_remove_from_basis
int find_variable_to_remove_from_basis(matrix constraints, int constraintcount, int newbasic)
{
 int i, index = -1;
 double bi, ais, minratio = +INT_MAX;
 for (i = 0; i < constraintcount; i++)
  {
   bi = constraints.values[i][constraints.col - 1];
   ais = constraints.values[i][newbasic];
   if (ais > 0 && bi / ais < minratio)
    {
     index = i;
     minratio = bi / ais;
    }
  }
 return index;
}

// Assembly:
testl %edx, %edx
jle 0xf633
movslq %ecx, %rcx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %rax, %rdi
sarq $0x20, %rdi
movl %edx, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movsd 0x92f1c(%rip), %xmm1    # 0xa2518
xorl %r8d, %r8d
xorpd %xmm0, %xmm0
movq (%rsi,%r8,8), %r9
movsd (%r9,%rcx,8), %xmm3
ucomisd %xmm0, %xmm3
jbe 0xf62a
movsd (%r9,%rdi,8), %xmm2
divsd %xmm3, %xmm2
ucomisd %xmm2, %xmm1
jbe 0xf62a
movl %r8d, %eax
movapd %xmm2, %xmm1
incq %r8
cmpq %r8, %rdx
jne 0xf603
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/convex.c
// Function: find_variable_to_bring_into_basis_qp
int find_variable_to_bring_into_basis_qp(Quadraticprogramptr program)
{
 int i, index = -2, complementary, newnonbasic;
 double mincoefficient = +INT_MAX;
 for (i = 0; i < program->variablecount + program->constraintcount; i++)
   if (!program->isbasic[i] && program->objectives[i] < mincoefficient)
    {
     complementary = complementary_variable(program->m, program->n, i);
     newnonbasic = find_variable_to_remove_from_basis(program->constraints, program->constraintcount, i);
     if ((i >= 2 * program->m + 2 * program->n) || !program->isbasic[complementary] || (newnonbasic >= 0 && program->basic[newnonbasic] == complementary))
      {
       index = i;
       mincoefficient = program->objectives[i];
      }
    }
 if (mincoefficient == 0.0)
   return -1;
 else
   if (mincoefficient > 0.0)
     return -2;
   else
     return index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addl %ecx, %edx
jle 0xf746
movq 0x40(%rdi), %rsi
movl %edx, %r8d
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movsd 0x92eae(%rip), %xmm0    # 0xa2518
xorl %r9d, %r9d
movabsq $-0x100000000, %r10     # imm = 0xFFFFFFFF00000000
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm1
cmpl $0x0, (%rsi,%r9,4)
jne 0xf738
movq 0x38(%rdi), %r11
movsd (%r11,%r9,8), %xmm3
ucomisd %xmm3, %xmm1
jbe 0xf738
movl (%rdi), %ebx
addl 0x4(%rdi), %ebx
movslq %ebx, %r14
movl %r14d, %r11d
negl %r11d
cmpq %r14, %r9
cmovll %ebx, %r11d
testl %ecx, %ecx
jle 0xf705
movq 0x18(%rdi), %r14
movq 0x10(%rdi), %r15
addq %r10, %r15
sarq $0x20, %r15
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r12d, %r12d
movapd %xmm0, %xmm4
movq (%r14,%r12,8), %r13
movsd (%r13,%r9,8), %xmm6
ucomisd %xmm2, %xmm6
jbe 0xf6fb
movsd (%r13,%r15,8), %xmm5
divsd %xmm6, %xmm5
ucomisd %xmm5, %xmm4
jbe 0xf6fb
movl %r12d, %ebp
movapd %xmm5, %xmm4
incq %r12
cmpq %r12, %rcx
jne 0xf6d2
jmp 0xf70a
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
addl %ebx, %ebx
movslq %ebx, %rbx
cmpq %rbx, %r9
jge 0xf731
addl %r9d, %r11d
movslq %r11d, %rbx
cmpl $0x0, (%rsi,%rbx,4)
je 0xf731
testl %ebp, %ebp
js 0xf738
movq 0x48(%rdi), %rbx
movl %ebp, %r14d
cmpl %r11d, (%rbx,%r14,4)
jne 0xf738
movl %r9d, %edx
movapd %xmm3, %xmm1
incq %r9
cmpq %r8, %r9
jne 0xf67f
jmp 0xf753
movsd 0x92dca(%rip), %xmm1    # 0xa2518
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
cmoval %eax, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnel %edx, %eax
cmovpl %edx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/convex.c
// Function: pivot_on_the_new_variables
void pivot_on_the_new_variables(matrix constraints, double* objectives, int newnonbasic, int newbasic)
{
 int i, j;
 double ars = constraints.values[newnonbasic][newbasic], factor;
 for (j = 0; j < constraints.col; j++)
   constraints.values[newnonbasic][j] /= ars;
 for (i = 0; i < constraints.row; i++)
   if (i != newnonbasic)
    {
     factor = -constraints.values[i][newbasic];
     if (factor != 0)
       for (j = 0; j < constraints.col; j++)
         constraints.values[i][j] += factor * constraints.values[newnonbasic][j];
    }
 factor = -objectives[newbasic];
 for (j = 0; j < constraints.col; j++)
   objectives[j] += factor * constraints.values[newnonbasic][j];
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rax
shrq $0x20, %rax
movslq %ecx, %r9
movq (%rsi,%r9,8), %r9
movslq %r8d, %r8
testl %eax, %eax
jle 0xf7ae
movsd (%r9,%r8,8), %xmm0
xorl %r10d, %r10d
movsd (%r9,%r10,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r9,%r10,8)
incq %r10
cmpq %r10, %rax
jne 0xf796
testl %edi, %edi
jle 0xf81d
movl %ecx, %ecx
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %r10d, %r10d
movapd 0x93a0b(%rip), %xmm0    # 0xa31d0
cmpq %rcx, %r10
je 0xf815
testl %eax, %eax
setle %bl
movq (%rsi,%r10,8), %r11
movsd (%r11,%r8,8), %xmm2
movapd %xmm2, %xmm1
xorpd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
setnp %bpl
sete %r14b
andb %bpl, %r14b
orb %bl, %r14b
jne 0xf815
xorl %ebx, %ebx
movsd (%r9,%rbx,8), %xmm2
mulsd %xmm1, %xmm2
addsd (%r11,%rbx,8), %xmm2
movsd %xmm2, (%r11,%rbx,8)
incq %rbx
cmpq %rbx, %rax
jne 0xf7f7
incq %r10
cmpq %rdi, %r10
jne 0xf7c5
testl %eax, %eax
jle 0xf84d
movsd (%rdx,%r8,8), %xmm0
xorpd 0x939a1(%rip), %xmm0    # 0xa31d0
xorl %ecx, %ecx
movsd (%r9,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%rdx,%rcx,8), %xmm1
movsd %xmm1, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xf831
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/convex.c
// Function: print_simplex_tableau
void print_simplex_tableau(matrix constraints, int* basic, double* objectives)
{
 int i, j;
 printf("------------------------------------------------\n");
 for (i = 0; i < constraints.row; i++)
  {
   printf("%3d ", basic[i]);
   for (j = 0; j < constraints.col; j++)
     printf("%7.3f ", constraints.values[i][j]);
   printf("\n");
  }
 printf("  F ");
 for (j = 0; j < constraints.col; j++)
   printf("%7.3f ", objectives[j]);
 printf("\n");
 printf("------------------------------------------------\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r13
movq %rdi, %r12
shrq $0x20, %r12
leaq 0x93a7c(%rip), %rdi     # 0xa32fa
callq 0x4090
testl %r13d, %r13d
jle 0xf8e4
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
leaq 0x939e4(%rip), %rbp     # 0xa327a
xorl %ebx, %ebx
movq 0x10(%rsp), %rax
movl (%rax,%rbx,4), %esi
leaq 0x939ce(%rip), %rdi     # 0xa3275
xorl %eax, %eax
callq 0x4030
testl %r12d, %r12d
jle 0xf8d2
xorl %r14d, %r14d
movq (%r15,%rbx,8), %rax
movsd (%rax,%r14,8), %xmm0
movq %rbp, %rdi
movb $0x1, %al
callq 0x4030
incq %r14
cmpq %r14, %r12
jne 0xf8b6
movl $0xa, %edi
callq 0x40d0
incq %rbx
cmpq %r13, %rbx
jne 0xf898
leaq 0x93996(%rip), %rdi     # 0xa3281
xorl %eax, %eax
callq 0x4030
testl %r12d, %r12d
movq 0x8(%rsp), %r15
jle 0xf91d
xorl %ebx, %ebx
leaq 0x93975(%rip), %r14     # 0xa327a
movsd (%r15,%rbx,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x4030
incq %rbx
cmpq %rbx, %r12
jne 0xf905
movl $0xa, %edi
callq 0x40d0
leaq 0x939cc(%rip), %rdi     # 0xa32fa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/convex.c
// Function: drop_artificial_variables
void drop_artificial_variables(Linearprogramptr program)
{
 int i, totalvariables;
 double tmp;
 program->variablecount -= program->constraintcount;
 totalvariables = program->variablecount + program->constraintcount;
 program->isbasic = alloc(program->isbasic, totalvariables * sizeof(BOOLEAN), totalvariables);
 program->objectives = alloc(program->objectives, (totalvariables + 1) * sizeof(double), totalvariables + 1);
 for (i = 0; i < totalvariables; i++)
   program->objectives[i] = program->constraints.values[program->constraintcount][i];
 program->objectives[totalvariables] = program->constraints.values[program->constraintcount][program->constraints.col - 1];
 for (i = 0; i < program->constraintcount; i++)
  {
   tmp = program->constraints.values[i][program->constraints.col - 1];
   program->constraints.values[i] = alloc(program->constraints.values[i], (totalvariables + 1) * sizeof(double), totalvariables + 1);
   program->constraints.values[i][totalvariables] = tmp;
  }
 safe_free(program->constraints.values[program->constraintcount]);
 (program->constraints.row)--;
 program->constraints.values = alloc(program->constraints.values, program->constraints.row * sizeof(double*), program->constraints.row);
 program->constraints.col -= program->constraintcount;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rdi), %r14
movl %r14d, %eax
subl 0x4(%rdi), %eax
movl %eax, (%rdi)
movq 0x20(%rdi), %rdi
leaq (,%r14,4), %rsi
movl %r14d, %edx
callq 0x390c8
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rdi
leaq 0x1(%r14), %r15
leaq 0x8(,%r14,8), %r12
movq %r12, %rsi
movl %r15d, %edx
callq 0x390c8
movq %rax, 0x18(%rbx)
testq %r14, %r14
jle 0xfdbf
movq 0x10(%rbx), %rcx
movslq 0x4(%rbx), %rdx
movq (%rcx,%rdx,8), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %r14
jne 0xfdad
movq 0x10(%rbx), %rcx
movslq 0x4(%rbx), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0xc(%rbx), %rdx
movsd -0x8(%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%r14,8)
movl 0x4(%rbx), %eax
testl %eax, %eax
jle 0xfe30
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %rdi
movslq 0xc(%rbx), %rax
movsd -0x8(%rdi,%rax,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rsi
movl %r15d, %edx
callq 0x390c8
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %rax
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax,%r14,8)
incq %r13
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jl 0xfde5
movq 0x10(%rbx), %rcx
cltq
movq (%rcx,%rax,8), %rdi
callq 0x39194
movslq 0x8(%rbx), %rax
leaq -0x1(%rax), %rdx
movl %edx, 0x8(%rbx)
movq 0x10(%rbx), %rdi
leaq -0x8(,%rax,8), %rsi
callq 0x390c8
movq %rax, 0x10(%rbx)
movl 0x4(%rbx), %eax
subl %eax, 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/convex.c
// Function: solve_lp
Convexsolutionptr solve_lp(Linearprogramptr program)
{
 Convexsolutionptr solution;
 Linearprogramptr newprogram;
 if (is_program_in_canonical_form(program))
   return solve_lp_with_basic_feasible_solution_using_simplex(program);
 newprogram = formulate_infeasibility_form(program);
 solution = solve_lp_with_basic_feasible_solution_using_simplex(newprogram);
 if (solution->optimalvalue <= DBL_DELTA)
  {
   drop_artificial_variables(newprogram);
   return solve_lp_with_basic_feasible_solution_using_simplex(newprogram);
  }
 return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x4(%rdi), %rax
testq %rax, %rax
jle 0xfed2
movq 0x10(%rbx), %rcx
movslq 0xc(%rbx), %rdx
xorl %esi, %esi
xorpd %xmm0, %xmm0
movq (%rcx,%rsi,8), %rdi
ucomisd -0x8(%rdi,%rdx,8), %xmm0
ja 0xfea4
incq %rsi
cmpq %rsi, %rax
jne 0xfe8e
jmp 0xfed2
movq %rbx, %rdi
callq 0xfaba
movq %rax, %rbx
movq %rax, %rdi
callq 0xf941
movsd 0x92f19(%rip), %xmm0    # 0xa2dd8
ucomisd 0x8(%rax), %xmm0
jae 0xfeca
xorl %eax, %eax
popq %rbx
retq
movq %rbx, %rdi
callq 0xfd48
movq %rbx, %rdi
popq %rbx
jmp 0xf941
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/convex.c
// Function: solve_qp_wolfe_method
Convexsolutionptr solve_qp_wolfe_method(Quadraticprogramptr program)
{
 int iteration = 0;
 Convexsolutionptr solution, best;
 Quadraticprogramptr copy;
 double optimal;
 copy = copy_of_quadratic_program(program);
 best = solve_qp_using_simplex(copy, BOOLEAN_FALSE);
 optimal = fabs(best->optimalvalue);
 while (optimal > DBL_DELTA && iteration < 10)
  {
   free_quadratic_program(copy);
   copy = copy_of_quadratic_program(program);
   solution = solve_qp_using_simplex(copy, BOOLEAN_TRUE);
   iteration++;
   if (fabs(solution->optimalvalue) < optimal)
    {
     optimal = fabs(solution->optimalvalue);
     free_convex_solution(best);
     best = solution;
    }
   else
     free_convex_solution(solution);
  }
 free_quadratic_program(copy);
 return best;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
callq 0xe9fc
movq %rax, %r14
xorl %r13d, %r13d
movq %rax, %rdi
xorl %esi, %esi
callq 0xffb2
movq %rax, %rbx
movsd 0x8(%rax), %xmm0
andpd 0x932d0(%rip), %xmm0    # 0xa31e0
ucomisd 0x92ec0(%rip), %xmm0    # 0xa2dd8
jbe 0xff99
movapd %xmm0, (%rsp)
movq %r14, %rdi
callq 0xf392
movq %r15, %rdi
callq 0xe9fc
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
callq 0xffb2
movapd (%rsp), %xmm0
movsd 0x8(%rax), %xmm1
andpd 0x9328f(%rip), %xmm1    # 0xa31e0
ucomisd %xmm1, %xmm0
ja 0xff5c
movq %rax, %r12
jmp 0xff62
movq %rbx, %r12
movq %rax, %rbx
minsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movq 0x10(%r12), %rdi
callq 0x39194
movq %r12, %rdi
callq 0x39194
movapd (%rsp), %xmm0
ucomisd 0x92e4e(%rip), %xmm0    # 0xa2dd8
jbe 0xff99
leal 0x1(%r13), %eax
cmpl $0x9, %r13d
movl %eax, %r13d
jb 0xff1a
movq %r14, %rdi
callq 0xf392
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/data.c
// Function: normalize_regression_values
void normalize_regression_values(Instanceptr myptr, double mean, double variance)
{
 /*!Last Changed 21.12.2005*/
 Instanceptr tmp;
 int classfno;
 NORMALIZATION_TYPE normtype = get_parameter_l("normalization");
 classfno = current_dataset->classdefno;
 tmp = myptr;
 while (tmp)
  {
   switch (normtype)
    {
     case        Z_NORMALIZATION:
     case   VECTOR_NORMALIZATION:tmp->values[classfno].floatvalue = (tmp->values[classfno].floatvalue - mean) / sqrt(variance);
                                 break;
     case STANDARD_NORMALIZATION:tmp->values[classfno].floatvalue = (tmp->values[classfno].floatvalue - current_dataset->features[classfno].min.floatvalue) / (current_dataset->features[classfno].max.floatvalue - current_dataset->features[classfno].min.floatvalue);
                                 break;
    }
   
   tmp = tmp->next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm1, (%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rdi, %rbx
leaq 0x931e3(%rip), %rdi     # 0xa3360
callq 0x535f7
movsd (%rsp), %xmm3
testq %rbx, %rbx
je 0x10251
movl %eax, %ebp
leaq 0xc26d7(%rip), %r14     # 0xd2870
movq (%r14), %rax
movslq 0x1407128(%rax), %r15
sqrtsd %xmm3, %xmm4
xorpd %xmm5, %xmm5
imulq $0x340, %r15, %r12      # imm = 0x340
movsd %xmm4, 0x8(%rsp)
cmpl $0x2, %ebp
je 0x101c6
cmpl $0x1, %ebp
je 0x10212
testl %ebp, %ebp
jne 0x10244
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm1
ucomisd %xmm5, %xmm3
movapd %xmm4, %xmm0
jae 0x101fd
movapd %xmm3, %xmm0
movsd %xmm1, 0x10(%rsp)
callq 0x4300
movsd 0x10(%rsp), %xmm1
xorpd %xmm5, %xmm5
movsd 0x8(%rsp), %xmm4
movsd (%rsp), %xmm3
subsd 0x18(%rsp), %xmm1
divsd %xmm0, %xmm1
movq (%rbx), %rax
movsd %xmm1, (%rax,%r15,8)
jmp 0x10244
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
movq (%r14), %rcx
movsd 0x30f10(%rcx,%r12), %xmm1
movsd 0x30f18(%rcx,%r12), %xmm2
subsd %xmm1, %xmm0
subsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movsd %xmm0, (%rax,%r15,8)
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x101b8
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/data.c
// Function: unnormalize_instance
void unnormalize_instance(Instanceptr myptr, Instance mean, Instance variance)
{
 int i;
 Instanceptr temp;
 temp = myptr;
 if (mustrealize)
  {
   for (i = 0; i < current_dataset->multifeaturecount; i++)
     if (i != current_dataset->classdefno)
       temp->values[i].floatvalue = (double) (temp->values[i].floatvalue * sqrt(variance.values[i].floatvalue) + mean.values[i].floatvalue);
  }
 else
  {
   for (i = 0; i < current_dataset->featurecount; i++)
     switch (current_dataset->features[i].type)
      {
       case INTEGER:temp->values[i].intvalue = (int) (temp->values[i].floatvalue * sqrt(variance.values[i].floatvalue) + mean.values[i].floatvalue);
                    break;
       case    REAL:temp->values[i].floatvalue = (double) (temp->values[i].floatvalue * sqrt(variance.values[i].floatvalue) + mean.values[i].floatvalue);
                    break;
      }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x70(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x39ed27(%rip), %rax    # 0x3aefa4
cmpl $0x0, (%rax)
leaq 0xc25e9(%rip), %r14     # 0xd2870
movq (%r14), %rax
je 0x10309
cmpl $0x0, 0x1c0(%rax)
jle 0x103d5
movq (%rdx), %r15
movq (%rcx), %r12
xorl %r13d, %r13d
xorpd %xmm1, %xmm1
movl 0x1407128(%rax), %eax
cmpq %rax, %r13
je 0x102f2
movq (%rbx), %rax
movsd (%rax,%r13,8), %xmm2
movsd (%r15,%r13,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x102cc
sqrtsd %xmm0, %xmm0
jmp 0x102df
movsd %xmm2, (%rsp)
callq 0x4300
movsd (%rsp), %xmm2
xorpd %xmm1, %xmm1
mulsd %xmm0, %xmm2
addsd (%r12,%r13,8), %xmm2
movq (%rbx), %rax
movsd %xmm2, (%rax,%r13,8)
incq %r13
movq (%r14), %rax
movslq 0x1c0(%rax), %rcx
cmpq %rcx, %r13
jl 0x102a6
jmp 0x103d5
cmpl $0x0, 0x1bc(%rax)
jle 0x103d5
movq (%rdx), %r15
movq (%rcx), %r12
movl $0x61e1, %r13d          # imm = 0x61E1
xorl %ebp, %ebp
xorpd %xmm1, %xmm1
movl (%rax,%r13,8), %eax
cmpl $0x2, %eax
je 0x10353
testl %eax, %eax
jne 0x103bb
movq (%rbx), %rax
movsd (%rax,%rbp,8), %xmm2
movsd (%r15,%rbp,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x1036d
sqrtsd %xmm0, %xmm0
jmp 0x10380
movq (%rbx), %rax
movsd (%rax,%rbp,8), %xmm2
movsd (%r15,%rbp,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x10396
sqrtsd %xmm0, %xmm0
jmp 0x103a9
movsd %xmm2, (%rsp)
callq 0x4300
movsd (%rsp), %xmm2
xorpd %xmm1, %xmm1
mulsd %xmm0, %xmm2
addsd (%r12,%rbp,8), %xmm2
cvttsd2si %xmm2, %eax
movq (%rbx), %rcx
movl %eax, (%rcx,%rbp,8)
jmp 0x103bb
movsd %xmm2, (%rsp)
callq 0x4300
movsd (%rsp), %xmm2
xorpd %xmm1, %xmm1
mulsd %xmm0, %xmm2
addsd (%r12,%rbp,8), %xmm2
movq (%rbx), %rax
movsd %xmm2, (%rax,%rbp,8)
incq %rbp
movq (%r14), %rax
movslq 0x1bc(%rax), %rcx
addq $0x68, %r13
cmpq %rcx, %rbp
jl 0x10328
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/data.c
// Function: normalize
void normalize(Instanceptr myptr, Instance mean, Instance variance)
{
 /*!Last Changed 20.03.2002*/
 Instanceptr temp;
 temp = myptr;
 while (temp)
  {
   normalize_instance(temp, mean, variance);
   temp = temp->next;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x10830
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0xb0(%rsp), %r14
leaq 0x80(%rsp), %r15
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x50(%rsp)
movups %xmm1, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x103e4
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x107dd
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq