LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x98195(%rip), %rdx     # 0xa6055
movl $0x8, %esi
movl $0x5, %ecx
callq 0x3a1fc
movq %rax, %r12
testl %ebx, %ebx
jle 0xdf14
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movsd 0x97ec0(%rip), %xmm0    # 0xa5da8
testl %r15d, %r15d
jle 0xdf0c
xorl %edx, %edx
movq (%r14,%rdx,8), %rsi
movsd (%rsi,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xdf04
movsd %xmm1, (%r12,%rcx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xdeef
incq %rcx
cmpq %rbx, %rcx
jne 0xdee8
movq %r12, %rdi
movl %ebx, %esi
callq 0x38031
movl %eax, %ebx
movq %r12, %rdi
callq 0x3a180
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x98108(%rip), %rdx     # 0xa6061
movl $0x8, %esi
movl $0x5, %ecx
callq 0x3a1fc
movq %rax, %r12
testl %ebx, %ebx
jle 0xdfad
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movsd 0x980bf(%rip), %xmm0    # 0xa6040
testl %r15d, %r15d
jle 0xdfa5
xorl %edx, %edx
movq (%r14,%rdx,8), %rsi
movsd (%rsi,%rcx,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xdf9d
movsd %xmm1, (%r12,%rcx,8)
incq %rdx
cmpq %rdx, %rax
jne 0xdf88
incq %rcx
cmpq %rbx, %rcx
jne 0xdf81
movq %r12, %rdi
movl %ebx, %esi
callq 0x38031
movl %eax, %ebx
movq %r12, %rdi
callq 0x3a180
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9807b(%rip), %rdx     # 0xa606d
movl $0x8, %esi
movl $0x5, %ecx
callq 0x3a1fc
movq %rax, %r12
testl %ebx, %ebx
jle 0xe052
movl %r15d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
movsd 0x974fc(%rip), %xmm0    # 0xa5520
movq %rdx, (%r12,%rcx,8)
testl %r15d, %r15d
jle 0xe04a
xorl %esi, %esi
movapd %xmm0, %xmm1
movq (%r14,%rsi,8), %rdi
mulsd (%rdi,%rcx,8), %xmm1
movsd %xmm1, (%r12,%rcx,8)
incq %rsi
cmpq %rsi, %rax
jne 0xe033
incq %rcx
cmpq %rbx, %rcx
jne 0xe024
movq %r12, %rdi
movl %ebx, %esi
callq 0x38031
movl %eax, %ebx
movq %r12, %rdi
callq 0x3a180
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x97fe0(%rip), %r13     # 0xa607a
movl $0x8, %esi
movq %r13, %rdx
movl $0x5, %ecx
callq 0x3a1fc
movq %rax, (%rsp)
movslq %r15d, %rdi
movl $0x8, %esi
movq %r13, %rdx
movl $0x6, %ecx
callq 0x3a1fc
movq %rbx, %r12
testl %ebx, %ebx
jle 0xe12c
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 0xe110
xorl %eax, %eax
movsd 0x97428(%rip), %xmm0    # 0xa5520
movq (%r14,%rax,8), %rcx
mulsd (%rcx,%rbx,8), %xmm0
movsd %xmm0, (%r13,%rbx,8)
incq %rax
cmpq %rax, %rbp
jne 0xe0f8
movq %r13, %rdi
movl %r15d, %esi
callq 0x38218
movq (%rsp), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
cmpq %r12, %rbx
jne 0xe0da
movq (%rsp), %r14
movq %r14, %rdi
movl %r12d, %esi
callq 0x38031
movl %eax, %ebx
movq %r14, %rdi
callq 0x3a180
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_O3/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 0xe1b6
movslq 0xc732f(%rip), %r15     # 0xd54b0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r15, %r15
jle 0xe1c0
movq %rdi, %r14
movq 0xc7313(%rip), %r13     # 0xd54a8
xorl %r12d, %r12d
movq (%r13), %rsi
movq %r14, %rdi
callq 0x4260
testl %eax, %eax
je 0xe1bd
incq %r12
addq $0x68, %r13
cmpq %r12, %r15
jne 0xe198
jmp 0xe1c0
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0xe1c0
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0xc72dd(%rip)     # 0xd54b0
jle 0xe26e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa2c60(%rip), %r14     # 0xb0e4b
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0xc72b0(%rip), %rax     # 0xd54a8
movq (%rax,%r15), %rdi
movq %rbx, %rsi
callq 0x3b2cd
movq 0xc729d(%rip), %rcx     # 0xd54a8
cmpl $-0x1, %eax
jne 0xe242
movq 0x28(%rcx,%r15), %rdi
movq %rbx, %rsi
callq 0x3b2cd
movq 0xc7284(%rip), %rcx     # 0xd54a8
cmpl $-0x1, %eax
jne 0xe242
movq 0x30(%rcx,%r15), %rdi
movq %rbx, %rsi
callq 0x3b2cd
cmpl $-0x1, %eax
je 0xe250
movq 0xc7266(%rip), %rcx     # 0xd54a8
movq (%rcx,%r15), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x4030
incq %r12
movslq 0xc7256(%rip), %rax     # 0xd54b0
addq $0x68, %r15
cmpq %rax, %r12
jl 0xe1f1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl $0xa, %edi
jmp 0x40d0
// File: /workspace/github_c_makefile_star2_O3/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, 0xc7231(%rip)     # 0xd54b0
movq 0xc7222(%rip), %rdi     # 0xd54a8
jle 0x3a180
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x38, %ebx
xorl %r14d, %r14d
imulq $0x68, %r14, %r15
movq (%rdi,%r15), %rax
testq %rax, %rax
je 0xe2b8
movq %rax, %rdi
callq 0x3a180
movq 0xc71f0(%rip), %rdi     # 0xd54a8
movq 0x8(%rdi,%r15), %rax
testq %rax, %rax
je 0xe2d1
movq %rax, %rdi
callq 0x3a180
movq 0xc71d7(%rip), %rdi     # 0xd54a8
movq 0x10(%rdi,%r15), %rax
testq %rax, %rax
je 0xe2ea
movq %rax, %rdi
callq 0x3a180
movq 0xc71be(%rip), %rdi     # 0xd54a8
movq 0x18(%rdi,%r15), %rax
testq %rax, %rax
je 0xe303
movq %rax, %rdi
callq 0x3a180
movq 0xc71a5(%rip), %rdi     # 0xd54a8
movq 0x20(%rdi,%r15), %rax
testq %rax, %rax
je 0xe31c
movq %rax, %rdi
callq 0x3a180
movq 0xc718c(%rip), %rdi     # 0xd54a8
movq 0x28(%rdi,%r15), %rax
testq %rax, %rax
je 0xe335
movq %rax, %rdi
callq 0x3a180
movq 0xc7173(%rip), %rdi     # 0xd54a8
movq 0x30(%rdi,%r15), %rax
testq %rax, %rax
je 0xe34e
movq %rax, %rdi
callq 0x3a180
movq 0xc715a(%rip), %rdi     # 0xd54a8
cmpl $0x0, 0x60(%rdi,%r15)
jle 0xe379
xorl %r12d, %r12d
addq %rbx, %rdi
movq (%rdi,%r12,8), %rdi
callq 0x3a180
incq %r12
movq 0xc7139(%rip), %rdi     # 0xd54a8
movslq 0x60(%rdi,%r15), %rax
cmpq %rax, %r12
jl 0xe359
incq %r14
movslq 0xc712d(%rip), %rax     # 0xd54b0
addq $0x68, %rbx
cmpq %rax, %r14
jl 0xe29c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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 0xc70f0(%rip), %rax     # 0xd54a8
movslq %edi, %rcx
imulq $0x68, %rcx, %rbp
movq (%rax,%rbp), %rdx
leaq 0x97ce6(%rip), %rbx     # 0xa60b0
leaq 0x97ce6(%rip), %rsi     # 0xa60b7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc70c6(%rip), %rax     # 0xd54a8
movq 0x8(%rax,%rbp), %rdx
leaq 0x97cd2(%rip), %rsi     # 0xa60c0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc70a9(%rip), %rax     # 0xd54a8
movq 0x10(%rax,%rbp), %rdx
leaq 0x97cc4(%rip), %rsi     # 0xa60cf
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc708c(%rip), %rax     # 0xd54a8
movq 0x20(%rax,%rbp), %rdx
leaq 0x97cb9(%rip), %rsi     # 0xa60e1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc706f(%rip), %rax     # 0xd54a8
movq 0x18(%rax,%rbp), %rdx
leaq 0x97ca5(%rip), %rsi     # 0xa60ea
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc7052(%rip), %rax     # 0xd54a8
movq 0x28(%rax,%rbp), %rdx
leaq 0x97c91(%rip), %rsi     # 0xa60f3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc7035(%rip), %rax     # 0xd54a8
movq 0x30(%rax,%rbp), %rdx
leaq 0x97c7b(%rip), %rsi     # 0xa60fa
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xc7018(%rip), %rax     # 0xd54a8
cmpl $0x0, 0x60(%rax,%rbp)
jle 0xe4fb
leaq 0x38(%rbp), %rbx
leaq 0x97c6d(%rip), %r15     # 0xa610f
movq %rsp, %r12
xorl %r13d, %r13d
leaq 0x1(%r13), %r14
leaq 0x9d831(%rip), %rdi     # 0xabce4
leaq 0x97c4d(%rip), %rsi     # 0xa6107
movl %r14d, %edx
xorl %eax, %eax
callq 0x4030
movq 0xc6fdd(%rip), %rax     # 0xd54a8
addq %rbx, %rax
movq (%rax,%r13,8), %rdx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x41b0
movq %r12, %rdi
callq 0x8a797
movq 0xc6fba(%rip), %rax     # 0xd54a8
movslq 0x60(%rax,%rbp), %rax
movq %r14, %r13
cmpq %rax, %r14
jl 0xe4a8
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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 0x9793b(%rip), %rsi     # 0xa6139
movl $0x18, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r14
movq (%rax), %rdi
movq %r15, %rsi
callq 0x3b494
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
testq %r12, %r12
je 0xe869
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3b3a8
testl %eax, %eax
js 0xe85a
movq %r12, %r13
movq 0x8(%r12), %r12
testq %r12, %r12
je 0xe862
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3b3a8
testl %eax, %eax
jns 0xe83b
jmp 0xe85d
xorl %r13d, %r13d
testq %r13, %r13
je 0xe869
addq $0x8, %r13
movq %r13, %rbx
movq (%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x97884(%rip), %rsi     # 0xa614b
movl $0x18, %edi
movl $0x3, %edx
callq 0x3a0e1
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq (%rax), %rdi
leaq 0x97877(%rip), %rsi     # 0xa6161
callq 0x3b494
movq %rax, (%rbx)
movl 0xc6bb7(%rip), %r15d    # 0xd54b0
testl %r15d, %r15d
jle 0xe9e0
movq 0xc6b9f(%rip), %r12     # 0xd54a8
xorl %ebp, %ebp
imulq $0x68, %rbp, %r14
movq (%r12,%r14), %rdi
leaq 0x97850(%rip), %rsi     # 0xa616a
callq 0x4260
testl %eax, %eax
je 0xe9d1
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0xe957
addq %r14, %r12
movq 0x8(%r12), %r12
movq (%r15), %rsi
movq %r12, %rdi
callq 0x3b3a8
testl %eax, %eax
je 0xe967
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xe938
movq 0xc6b51(%rip), %r12     # 0xd54a8
movq 0x8(%r12,%r14), %rsi
movq %rbx, %rdi
callq 0xe7e0
movq %rax, %r15
movq 0xc6b3a(%rip), %rax     # 0xd54a8
movq 0x10(%rax,%r14), %r13
movq 0x10(%r15), %r12
testq %r12, %r12
je 0xe9a2
movq (%r12), %rsi
movq %r13, %rdi
callq 0x3b3a8
testl %eax, %eax
je 0xe9b0
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0xe97c
movq 0xc6b0b(%rip), %rax     # 0xd54a8
movq 0x10(%rax,%r14), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0xe7e0
movq %rax, %r12
movq 0xc6af1(%rip), %rax     # 0xd54a8
movq (%rax,%r14), %rsi
movq %r12, %rdi
callq 0xe7e0
movq 0xc6ade(%rip), %r12     # 0xd54a8
movl 0xc6adf(%rip), %r15d    # 0xd54b0
incq %rbp
movslq %r15d, %rax
cmpq %rax, %rbp
jl 0xe90b
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_O3/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 0xea0f
movl %ebx, %ebp
movl $0x9, %edi
callq 0x40d0
decl %ebp
jne 0xea01
movq (%r14), %rdi
callq 0x4090
movq 0x10(%r14), %r14
testq %r14, %r14
je 0xea35
incl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0xe9f2
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xea22
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xea53
callq 0xea41
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xea61
callq 0xea41
movq (%rbx), %rdi
callq 0x3a180
movq %rbx, %rdi
popq %rbx
jmp 0x3a180
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x9776e(%rip), %rsi     # 0xa61f0
movl $0x50, %edi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %rbx
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x20(%r14), %rdi
movq 0x28(%r14), %rsi
callq 0x3dae3
movq %rax, 0x20(%rbx)
movq %rdx, 0x28(%rbx)
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
callq 0x3dae3
movq %rax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movq 0x30(%r14), %rdi
movl (%r14), %esi
shll $0x3, %esi
callq 0x37a5f
movq %rax, 0x30(%rbx)
movq 0x38(%r14), %rdi
movl 0x14(%r14), %esi
shll $0x3, %esi
callq 0x37a5f
movq %rax, 0x38(%rbx)
movq 0x48(%r14), %rdi
movl 0x8(%r14), %esi
shll $0x2, %esi
callq 0x37a5f
movq %rax, 0x48(%rbx)
movq 0x40(%r14), %rdi
movl 0x14(%r14), %eax
leal -0x4(,%rax,4), %esi
callq 0x37a5f
movq %rax, 0x40(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3a180
movq 0x20(%rbx), %rdi
callq 0x3a180
movq 0x28(%rbx), %rdi
callq 0x3a180
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x3ed51
movq %rbx, %rdi
popq %rbx
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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 0x3a180
movq 0x40(%rbx), %rdi
callq 0x3a180
movq 0x38(%rbx), %rdi
callq 0x3a180
movq 0x30(%rbx), %rdi
callq 0x3a180
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rsi
popq %rbx
jmp 0x3ed51
// File: /workspace/github_c_makefile_star2_O3/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 0xf440
movq 0x20(%rdi), %rdx
movl %ecx, %esi
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
movsd 0x96103(%rip), %xmm0    # 0xa5518
xorl %r8d, %r8d
cmpl $0x0, (%rdx,%r8,4)
jne 0xf436
movq 0x18(%rdi), %r9
movsd (%r9,%r8,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xf436
movl %r8d, %ecx
movapd %xmm1, %xmm0
incq %r8
cmpq %r8, %rsi
jne 0xf418
jmp 0xf44d
movsd 0x960d0(%rip), %xmm0    # 0xa5518
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_O3/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 0xf656
movslq %ecx, %rcx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %rax, %rdi
sarq $0x20, %rdi
movl %edx, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movsd 0x95ef9(%rip), %xmm1    # 0xa5518
xorl %r8d, %r8d
xorpd %xmm0, %xmm0
movq (%rsi,%r8,8), %r9
movsd (%r9,%rcx,8), %xmm3
ucomisd %xmm0, %xmm3
jbe 0xf64d
movsd (%r9,%rdi,8), %xmm2
divsd %xmm3, %xmm2
ucomisd %xmm2, %xmm1
jbe 0xf64d
movl %r8d, %eax
movapd %xmm2, %xmm1
incq %r8
cmpq %r8, %rdx
jne 0xf626
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf769
movq 0x40(%rdi), %rsi
movl %edx, %r8d
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movsd 0x95e8b(%rip), %xmm0    # 0xa5518
xorl %r9d, %r9d
movabsq $-0x100000000, %r10     # imm = 0xFFFFFFFF00000000
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm1
cmpl $0x0, (%rsi,%r9,4)
jne 0xf75b
movq 0x38(%rdi), %r11
movsd (%r11,%r9,8), %xmm3
ucomisd %xmm3, %xmm1
jbe 0xf75b
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 0xf728
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 0xf71e
movsd (%r13,%r15,8), %xmm5
divsd %xmm6, %xmm5
ucomisd %xmm5, %xmm4
jbe 0xf71e
movl %r12d, %ebp
movapd %xmm5, %xmm4
incq %r12
cmpq %r12, %rcx
jne 0xf6f5
jmp 0xf72d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
addl %ebx, %ebx
movslq %ebx, %rbx
cmpq %rbx, %r9
jge 0xf754
addl %r9d, %r11d
movslq %r11d, %rbx
cmpl $0x0, (%rsi,%rbx,4)
je 0xf754
testl %ebp, %ebp
js 0xf75b
movq 0x48(%rdi), %rbx
movl %ebp, %r14d
cmpl %r11d, (%rbx,%r14,4)
jne 0xf75b
movl %r9d, %edx
movapd %xmm3, %xmm1
incq %r9
cmpq %r8, %r9
jne 0xf6a2
jmp 0xf776
movsd 0x95da7(%rip), %xmm1    # 0xa5518
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_O3/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 0xf7d1
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 0xf7b9
testl %edi, %edi
jle 0xf840
movl %ecx, %ecx
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %r10d, %r10d
movapd 0x969e8(%rip), %xmm0    # 0xa61d0
cmpq %rcx, %r10
je 0xf838
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 0xf838
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 0xf81a
incq %r10
cmpq %rdi, %r10
jne 0xf7e8
testl %eax, %eax
jle 0xf870
movsd (%rdx,%r8,8), %xmm0
xorpd 0x9697e(%rip), %xmm0    # 0xa61d0
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 0xf854
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x96a59(%rip), %rdi     # 0xa62fa
callq 0x4090
testl %r13d, %r13d
jle 0xf907
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
leaq 0x969c1(%rip), %rbp     # 0xa627a
xorl %ebx, %ebx
movq 0x10(%rsp), %rax
movl (%rax,%rbx,4), %esi
leaq 0x969ab(%rip), %rdi     # 0xa6275
xorl %eax, %eax
callq 0x4030
testl %r12d, %r12d
jle 0xf8f5
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 0xf8d9
movl $0xa, %edi
callq 0x40d0
incq %rbx
cmpq %r13, %rbx
jne 0xf8bb
leaq 0x96973(%rip), %rdi     # 0xa6281
xorl %eax, %eax
callq 0x4030
testl %r12d, %r12d
movq 0x8(%rsp), %r15
jle 0xf940
xorl %ebx, %ebx
leaq 0x96952(%rip), %r14     # 0xa627a
movsd (%r15,%rbx,8), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x4030
incq %rbx
cmpq %rbx, %r12
jne 0xf928
movl $0xa, %edi
callq 0x40d0
leaq 0x969a9(%rip), %rdi     # 0xa62fa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O3/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 0x3a0b4
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rdi
leaq 0x1(%r14), %r15
leaq 0x8(,%r14,8), %r12
movq %r12, %rsi
movl %r15d, %edx
callq 0x3a0b4
movq %rax, 0x18(%rbx)
movq 0x10(%rbx), %rcx
movslq 0x4(%rbx), %rdx
movq (%rcx,%rdx,8), %rdi
testq %r14, %r14
jle 0xfded
xorl %esi, %esi
movsd (%rdi,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %r14
jne 0xfddb
movslq 0xc(%rbx), %rsi
movsd -0x8(%rdi,%rsi,8), %xmm0
movsd %xmm0, (%rax,%r14,8)
testl %edx, %edx
jle 0xfe4f
xorl %r13d, %r13d
movq (%rcx,%r13,8), %rdi
movslq 0xc(%rbx), %rax
movsd -0x8(%rdi,%rax,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rsi
movl %r15d, %edx
callq 0x3a0b4
movq 0x10(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x10(%rbx), %rcx
movq (%rcx,%r13,8), %rax
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax,%r14,8)
incq %r13
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jl 0xfe04
movq (%rcx,%rax,8), %rdi
callq 0x3a180
movslq 0x8(%rbx), %rax
leaq -0x1(%rax), %rdx
movl %edx, 0x8(%rbx)
movq 0x10(%rbx), %rdi
leaq -0x8(,%rax,8), %rsi
callq 0x3a0b4
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_O3/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 0xfee7
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 0xfeb9
incq %rsi
cmpq %rsi, %rax
jne 0xfea3
jmp 0xfee7
movq %rbx, %rdi
callq 0xfae7
movq %rax, %rbx
movq %rax, %rdi
callq 0xf964
movsd 0x95f04(%rip), %xmm0    # 0xa5dd8
ucomisd 0x8(%rax), %xmm0
jae 0xfedf
xorl %eax, %eax
popq %rbx
retq
movq %rbx, %rdi
callq 0xfd76
movq %rbx, %rdi
popq %rbx
jmp 0xf964
// File: /workspace/github_c_makefile_star2_O3/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, %r14
callq 0xea74
movq %rax, %rbx
xorl %r13d, %r13d
movq %rax, %rdi
xorl %esi, %esi
callq 0xffd9
movq %rax, %r15
movsd 0x8(%rax), %xmm0
andpd 0x962bb(%rip), %xmm0    # 0xa61e0
ucomisd 0x95eab(%rip), %xmm0    # 0xa5dd8
jbe 0xffc0
movapd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xf3aa
movq %r14, %rdi
callq 0xea74
movq %rax, %rbx
movq %rax, %rdi
movl $0x1, %esi
callq 0xffd9
movq %rax, %r12
movsd 0x8(%rax), %xmm1
andpd 0x96278(%rip), %xmm1    # 0xa61e0
movapd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xff8e
movq 0x10(%r15), %rdi
movapd %xmm1, (%rsp)
callq 0x3a180
movq %r15, %rdi
callq 0x3a180
movq %r12, %r15
jmp 0xffa0
movq 0x10(%r12), %rdi
callq 0x3a180
movq %r12, %rdi
callq 0x3a180
movapd (%rsp), %xmm0
ucomisd 0x95e2b(%rip), %xmm0    # 0xa5dd8
jbe 0xffc0
leal 0x1(%r13), %eax
cmpl $0x9, %r13d
movl %eax, %r13d
jb 0xff33
movq %rbx, %rdi
callq 0xf3aa
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x961bb(%rip), %rdi     # 0xa6360
callq 0x54afc
movsd (%rsp), %xmm3
testq %rbx, %rbx
je 0x10279
movl %eax, %ebp
leaq 0xc56af(%rip), %r14     # 0xd5870
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 0x101ee
cmpl $0x1, %ebp
je 0x1023a
testl %ebp, %ebp
jne 0x1026c
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm1
ucomisd %xmm5, %xmm3
movapd %xmm4, %xmm0
jae 0x10225
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 0x1026c
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 0x101e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3a1cff(%rip), %rax    # 0x3b1fa4
cmpl $0x0, (%rax)
leaq 0xc55c1(%rip), %r14     # 0xd5870
movq (%r14), %rax
je 0x10331
cmpl $0x0, 0x1c0(%rax)
jle 0x103fd
movq (%rdx), %r15
movq (%rcx), %r12
xorl %r13d, %r13d
xorpd %xmm1, %xmm1
movl 0x1407128(%rax), %ecx
cmpq %rcx, %r13
je 0x1031d
movq (%rbx), %rax
movsd (%rax,%r13,8), %xmm2
movsd (%r15,%r13,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x102f4
sqrtsd %xmm0, %xmm0
jmp 0x10307
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)
movq (%r14), %rax
incq %r13
movslq 0x1c0(%rax), %rcx
cmpq %rcx, %r13
jl 0x102ce
jmp 0x103fd
cmpl $0x0, 0x1bc(%rax)
jle 0x103fd
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 0x1037b
testl %eax, %eax
jne 0x103e3
movq (%rbx), %rax
movsd (%rax,%rbp,8), %xmm2
movsd (%r15,%rbp,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x10395
sqrtsd %xmm0, %xmm0
jmp 0x103a8
movq (%rbx), %rax
movsd (%rax,%rbp,8), %xmm2
movsd (%r15,%rbp,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x103be
sqrtsd %xmm0, %xmm0
jmp 0x103d1
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 0x103e3
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 0x10350
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/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 0x10826
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 0x1040c
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x107d3
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/data.c
// Function: realize_instance
void realize_instance(Instanceptr myptr)
{
 Instanceptr tmp = myptr;
 int i, j, k;
 i = current_dataset->featurecount - 1;
 j = current_dataset->multifeaturecount - 1;
 if (i != j)
  tmp->values = (union value *) alloc(tmp->values, current_dataset->multifeaturecount * sizeof(union value), current_dataset->multifeaturecount);
 while (i >= 0)
  {
   switch (current_dataset->features[i].type)
    {
     case INTEGER  :tmp->values[j].floatvalue = (double) tmp->values[i].intvalue;
                    j--;
                    break;
     case REGDEF   :
     case REAL     :tmp->values[j].floatvalue = tmp->values[i].floatvalue;
                    j--;
                    break;
     case CLASSDEF :tmp->values[j].stringindex = tmp->values[i].stringindex;
                    j--;
                    break;
     case STRING   :for (k = 0; k < current_dataset->features[i].valuecount; k++)
                      if (k == tmp->values[i].stringindex)
                        tmp->values[j-k].floatvalue = 1;
                      else
                        tmp->values[j-k].floatvalue = 0;
                    j -= current_dataset->features[i].valuecount;
                    break;
     default       :printf(m1238, current_dataset->features[i].type);
                    break;
    }
   i--;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc5034(%rip), %r15     # 0xd5870
movq (%r15), %rax
movl 0x1bc(%rax), %r12d
movslq 0x1c0(%rax), %r14
cmpl %r14d, %r12d
je 0x10867
movq (%rbx), %rdi
movq %r14, %rsi
shlq $0x3, %rsi
movl %r14d, %edx
callq 0x3a0b4
movq %rax, (%rbx)
testl %r12d, %r12d
jle 0x10945
leal -0x1(%r14), %ebp
leaq 0x95abd(%rip), %r13     # 0xa6338
movsd 0x94c9d(%rip), %xmm1    # 0xa5520
movq %r12, %r14
decq %r12
movq (%r15), %rcx
imulq $0x340, %r12, %rax      # imm = 0x340
movl 0x30f08(%rcx,%rax), %esi
cmpq $0x4, %rsi
ja 0x1092d
movslq (%r13,%rsi,4), %rdx
addq %r13, %rdx
jmpq *%rdx
movq (%rbx), %rax
movsd (%rax,%r12,8), %xmm0
jmp 0x108d4
movq (%rbx), %rax
movl (%rax,%r12,8), %ecx
movslq %ebp, %rdx
movl %ecx, (%rax,%rdx,8)
jmp 0x108dc
movq (%rbx), %rax
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%r12,8), %xmm0
movslq %ebp, %rcx
movsd %xmm0, (%rax,%rcx,8)
decl %ebp
cmpq $0x1, %r14
jg 0x10883
jmp 0x10945
addq $0x30f08, %rcx          # imm = 0x30F08
movl 0x18(%rcx,%rax), %esi
testl %esi, %esi
jle 0x10929
movslq %ebp, %rcx
xorl %edx, %edx
movq (%rbx), %rsi
movl (%rsi,%r12,8), %edi
movapd %xmm1, %xmm0
cmpq %rdi, %rdx
je 0x1090e
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsi,%rcx,8)
incq %rdx
movq (%r15), %rsi
movslq 0x30f20(%rsi,%rax), %rsi
decq %rcx
cmpq %rsi, %rdx
jl 0x108fa
subl %esi, %ebp
jmp 0x108de
leaq 0x95a3a(%rip), %rdi     # 0xa636e
xorl %eax, %eax
callq 0x4030
movsd 0x94bdd(%rip), %xmm1    # 0xa5520
jmp 0x108de
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/data.c
// Function: realize
void realize(Instanceptr myptr)
{
 /*!Last Changed 10.03.2004 extended to regression*/
 Instanceptr tmp = myptr;
 while(tmp)
  {
   realize_instance(tmp);
   tmp = tmp->next;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1096f
pushq %rbx
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x10827
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x1095d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/data.c
// Function: dimension_reduce_with_pca
void dimension_reduce_with_pca(Instanceptr inst, int howmany, matrix eigenvect)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 Instanceptr tmp = inst;
 int i, j, k;
 double* values, sum;
 values = (double *)safemalloc((current_dataset->multifeaturecount - 1) * sizeof(double), "dimension_reduce_with_pca", 4);
 while (tmp)
  {
   for (i = 0; i < howmany; i++)
    {
     sum = 0;
     for (j = 0; j < current_dataset->multifeaturecount - 1; j++)
       sum += eigenvect.values[j][i] * real_feature(tmp, j);
     values[i] = sum;
    }
   k = 0;
   for (j = 0; j < current_dataset->multifeaturecount - 1 && k < howmany; j++)
     if (in_list(current_dataset->features[j].type, 2, REAL, INTEGER))
      {
       tmp->values[j].floatvalue = (double) values[k];
       k++;
      }
   tmp = tmp->next;
  }
 safe_free(values);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %esi, 0x4(%rsp)
movq %rdi, %r14
leaq 0xc4ee1(%rip), %r13     # 0xd5870
movq (%r13), %rax
movslq 0x1c0(%rax), %rax
leaq -0x8(,%rax,8), %rdi
leaq 0x959f0(%rip), %rsi     # 0xa6399
movl $0x4, %edx
callq 0x3a0e1
movq %rax, %r15
testq %r14, %r14
je 0x10adb
movq (%r13), %rax
movl 0x4(%rsp), %ecx
movq %rcx, 0x18(%rsp)
movq %r15, 0x10(%rsp)
cmpl $0x0, 0x4(%rsp)
jle 0x10ac9
xorl %ebp, %ebp
xorps %xmm0, %xmm0
cmpl $0x2, 0x1c0(%rax)
jl 0x10a3f
xorl %r12d, %r12d
movsd %xmm0, 0x8(%rsp)
movq (%rbx,%r12,8), %rax
movsd (%rax,%rbp,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r14, %rdi
movl %r12d, %esi
callq 0x2ed6a
mulsd 0x20(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r12
movq (%r13), %rax
movslq 0x1c0(%rax), %rcx
decq %rcx
cmpq %rcx, %r12
jl 0x109ed
movsd %xmm0, (%r15,%rbp,8)
incq %rbp
cmpq 0x18(%rsp), %rbp
jne 0x109de
cmpl $0x0, 0x4(%rsp)
setle %cl
cmpl $0x2, 0x1c0(%rax)
setl %dl
orb %cl, %dl
jne 0x10ac9
xorl %r12d, %r12d
movl $0x1, %ebp
movl $0x61e1, %r15d          # imm = 0x61E1
movl (%rax,%r15,8), %edi
movl $0x2, %esi
movl $0x2, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
je 0x10aa8
movslq %r12d, %r12
movq 0x10(%rsp), %rax
movsd (%rax,%r12,8), %xmm0
movq (%r14), %rax
movsd %xmm0, -0x8(%rax,%rbp,8)
incl %r12d
movq (%r13), %rax
movslq 0x1c0(%rax), %rcx
decq %rcx
cmpq %rcx, %rbp
jge 0x10ac9
incq %rbp
addq $0x68, %r15
cmpl 0x4(%rsp), %r12d
jl 0x10a73
movq 0x10(%r14), %r14
testq %r14, %r14
movq 0x10(%rsp), %r15
jne 0x109d1
movq %r15, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a180