LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_omnildt
void* train_omnildt(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 24.11.2004 added univariate and multivariate condition counts*/
 /*!Last Changed 22.11.2004 added possible conditioncount*/
 /*!Last Changed 04.10.2004 added writerules*/
 /*!Last Changed 23.09.2004*/
 Decisionnodeptr rootnode;
 Multildt_parameterptr p;
 p = (Multildt_parameterptr) parameters;
 rootnode = createnewnode(NULL, 1);
 rootnode->instances = *trdata;
 rootnode->possibleconditioncount = possible_condition_count(*trdata);
 create_omnildtchildren(rootnode, p);
 if (in_list(p->c45param.prunetype, 2, MODELSELECTIONPRUNING, VALIDATIONPRUNING))
  {
   if (p->c45param.prunetype == VALIDATIONPRUNING || (p->c45param.prunetype == MODELSELECTIONPRUNING && p->modelselectionmethod == MODEL_SELECTION_CV))
     prune_tree(rootnode, rootnode, *cvdata);
   else
     prune_tree_according_to_model_selection_method(rootnode, p->modelselectionmethod);
  }
 *trdata = NULL;
 return rootnode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x1
popq %rbp
xorl %edi, %edi
movl %ebp, %esi
callq 0x1ac98
movq %rax, %r14
movq (%rbx), %rdi
movq %rdi, 0x20(%rax)
callq 0x8ef98
movl %eax, 0x8c(%r14)
movq %r14, %rdi
movq %r12, %rsi
callq 0x4c613
movl (%r12), %edi
pushq $0x2
popq %rdx
movl %edx, %esi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0xb750
movl (%r12), %eax
cmpl $0x1, %eax
je 0xb733
cmpl $0x2, %eax
jne 0xb743
movl 0x18(%r12), %esi
testl %esi, %esi
jne 0xb748
movq (%r15), %rdx
movq %r14, %rdi
movq %r14, %rsi
callq 0x1b4d4
jmp 0xb750
movl 0x18(%r12), %esi
movq %r14, %rdi
callq 0x4b3a0
andq $0x0, (%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_softtree
void* train_softtree(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
	Decisionnodeptr treenode;
	Softregtree_parameterptr p;
	p = (Softregtree_parameterptr) parameters;
 treenode = createnewnode(NULL, 1);
 treenode->weight = 1.0;
 treenode->instances = *trdata;
 if (current_dataset->classno == 2)
  {
   treenode->leaftype = p->leaftype;
   if (p->leaftype == CONSTANTLEAF)
     treenode->w0 = produce_random_value(-0.01, +0.01);
   else
     treenode->w = random_matrix(current_dataset->multifeaturecount, 1, -0.01, +0.01);
   create_softtree(treenode, treenode, *cvdata, p);
  }
 else
  {
   treenode->leaftype = CONSTANTLEAF;
   treenode->w0s = random_array_double(current_dataset->classno, -0.01, +0.01);
   treenode->outputs = safemalloc(current_dataset->classno * sizeof(double), "train_softtree", 14);
   create_softtree_K_class(treenode, treenode, *cvdata, p);
  }
	*trdata = NULL;
	return treenode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edi, %edi
callq 0x1ac98
movq %rax, %r15
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%r15)
movq (%rbx), %rax
movq %rax, 0x20(%r15)
leaq 0xc1ebf(%rip), %r13     # 0xcd870
movq (%r13), %rax
movl 0x10(%rax), %edi
cmpl $0x2, %edi
jne 0xb9f0
movl (%r14), %ecx
movl %ecx, 0x60(%r15)
testl %ecx, %ecx
je 0xba41
movl 0x1c0(%rax), %edi
pushq $0x1
popq %rsi
movsd 0x8a3e7(%rip), %xmm0    # 0x95dc0
movsd 0x8a3e7(%rip), %xmm1    # 0x95dc8
callq 0x393f5
movq %rax, 0x38(%r15)
movq %rdx, 0x40(%r15)
jmp 0xba5c
andl $0x0, 0x60(%r15)
movsd 0x8a3c3(%rip), %xmm0    # 0x95dc0
movsd 0x8a3c3(%rip), %xmm1    # 0x95dc8
callq 0x35d84
movq %rax, 0x50(%r15)
movq (%r13), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x8a5ad(%rip), %rsi     # 0x95fce
pushq $0xe
popq %rdx
callq 0x34f59
movq %rax, 0x70(%r15)
movq (%r12), %rdx
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x7ef4b
jmp 0xba6e
movsd 0x8a377(%rip), %xmm0    # 0x95dc0
movsd 0x8a377(%rip), %xmm1    # 0x95dc8
callq 0x35cae
movsd %xmm0, 0x48(%r15)
movq (%r12), %rdx
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x7efa4
andq $0x0, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: test_softtree
Prediction test_softtree(Instanceptr data, void* model, void* parameters, double* posterior)
{
 int i;
	Decisionnodeptr treenode;
 Prediction predicted;
 double* output;
	treenode = (Decisionnodeptr) model;
 if (current_dataset->classno == 2)
  {
   posterior[1] = sigmoid(soft_tree_output(treenode, data));
   posterior[0] = 1 - posterior[1];
   if (posterior[0] > posterior[1])
     predicted.classno = 0;
   else
     predicted.classno = 1;
  }
 else
  {
   output = soft_tree_output_K_class(treenode, data);
   softmax(output, current_dataset->classno);
   for (i = 0; i < current_dataset->classno; i++)
     posterior[i] = output[i];
   predicted.classno = find_max_in_list_double(posterior, current_dataset->classno);
  }
 return predicted;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rdi, %rbx
leaq 0xc1ddc(%rip), %r12     # 0xcd870
movq (%r12), %rax
cmpl $0x2, 0x10(%rax)
jne 0xbace
movq %rdx, %rdi
callq 0x7dd7a
callq 0x4dd58
movsd %xmm0, 0x8(%r14)
movsd 0x89a67(%rip), %xmm1    # 0x95520
subsd %xmm0, %xmm1
movsd %xmm1, (%r14)
ucomisd %xmm0, %xmm1
jbe 0xbb1e
andl $0x0, 0x8(%rbx)
jmp 0xbb25
movq %rdx, %rdi
callq 0x7dcac
movq %rax, %r15
movq (%r12), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x4dd7c
movq (%r12), %rax
movl 0x10(%rax), %esi
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
cmpq %rax, %rcx
je 0xbb11
movsd (%r15,%rax,8), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
jmp 0xbafb
movq %r14, %rdi
callq 0x336dd
movl %eax, 0x8(%rbx)
jmp 0xbb25
movl $0x1, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: test_logistic
Prediction test_logistic(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 17.04.2005*/
 double** w, *y;
 int i, j;
 Prediction predicted;
 w = (double**) model;
 y = safemalloc(current_dataset->classno * sizeof(double), "logistic", 6);
 for (i = 0; i < current_dataset->classno; i++)
  {
   y[i] = w[i][0];
   for (j = 0; j < current_dataset->multifeaturecount - 1; j++)
     y[i] += w[i][j + 1] * real_feature(data, j);
  }
 predicted.classno = findMaxOutput(y, current_dataset->classno);
 softmax(y, current_dataset->classno);
 for (i = 0; i < current_dataset->classno; i++)
   posterior[i] = y[i]; 
 safe_free(y);
 return predicted;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, (%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x8(%rsp)
leaq 0xc1a7c(%rip), %rbp     # 0xcd870
movq (%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
leaq 0x8a1d6(%rip), %rsi     # 0x95fdd
pushq $0x6
popq %rdx
callq 0x34f59
movq %rax, %r15
movq (%rbp), %rax
xorl %ebx, %ebx
movslq 0x10(%rax), %rsi
cmpq %rsi, %rbx
jge 0xbe76
movq (%r12,%rbx,8), %rcx
movsd (%rcx), %xmm0
xorl %esi, %esi
movsd %xmm0, (%r15,%rbx,8)
movslq 0x1c0(%rax), %rcx
decq %rcx
cmpq %rcx, %rsi
jge 0xbe71
movq (%r12,%rbx,8), %rax
leaq 0x1(%rsi), %r14
movsd 0x8(%rax,%rsi,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r13, %rdi
callq 0x2aea2
mulsd 0x10(%rsp), %xmm0
addsd (%r15,%rbx,8), %xmm0
movq (%rbp), %rax
movq %r14, %rsi
jmp 0xbe2b
incq %rbx
jmp 0xbe18
movq %r15, %rdi
callq 0x339b7
movq 0x8(%rsp), %rbx
movl %eax, 0x8(%rbx)
movq (%rbp), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x4dd7c
movq (%rbp), %rax
movl 0x10(%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movq (%rsp), %rdx
cmpq %rcx, %rax
je 0xbebc
movsd (%r15,%rcx,8), %xmm0
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
jmp 0xbea7
movq %r15, %rdi
callq 0x34ff7
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_svm
void* train_svm(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 03.05.2005*/
 Partition dummyp;
 Svm_modelptr model;
 Svm_problem prob;
 Svm_parameterptr param;
 dummyp = get_two_class_partition();
 prepare_svm_problem(&prob, C_SVC, *trdata, dummyp);
 free_partition(dummyp);
 param = (Svm_parameter*) parameters;
 model = svm_train(prob, *param, 1);
 return model;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x78(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x4db9c
movq (%r14), %rdx
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x90(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x85b64
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x4dd42
leaq 0x20(%rsp), %rdi
pushq $0xb
popq %rcx
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rdi
callq 0x8362c
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: test_svm
Prediction test_svm(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 03.05.2005*/
 Prediction predicted;
 double* dec_values;
 int classno, y;
 Svm_nodeptr node;
 Svm_modelptr m;
 m = (Svm_modelptr) model;
 node = instance_to_svmnode(data);
 svm_predict_probability(m, node, posterior);
 if (m->nr_class == 2)
  {
   dec_values = safemalloc(sizeof(double), "test_svm", 7);
   svm_predict_values(m, node, dec_values);
   classno = give_classno(data);
   y = 1 - 2 * classno;
   predicted.hingeloss = hinge_loss(y, dec_values[0]);
   safe_free(dec_values);
  }
 predicted.classno = (int) svm_predict(m, node);
 safe_free(node);
 return predicted;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2add8
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x84f91
cmpl $0x2, 0x58(%r15)
jne 0xbfeb
leaq 0x8a042(%rip), %rsi     # 0x95fe6
pushq $0x8
popq %rdi
pushq $0x7
popq %rdx
callq 0x34f59
movq %rax, %r13
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x84490
movq %r12, %rdi
callq 0x2b47e
addl %eax, %eax
pushq $0x1
popq %rcx
subl %eax, %ecx
cvtsi2sd %ecx, %xmm0
movsd (%r13), %xmm1
callq 0x4077b
movsd %xmm0, 0x10(%rbx)
movq %r13, %rdi
callq 0x34ff7
movq %r15, %rdi
movq %r14, %rsi
callq 0x85125
cvttsd2si %xmm0, %eax
movl %eax, 0x8(%rbx)
movq %r14, %rdi
callq 0x34ff7
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: train_simplexsvm
void* train_simplexsvm(Instanceptr* trdata, Instanceptr *cvdata, void* parameters)
{
 /*!Last Changed 03.05.2005*/
 Svm_simplex_parameterptr param;
 param = (Svm_simplex_parameterptr) parameters;
 if (current_dataset->classno == 2)
   return solve_binary_svm(*trdata, param, 0);
 else
   if (param->problem_type == ONE_VS_ONE)
     return solve_one_vs_one_svm(trdata, param);
   else
     return solve_one_vs_rest_svm(*trdata, param);
}

// Assembly:
leaq 0xc1857(%rip), %rax     # 0xcd870
movq (%rax), %rax
cmpl $0x2, 0x10(%rax)
jne 0xc02f
movq (%rdi), %rdi
movq %rdx, %rsi
xorl %edx, %edx
jmp 0x8712f
cmpl $0x0, 0x18(%rdx)
je 0xc040
movq (%rdi), %rdi
movq %rdx, %rsi
jmp 0x87764
movq %rdx, %rsi
jmp 0x875c1
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/classification.c
// Function: test_simplexsvm
Prediction test_simplexsvm(Instanceptr data, void* model, void* parameters, double* posterior)
{
 /*!Last Changed 03.05.2005*/
 Svm_simplex_parameterptr param;
 Prediction predicted;
 param = (Svm_simplex_parameterptr) parameters;
 if (current_dataset->classno == 2)
  {
   if (test_binary_svm((Svm_binary_modelptr) model, param, data) < 0)
     predicted.classno = 0;
   else
     predicted.classno = 1;
  }
 else
   if (param->problem_type == ONE_VS_ONE)
     predicted.classno = test_one_vs_one_svm((Svm_simplex_modelptr) model, param, data);
  else
     predicted.classno = test_one_vs_rest_svm((Svm_simplex_modelptr) model, param, data);
  return predicted;
}

// Assembly:
pushq %rbx
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0xc1817(%rip), %rsi     # 0xcd870
movq (%rsi), %rsi
cmpl $0x2, 0x10(%rsi)
jne 0xc07d
movq %rax, %rdi
movq %rcx, %rsi
callq 0x874c0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0xc090
andl $0x0, 0x8(%rbx)
jmp 0xc0a7
cmpl $0x0, 0x18(%rcx)
je 0xc099
movq %rax, %rdi
movq %rcx, %rsi
callq 0x87820
jmp 0xc0a4
movl $0x1, 0x8(%rbx)
jmp 0xc0a7
movq %rax, %rdi
movq %rcx, %rsi
callq 0x876a7
movl %eax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/clustering.c
// Function: find_nearest_mean
Instanceptr find_nearest_mean(Instanceptr means, Instanceptr data, int* index)
{
	/*!Last Changed 22.03.2005*/
	double mindist, dist;
	Instanceptr temp, minindex = NULL;
	int i;
 mindist = +INT_MAX;
 i = 0;
 temp = means;
 while (temp)
  {
   dist = distance_between_instances(temp, data);
   if (dist < mindist)
    {
     mindist = dist;
     *index = i;
					minindex = temp;
    }
   temp = temp->next;
   i++;
  }
	return minindex;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movsd 0x89088(%rip), %xmm0    # 0x95518
movsd %xmm0, 0x8(%rsp)
xorl %ebp, %ebp
testq %r15, %r15
je 0xc4c7
movq %r15, %rdi
movq %r14, %rsi
callq 0x2beed
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xc4bf
movl %ebp, (%rbx)
movsd %xmm0, 0x8(%rsp)
movq %r15, %r12
movq 0x10(%r15), %r15
incl %ebp
jmp 0xc498
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/clustering.c
// Function: cluster_spreads
double* cluster_spreads(Instanceptr data, Instanceptr means, int k)
{
	/*!Last Changed 20.08.2007*/
	int i, minindex;
	double* result, dist;
	Instanceptr tmp;
	result = safecalloc(k, sizeof(double), "cluster_spreads", 3);
	tmp = data;
	while (tmp)
	 {
		 find_nearest_mean(means, tmp, &minindex);
			dist = distance_between_instances(tmp, data_x(means, minindex));
			if (dist > result[minindex])
				 result[minindex] = dist;
		 tmp = tmp->next;
	 }
	for (i = 0; i < k; i++)
   if (result[i] == 0)
     result[i] = 1.0;
   else
		   result[i] = sqrt(result[i]) / 2;
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
movslq %edx, %rdi
leaq 0x89b16(%rip), %rdx     # 0x9600a
pushq $0x8
popq %rsi
pushq $0x3
popq %rcx
callq 0x35067
movq %rax, %r14
leaq 0x4(%rsp), %r13
testq %r12, %r12
je 0xc54b
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xc470
movl 0x4(%rsp), %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x2d761
movq %r12, %rdi
movq %rax, %rsi
callq 0x2beed
movslq %ebp, %rax
ucomisd (%r14,%rax,8), %xmm0
jbe 0xc544
movsd %xmm0, (%r14,%rax,8)
movq 0x10(%r12), %r12
jmp 0xc507
xorl %r15d, %r15d
testl %ebx, %ebx
cmovlel %r15d, %ebx
movsd 0x88fc4(%rip), %xmm2    # 0x95520
xorpd %xmm3, %xmm3
movsd 0x897b8(%rip), %xmm4    # 0x95d20
cmpq %r15, %rbx
je 0xc5b3
movsd (%r14,%r15,8), %xmm1
ucomisd %xmm3, %xmm1
movapd %xmm2, %xmm0
jne 0xc57f
jnp 0xc5a8
jb 0xc587
sqrtsd %xmm1, %xmm0
jmp 0xc5a4
movapd %xmm1, %xmm0
callq 0x4300
movsd 0x89788(%rip), %xmm4    # 0x95d20
xorpd %xmm3, %xmm3
movsd 0x88f7c(%rip), %xmm2    # 0x95520
mulsd %xmm4, %xmm0
movsd %xmm0, (%r14,%r15,8)
incq %r15
jmp 0xc568
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/clustering.c
// Function: calculate_mean_of_nearest_distance
double calculate_mean_of_nearest_distance(Instanceptr data)
{
 Instanceptr temp, mininst;
 double S = 0.0;
 int N;
 int index;
 temp = data;
 N = data_size(data);
 while (temp)
  {
  	mininst = find_nearest_mean(data, temp, &index);
	  S = S + sqrt(distance_between_instances(mininst, temp));
 	 temp = temp->next;
  }
 S = S / N;
 return S;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x2c3cc
movl %eax, %ebp
leaq 0x14(%rsp), %r14
xorpd %xmm1, %xmm1
movq %rbx, %r15
testq %r15, %r15
je 0xc896
movsd %xmm1, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xc470
movq %rax, %rdi
movq %r15, %rsi
callq 0x2beed
ucomisd 0x8949f(%rip), %xmm0    # 0x95d18
jb 0xc881
sqrtsd %xmm0, %xmm0
jmp 0xc886
callq 0x4300
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movq 0x10(%r15), %r15
jmp 0xc84d
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/cn2.c
// Function: generate_candidate_for_newstar
Decisionruleptr generate_candidate_for_newstar(Decisionruleptr current, int fno, char comparison, double split, int falsepositives, int covered)
{
 Decisionruleptr result;
 Decisionconditionptr newcondition;
 result = create_copy_of_rule(current);
 newcondition = empty_condition();
 newcondition->conditiontype = UNIVARIATE_CONDITION;
 newcondition->freeparam = 1;
 newcondition->featureindex = fno;
 newcondition->comparison = comparison;
 newcondition->value = split;
 result->falsepositives = falsepositives;
 result->covered = covered;
 add_condition(result, newcondition);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movsd %xmm0, 0x8(%rsp)
movl %edx, %r14d
movl %esi, %r15d
callq 0x717f9
movq %rax, %r12
xorl %eax, %eax
callq 0x71cd1
movq $0x1, 0x3c(%rax)
movl %r15d, (%rax)
movb %r14b, 0x4(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movl %ebp, 0x8(%r12)
movl %ebx, 0x4(%r12)
movq %r12, %rdi
movq %rax, %rsi
callq 0x719fe
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/cn2.c
// Function: add_candidate_to_newstar
void add_candidate_to_newstar(Decisionruleptr candidate, Ruleset* newstar, int maxstar)
{
 Decisionruleptr tmp, tmpbefore = NULL, deleted;
 tmp = newstar->start;
 while (tmp)
  {
   if (laplace_estimate_of_rule(*tmp) > laplace_estimate_of_rule(*candidate))
     break;
   tmpbefore = tmp;
   tmp = tmp->next;
  }
 add_rule_after(newstar, tmpbefore, candidate);
 if (newstar->rulecount > maxstar)
  {
   deleted = newstar->end;
   remove_rule(newstar, newstar->end);
   free_rule(*deleted);
   safe_free(deleted);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq %rsi, %r13
movq %r12, %r15
movq (%r13), %r12
testq %r12, %r12
je 0xca0b
movq 0x30(%r12), %rax
movq %rax, 0x30(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x30(%r12), %r13
callq 0x724bd
movsd %xmm0, 0x40(%rsp)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rsp)
movupd (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
callq 0x724bd
movsd 0x40(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xc98e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x7217f
cmpl %ebp, 0x10(%rbx)
jle 0xca6d
movq 0x8(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72264
movq 0x30(%r14), %rax
movq %rax, 0x30(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x71be8
movq %r14, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34ff7
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0xd0a2
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 0x7247e
ucomisd 0x88d70(%rip), %xmm0    # 0x95d20
ja 0xd0a2
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %eax
leal (%rax,%rcx), %edx
cvtsi2sd %edx, %xmm3
xorpd %xmm2, %xmm2
testl %ecx, %ecx
je 0xd021
movapd %xmm3, %xmm1
movsd 0x40(%rsp), %xmm0
mulsd %xmm0, %xmm1
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm1
jne 0xcfe5
jnp 0xd027
cvtsi2sd %ecx, %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 0x88cfc(%rip), %xmm2    # 0x95d18
movl 0x8(%rbx), %eax
jmp 0xd027
movsd 0x40(%rsp), %xmm0
testl %eax, %eax
je 0xd070
movsd 0x884ed(%rip), %xmm1    # 0x95520
subsd %xmm0, %xmm1
mulsd %xmm3, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0xd047
jnp 0xd070
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
pushq $0x1
popq %rdi
movapd %xmm2, %xmm0
callq 0x1d59f
movsd %xmm0, 0x40(%rsp)
leaq 0x8889b(%rip), %rdi     # 0x95928
callq 0x4cdcf
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_O2/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, %r12
movq %rsi, %rbx
shrq $0x20, %rbx
movq %rsi, %rdi
sarq $0x20, %rdi
leaq 0x88bd5(%rip), %rdx     # 0x96050
pushq $0x8
popq %rsi
pushq $0x5
popq %rcx
callq 0x35067
movq %rax, %r15
xorl %eax, %eax
testl %r12d, %r12d
movl $0x0, %ecx
cmovgl %r12d, %ecx
testl %ebx, %ebx
movl $0x0, %edx
cmovgl %ebx, %edx
cmpq %rdx, %rax
je 0xd4cc
xorl %esi, %esi
cmpq %rsi, %rcx
je 0xd4c7
movq (%r14,%rsi,8), %rdi
movsd (%rdi,%rax,8), %xmm0
addsd (%r15,%rax,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
incq %rsi
jmp 0xd4a8
incq %rax
jmp 0xd4a1
movq %r15, %rdi
movl %ebx, %esi
callq 0x336dd
movl %eax, %ebx
movq %r15, %rdi
callq 0x34ff7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movq %rsi, %rbx
shrq $0x20, %rbx
movq %rsi, %rdi
sarq $0x20, %rdi
leaq 0x88b4c(%rip), %rdx     # 0x9605d
pushq $0x8
popq %rsi
pushq $0x5
popq %rcx
callq 0x35067
movq %rax, %r15
xorl %eax, %eax
testl %r12d, %r12d
movl $0x0, %ecx
cmovgl %r12d, %ecx
testl %ebx, %ebx
movl $0x0, %edx
cmovgl %ebx, %edx
movsd 0x88871(%rip), %xmm0    # 0x95db0
cmpq %rdx, %rax
je 0xd56a
xorl %esi, %esi
cmpq %rsi, %rcx
je 0xd565
movq (%r14,%rsi,8), %rdi
movsd (%rdi,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xd560
movsd %xmm1, (%r15,%rax,8)
incq %rsi
jmp 0xd546
incq %rax
jmp 0xd53f
movq %r15, %rdi
movl %ebx, %esi
callq 0x336dd
movl %eax, %ebx
movq %r15, %rdi
callq 0x34ff7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movq %rsi, %rbx
shrq $0x20, %rbx
movq %rsi, %rdi
sarq $0x20, %rdi
leaq 0x88aba(%rip), %rdx     # 0x96069
pushq $0x8
popq %rsi
pushq $0x5
popq %rcx
callq 0x35067
movq %rax, %r15
xorl %eax, %eax
testl %r12d, %r12d
movl $0x0, %ecx
cmovgl %r12d, %ecx
testl %ebx, %ebx
movl $0x0, %edx
cmovgl %ebx, %edx
movsd 0x88a6b(%rip), %xmm0    # 0x96048
cmpq %rdx, %rax
je 0xd608
xorl %esi, %esi
cmpq %rsi, %rcx
je 0xd603
movq (%r14,%rsi,8), %rdi
movsd (%rdi,%rax,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xd5fe
movsd %xmm1, (%r15,%rax,8)
incq %rsi
jmp 0xd5e4
incq %rax
jmp 0xd5dd
movq %r15, %rdi
movl %ebx, %esi
callq 0x336dd
movl %eax, %ebx
movq %r15, %rdi
callq 0x34ff7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movq %rsi, %rbx
shrq $0x20, %rbx
movq %rsi, %rdi
sarq $0x20, %rdi
leaq 0x88a28(%rip), %rdx     # 0x96075
pushq $0x8
popq %rsi
pushq $0x5
popq %rcx
callq 0x35067
movq %rax, %r15
xorl %eax, %eax
testl %r12d, %r12d
movl $0x0, %ecx
cmovgl %r12d, %ecx
testl %ebx, %ebx
movl $0x0, %edx
cmovgl %ebx, %edx
movabsq $0x3ff0000000000000, %rsi # imm = 0x3FF0000000000000
movsd 0x87e9b(%rip), %xmm0    # 0x95520
cmpq %rdx, %rax
je 0xd6b3
movq %rsi, (%r15,%rax,8)
movapd %xmm0, %xmm1
xorl %edi, %edi
cmpq %rdi, %rcx
je 0xd6ae
movq (%r14,%rdi,8), %r8
mulsd (%r8,%rax,8), %xmm1
movsd %xmm1, (%r15,%rax,8)
incq %rdi
jmp 0xd694
incq %rax
jmp 0xd685
movq %r15, %rdi
movl %ebx, %esi
callq 0x336dd
movl %eax, %ebx
movq %r15, %rdi
callq 0x34ff7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %rax
shrq $0x20, %rax
movq %rax, 0x8(%rsp)
movq %rsi, %rdi
sarq $0x20, %rdi
leaq 0x8897f(%rip), %rbx     # 0x96082
pushq $0x8
popq %r13
pushq $0x5
popq %rcx
movq %r13, %rsi
movq %rbx, %rdx
callq 0x35067
movq %rax, 0x10(%rsp)
movslq %r15d, %rbp
pushq $0x6
popq %rcx
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x35067
movq %rax, %r13
xorl %ebx, %ebx
testl %ebp, %ebp
movl $0x0, %ebp
movq %r15, %r12
cmovgl %r15d, %ebp
movq 0x8(%rsp), %rax
testl %eax, %eax
movl $0x0, %r15d
cmovgl %eax, %r15d
cmpq %r15, %rbx
je 0xd7a4
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%r13,%rbx,8)
movsd 0x87db2(%rip), %xmm0    # 0x95520
xorl %eax, %eax
cmpq %rax, %rbp
je 0xd78a
movq (%r14,%rax,8), %rcx
mulsd (%rcx,%rbx,8), %xmm0
movsd %xmm0, (%r13,%rbx,8)
incq %rax
jmp 0xd770
movq %r13, %rdi
movl %r12d, %esi
callq 0x33898
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax,%rbx,8)
incq %rbx
jmp 0xd752
movq 0x10(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x336dd
movl %eax, %ebx
movq %r14, %rdi
callq 0x34ff7
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xd831
movq %rdi, %rbx
movl 0xbfcb1(%rip), %r15d    # 0xcd4b0
movq 0xbfca2(%rip), %r12     # 0xcd4a8
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
pushq $-0x1
popq %rbp
cmpq %r14, %r15
je 0xd839
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x4260
testl %eax, %eax
je 0xd836
incq %r14
addq $0x68, %r12
jmp 0xd813
pushq $-0x2
popq %rbp
jmp 0xd839
movl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x93559(%rip), %r14     # 0xa0daf
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0xbfc4d(%rip), %rax     # 0xcd4b0
cmpq %rax, %r12
jge 0xd8d0
movq 0xbfc39(%rip), %rax     # 0xcd4a8
movq (%rax,%r15), %rdi
movq %rbx, %rsi
callq 0x35e9b
movq 0xbfc26(%rip), %rcx     # 0xcd4a8
cmpl $-0x1, %eax
jne 0xd8b9
movq 0x28(%rcx,%r15), %rdi
movq %rbx, %rsi
callq 0x35e9b
movq 0xbfc0d(%rip), %rcx     # 0xcd4a8
cmpl $-0x1, %eax
jne 0xd8b9
movq 0x30(%rcx,%r15), %rdi
movq %rbx, %rsi
callq 0x35e9b
cmpl $-0x1, %eax
je 0xd8c7
movq 0xbfbef(%rip), %rcx     # 0xcd4a8
movq (%rcx,%r15), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x4030
incq %r12
addq $0x68, %r15
jmp 0xd85c
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40d0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
pushq $0x38
popq %rbx
xorl %r14d, %r14d
movslq 0xbfbb8(%rip), %rax     # 0xcd4b0
movq 0xbfba9(%rip), %rdi     # 0xcd4a8
cmpq %rax, %r14
jge 0xd9e1
imulq $0x68, %r14, %r15
movq (%rdi,%r15), %rax
testq %rax, %rax
je 0xd924
movq %rax, %rdi
callq 0x34ff7
movq 0xbfb84(%rip), %rdi     # 0xcd4a8
movq 0x8(%rdi,%r15), %rax
testq %rax, %rax
je 0xd93d
movq %rax, %rdi
callq 0x34ff7
movq 0xbfb6b(%rip), %rdi     # 0xcd4a8
movq 0x10(%rdi,%r15), %rax
testq %rax, %rax
je 0xd956
movq %rax, %rdi
callq 0x34ff7
movq 0xbfb52(%rip), %rdi     # 0xcd4a8
movq 0x18(%rdi,%r15), %rax
testq %rax, %rax
je 0xd96f
movq %rax, %rdi
callq 0x34ff7
movq 0xbfb39(%rip), %rdi     # 0xcd4a8
movq 0x20(%rdi,%r15), %rax
testq %rax, %rax
je 0xd988
movq %rax, %rdi
callq 0x34ff7
movq 0xbfb20(%rip), %rdi     # 0xcd4a8
movq 0x28(%rdi,%r15), %rax
testq %rax, %rax
je 0xd9a1
movq %rax, %rdi
callq 0x34ff7
movq 0xbfb07(%rip), %rdi     # 0xcd4a8
movq 0x30(%rdi,%r15), %rdi
testq %rdi, %rdi
je 0xd9b0
callq 0x34ff7
xorl %r12d, %r12d
movq 0xbfaee(%rip), %rax     # 0xcd4a8
movslq 0x60(%rax,%r15), %rcx
cmpq %rcx, %r12
jge 0xd9d5
addq %rbx, %rax
movq (%rax,%r12,8), %rdi
callq 0x34ff7
incq %r12
jmp 0xd9b3
incq %r14
addq $0x68, %rbx
jmp 0xd8f1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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 0xbfa9f(%rip), %rax     # 0xcd4a8
movslq %edi, %rcx
imulq $0x68, %rcx, %rbp
movq (%rax,%rbp), %rdx
leaq 0x8869d(%rip), %rbx     # 0x960b8
leaq 0x8869d(%rip), %rsi     # 0x960bf
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xbfa75(%rip), %rax     # 0xcd4a8
movq 0x8(%rax,%rbp), %rdx
leaq 0x88689(%rip), %rsi     # 0x960c8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xbfa58(%rip), %rax     # 0xcd4a8
movq 0x10(%rax,%rbp), %rdx
leaq 0x8867b(%rip), %rsi     # 0x960d7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xbfa3b(%rip), %rax     # 0xcd4a8
movq 0x20(%rax,%rbp), %rdx
leaq 0x88670(%rip), %rsi     # 0x960e9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xbfa1e(%rip), %rax     # 0xcd4a8
movq 0x18(%rax,%rbp), %rdx
leaq 0x8865c(%rip), %rsi     # 0x960f2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xbfa01(%rip), %rax     # 0xcd4a8
movq 0x28(%rax,%rbp), %rdx
leaq 0x88648(%rip), %rsi     # 0x960fb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
movq 0xbf9e4(%rip), %rax     # 0xcd4a8
movq 0x30(%rax,%rbp), %rdx
leaq 0x88632(%rip), %rsi     # 0x96102
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4030
leaq 0x38(%rbp), %rbx
leaq 0x88632(%rip), %r15     # 0x96117
movq %rsp, %r12
xorl %r13d, %r13d
movq 0xbf9b6(%rip), %rax     # 0xcd4a8
movslq 0x60(%rax,%rbp), %rax
cmpq %rax, %r13
jge 0xdb40
leaq 0x1(%r13), %r14
leaq 0x8e101(%rip), %rdi     # 0x9bc08
leaq 0x88601(%rip), %rsi     # 0x9610f
movl %r14d, %edx
xorl %eax, %eax
callq 0x4030
movq 0xbf989(%rip), %rax     # 0xcd4a8
addq %rbx, %rax
movq (%rax,%r13,8), %rdx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x41b0
movq %r12, %rdi
callq 0x7d0b1
movq %r14, %r13
jmp 0xdaeb
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %r12
addq $0x10, %rbx
leaq 0x88314(%rip), %rsi     # 0x96141
pushq $0x18
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %r15
movq (%rax), %rdi
movq %r14, %rsi
callq 0x3604c
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
xorl %r13d, %r13d
testq %r12, %r12
je 0xde73
movq (%r12), %rsi
movq %r14, %rdi
callq 0x35f65
testl %eax, %eax
js 0xde73
movq %r12, %r13
movq 0x8(%r12), %r12
jmp 0xde54
leaq 0x8(%r13), %rax
testq %r13, %r13
cmoveq %rbx, %rax
movq (%rax), %rcx
movq %rcx, 0x8(%r15)
movq %r15, (%rax)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/command.c
// Function: child_of_command
Command_nodeptr child_of_command(Command_nodeptr root, char* st)
{
	/*!Last Changed 23.10.2005*/
	Command_nodeptr tmp;
	tmp = root->child;
	while (tmp)
	 {
		 if (strIcmp(st, tmp->command) == 0)
				 return tmp;
		 tmp = tmp->next;
	 }
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xdec0
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x35f65
testl %eax, %eax
je 0xdec0
addq $0x8, %rbx
jmp 0xdea3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x88276(%rip), %rsi     # 0x96153
pushq $0x18
popq %rdi
pushq $0x3
popq %rdx
callq 0x34f59
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq (%rax), %rdi
leaq 0x8826d(%rip), %rsi     # 0x96169
callq 0x3604c
movq %rax, (%rbx)
xorl %r12d, %r12d
movl 0xbf5a3(%rip), %ebp     # 0xcd4b0
leaq 0x8825e(%rip), %r14     # 0x96172
xorl %r13d, %r13d
movslq %ebp, %rax
cmpq %rax, %r13
jge 0xdfb8
movq 0xbf57e(%rip), %r15     # 0xcd4a8
movq (%r15,%r12), %rdi
movq %r14, %rsi
callq 0x4260
testl %eax, %eax
je 0xdfac
movq 0x8(%r15,%r12), %rsi
movq %rbx, %rdi
callq 0xde95
movq %rax, %r15
testq %rax, %rax
jne 0xdf66
movq 0xbf552(%rip), %rax     # 0xcd4a8
movq 0x8(%rax,%r12), %rsi
movq %rbx, %rdi
callq 0xde0f
movq %rax, %r15
movq 0xbf53b(%rip), %rax     # 0xcd4a8
movq 0x10(%rax,%r12), %rsi
movq %r15, %rdi
callq 0xde95
testq %rax, %rax
jne 0xdf93
movq 0xbf522(%rip), %rax     # 0xcd4a8
movq 0x10(%rax,%r12), %rsi
movq %r15, %rdi
callq 0xde0f
movq 0xbf50e(%rip), %rcx     # 0xcd4a8
movq (%rcx,%r12), %rsi
movq %rax, %rdi
callq 0xde0f
movl 0xbf504(%rip), %ebp     # 0xcd4b0
incq %r13
addq $0x68, %r12
jmp 0xdf17
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_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
cmovgl %esi, %r15d
pushq $0x9
popq %rbp
subl $0x1, %r15d
jb 0xdff1
movl %ebp, %edi
callq 0x40d0
jmp 0xdfe2
movq (%r14), %rdi
callq 0x4090
addq $0x10, %r14
incl %ebx
movq (%r14), %r14
testq %r14, %r14
je 0xe017
movq %r14, %rdi
movl %ebx, %esi
callq 0xdfca
addq $0x8, %r14
jmp 0xdfff
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe03b
callq 0xe029
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xe049
callq 0xe029
movq (%rbx), %rdi
callq 0x34ff7
movq %rbx, %rdi
popq %rbx
jmp 0x34ff7
nop
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
leaq 0x88186(%rip), %rsi     # 0x961f0
pushq $0x50
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movq %rax, %r14
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x383f4
movq %rax, 0x20(%r14)
movq %rdx, 0x28(%r14)
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0x383f4
movq %rax, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq 0x30(%rbx), %rdi
movl (%rbx), %esi
shll $0x3, %esi
callq 0x33292
movq %rax, 0x30(%r14)
movq 0x38(%rbx), %rdi
movl 0x14(%rbx), %esi
shll $0x3, %esi
callq 0x33292
movq %rax, 0x38(%r14)
movq 0x48(%rbx), %rdi
movl 0x8(%rbx), %esi
shll $0x2, %esi
callq 0x33292
movq %rax, 0x48(%r14)
movq 0x40(%rbx), %rdi
movl 0x14(%rbx), %eax
leal -0x4(,%rax,4), %esi
callq 0x33292
movq %rax, 0x40(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/convex.c
// Function: is_program_in_canonical_form
BOOLEAN is_program_in_canonical_form(Linearprogramptr program)
{
 int i;
 for (i = 0; i < program->constraintcount; i++)
   if (program->constraints.values[i][program->constraints.col - 1] < 0)
     return BOOLEAN_FALSE;
 return BOOLEAN_TRUE;
}

// Assembly:
movl 0x4(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
pushq $0x1
popq %rax
xorpd %xmm0, %xmm0
cmpq %rdx, %rcx
je 0xe8e1
movq 0x10(%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
movslq 0xc(%rdi), %r8
incq %rdx
ucomisd -0x8(%rsi,%r8,8), %xmm0
jbe 0xe8c2
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x34ff7
movq 0x20(%rbx), %rdi
callq 0x34ff7
movq 0x28(%rbx), %rdi
callq 0x34ff7
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x3929f
movq %rbx, %rdi
popq %rbx
jmp 0x34ff7
// File: /workspace/github_c_makefile_star2_O2/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 0x34ff7
movq 0x40(%rbx), %rdi
callq 0x34ff7
movq 0x38(%rbx), %rdi
callq 0x34ff7
movq 0x30(%rbx), %rdi
callq 0x34ff7
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rsi
popq %rbx
jmp 0x3929f
// File: /workspace/github_c_makefile_star2_O2/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), %eax
addl (%rdi), %eax
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movsd 0x86ba1(%rip), %xmm0    # 0x95518
pushq $-0x2
popq %rcx
cmpq %rdx, %rax
je 0xe9a3
movq 0x20(%rdi), %rsi
cmpl $0x0, (%rsi,%rdx,4)
jne 0xe99e
movq 0x18(%rdi), %rsi
movsd (%rsi,%rdx,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xe99e
movl %edx, %ecx
movapd %xmm1, %xmm0
incq %rdx
jmp 0xe97a
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
pushq $-0x2
popq %rax
cmoval %eax, %ecx
pushq $-0x1
popq %rax
cmovnel %ecx, %eax
cmovpl %ecx, %eax
retq