LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softregtree.c
// Function: soft_regtree_output
double soft_regtree_output(Regressionnodeptr node, Instanceptr inst)
{
 if (node->featureno == LEAF_NODE)
   if (node->leaftype == CONSTANTLEAF)
     node->output = node->regressionvalue;
   else
     node->output = linear_fit_value(node->w, inst);
 else
  {
   node->left->weight = sigmoid(linear_fit_value(node->w, inst));
   node->right->weight = 1 - node->left->weight;
   node->output = node->left->weight * soft_regtree_output(node->left, inst) + node->right->weight * soft_regtree_output(node->right, inst);
  }
 return node->output;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x68(%rdi)
je 0x8817b
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq %r14, %rdx
callq 0x75608
callq 0x54568
movq (%rbx), %rdi
movsd %xmm0, 0x48(%rdi)
movsd 0x1a3fc(%rip), %xmm1    # 0xa2520
subsd %xmm0, %xmm1
movq 0x8(%rbx), %rax
movsd %xmm1, 0x48(%rax)
movsd 0x48(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rsi
callq 0x880ec
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
movsd 0x48(%rdi), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rsi
callq 0x880ec
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x88198
cmpl $0x0, 0x6c(%rbx)
je 0x88193
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq %r14, %rdx
callq 0x75608
jmp 0x88198
movsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x40(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softregtree.c
// Function: mse_error_of_soft_regression_tree
double mse_error_of_soft_regression_tree(Regressionnodeptr rootnode, Instanceptr list)
{
 int count = 0;
 double r, o, mse = 0.0;
 Instanceptr inst = list;
 while (inst)
  {
   r = give_regressionvalue(inst);
   o = soft_regtree_output(rootnode, inst);
   mse += (r - o) * (r - o);
   inst = inst->next;
   count++;
  }
 return mse / count;
}

// Assembly:
testq %rsi, %rsi
je 0x88213
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
xorpd %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %rbx, %rdi
callq 0x2eaee
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x880ec
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
subsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm1
movq 0x10(%rbx), %rbx
incl %ebp
testq %rbx, %rbx
jne 0x881be
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x8821b
movsd 0x1aaf5(%rip), %xmm1    # 0xa2d10
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softregtree.c
// Function: free_soft_regtree_ws
void free_soft_regtree_ws(Regressionnodeptr node)
{
 matrix_free(node->w);
 if (node->leaftype != CONSTANTLEAF)
  {
   matrix_free(node->left->w);
   matrix_free(node->right->w);
  } 
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq 0x38(%rbx), %rsi
callq 0x3dbad
cmpl $0x0, 0x6c(%rbx)
je 0x8867d
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x3dbad
movq 0x8(%rbx), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
popq %rbx
jmp 0x3dbad
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softregtree.c
// Function: copy_soft_regtree_ws
void copy_soft_regtree_ws(Regressionnodeptr dest, Regressionnodeptr src)
{
 dest->w = matrix_copy(src->w);
 if (src->leaftype == CONSTANTLEAF)
  {
   dest->left->regressionvalue = src->left->regressionvalue;
   dest->right->regressionvalue = src->right->regressionvalue;
  }
 else
  {
   dest->left->w = matrix_copy(src->left->w);
   dest->right->w = matrix_copy(src->right->w);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %rdi
movq 0x38(%rsi), %rsi
callq 0x3ca3c
movq %rax, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
cmpl $0x0, 0x6c(%r14)
je 0x886e0
movq (%rbx), %r15
movq (%r14), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x3ca3c
movq %rax, 0x30(%r15)
movq %rdx, 0x38(%r15)
movq 0x8(%rbx), %rbx
movq 0x8(%r14), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x3ca3c
movq %rax, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
jmp 0x88702
movq (%r14), %rax
movsd 0x70(%rax), %xmm0
movq (%rbx), %rax
movsd %xmm0, 0x70(%rax)
movq 0x8(%r14), %rax
movsd 0x70(%rax), %xmm0
movq 0x8(%rbx), %rax
movsd %xmm0, 0x70(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softregtree.c
// Function: soft_output_of_subregressiontree
double soft_output_of_subregressiontree(Regressionnodeptr subtree, double input)
{
 double weight, output, multiplier;
 Regressionnodeptr tmpnode;
 if (subtree->featureno == LEAF_NODE)
  {
   if (subtree->leaftype == CONSTANTLEAF)
     output = subtree->regressionvalue;    
   else
     output = subtree->w.values[0][0] + subtree->w.values[1][0] * input; 
   multiplier = 1.0;
   tmpnode = subtree;
   while (tmpnode->parent)
    {
     weight = sigmoid(tmpnode->parent->w.values[0][0] + tmpnode->parent->w.values[1][0] * input);
     if (tmpnode == tmpnode->parent->left)
       multiplier *= weight;
     else
       multiplier *= (1 - weight);
     tmpnode = tmpnode->parent;
    }
   return output * multiplier;   
  }
 else
   return soft_output_of_subregressiontree(subtree->left, input) + soft_output_of_subregressiontree(subtree->right, input);   
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movapd %xmm0, %xmm1
movq %rdi, %rbx
cmpl $-0x1, 0x68(%rdi)
je 0x88af9
movq (%rbx), %rdi
movapd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x88ab5
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x88ab5
addsd (%rsp), %xmm0
jmp 0x88b99
cmpl $0x0, 0x6c(%rbx)
je 0x88b18
movq 0x38(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
mulsd %xmm1, %xmm0
addsd (%rcx), %xmm0
jmp 0x88b1d
movsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rbx), %rax
movsd 0x199f1(%rip), %xmm2    # 0xa2520
testq %rax, %rax
je 0x88b8f
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, (%rsp)
movq %rbx, %r14
movq 0x38(%rax), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
mulsd %xmm1, %xmm0
addsd (%rcx), %xmm0
callq 0x54568
movq 0x18(%rbx), %rbx
cmpq (%rbx), %r14
je 0x88b77
movsd 0x199b1(%rip), %xmm1    # 0xa2520
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
movq 0x18(%rbx), %rax
testq %rax, %rax
movsd 0x8(%rsp), %xmm1
jne 0x88b3a
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softregtree.c
// Function: create_softregtree
int create_softregtree(Regressionnodeptr rootnode, Regressionnodeptr node, Instanceptr cvdata, Softregtree_parameterptr param)
{
 node->cvinstances = NULL;
 if (node != rootnode)
   node->instances = NULL;
 if (find_best_soft_regtree_split(rootnode, node, cvdata, param))
  {
   create_softregtree(rootnode, node->left, cvdata, param);
   create_softregtree(rootnode, node->right, cvdata, param);
  }
 return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq $0x0, 0x28(%r15)
cmpq %r12, %r15
je 0x88bd0
movq $0x0, 0x20(%r15)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x88708
testl %eax, %eax
je 0x88c0b
movq (%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x88ba1
movq 0x8(%r15), %r15
testb $0x1, %r13b
movl $0x1, %eax
cmovel %eax, %ebp
movb $0x1, %r13b
jmp 0x88bbb
testb $0x1, %r13b
movl $0x1, %eax
cmovnel %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softtree.c
// Function: soft_tree_output_K_class
double* soft_tree_output_K_class(Decisionnodeptr node, Instanceptr inst)
{
 int i;
 double *left_output, *right_output;
 if (node->featureno == LEAF_NODE)
   memcpy(node->outputs, node->w0s, current_dataset->classno * sizeof(double));
 else
  {
   node->left->weight = sigmoid(linear_fit_value(node->w, inst));
   node->right->weight = 1 - node->left->weight;
   left_output = soft_tree_output_K_class(node->left, inst);
   right_output = soft_tree_output_K_class(node->right, inst);
   for (i = 0; i < current_dataset->classno; i++)
     node->outputs[i] = node->left->weight * left_output[i] + node->right->weight * right_output[i];
  }
 return node->outputs;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, 0x30(%rdi)
je 0x88cd1
movq %rsi, %r15
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
movq %r15, %rdx
callq 0x75608
callq 0x54568
movq (%rbx), %rdi
movsd %xmm0, 0x78(%rdi)
movsd 0x198be(%rip), %xmm1    # 0xa2520
subsd %xmm0, %xmm1
movq 0x8(%rbx), %rax
movsd %xmm1, 0x78(%rax)
movq %r15, %rsi
callq 0x88c28
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x88c28
leaq 0x49be3(%rip), %rcx     # 0xd2870
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
testq %rcx, %rcx
jle 0x88cf0
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
movq 0x70(%rbx), %rdi
xorl %r8d, %r8d
movsd 0x78(%rdx), %xmm0
movsd 0x78(%rsi), %xmm1
mulsd (%rax,%r8,8), %xmm1
mulsd (%r14,%r8,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rcx
jne 0x88ca7
jmp 0x88cf0
movq 0x50(%rbx), %rsi
movq 0x70(%rbx), %rdi
leaq 0x49b90(%rip), %rax     # 0xd2870
movq (%rax), %rax
movslq 0x10(%rax), %rdx
shlq $0x3, %rdx
callq 0x4310
movq 0x70(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softtree.c
// Function: soft_tree_output
double soft_tree_output(Decisionnodeptr node, Instanceptr inst)
{
 if (node->featureno == LEAF_NODE)
   if (node->leaftype == CONSTANTLEAF)
     node->output = node->w0;
   else
     node->output = linear_fit_value(node->w, inst);
 else
  {
   node->left->weight = sigmoid(linear_fit_value(node->w, inst));
   node->right->weight = 1 - node->left->weight;
   node->output = node->left->weight * soft_tree_output(node->left, inst) + node->right->weight * soft_tree_output(node->right, inst);
  }
 return node->output;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x30(%rdi)
je 0x88d89
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
movq %r14, %rdx
callq 0x75608
callq 0x54568
movq (%rbx), %rdi
movsd %xmm0, 0x78(%rdi)
movsd 0x197ee(%rip), %xmm1    # 0xa2520
subsd %xmm0, %xmm1
movq 0x8(%rbx), %rax
movsd %xmm1, 0x78(%rax)
movsd 0x78(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rsi
callq 0x88cfa
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
movsd 0x78(%rdi), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rsi
callq 0x88cfa
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x88da6
cmpl $0x0, 0x60(%rbx)
je 0x88da1
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
movq %r14, %rdx
callq 0x75608
jmp 0x88da6
movsd 0x48(%rbx), %xmm0
movsd %xmm0, 0x68(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softtree.c
// Function: error_of_soft_tree_K_class
int error_of_soft_tree_K_class(Decisionnodeptr rootnode, Instanceptr list)
{
 int count = 0, classno;
 double* o;
 Instanceptr inst = list;
 while (inst)
  {
   classno = give_classno(inst);
   o = soft_tree_output_K_class(rootnode, inst);
   if (find_max_in_list_double(o, current_dataset->classno) != classno)
     count++;
   inst = inst->next;
  }
 return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x88e09
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x49aa1(%rip), %r12     # 0xd2870
movq %rbx, %rdi
callq 0x2eaca
movl %eax, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x88c28
movq (%r12), %rcx
movl 0x10(%rcx), %esi
movq %rax, %rdi
callq 0x37533
xorl %ecx, %ecx
cmpl %r15d, %eax
setne %cl
addl %ecx, %ebp
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x88dcf
jmp 0x88e0b
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softtree.c
// Function: error_of_soft_tree
int error_of_soft_tree(Decisionnodeptr rootnode, Instanceptr list)
{
 int count = 0, classno;
 double o;
 Instanceptr inst = list;
 while (inst)
  {
   classno = give_classno(inst);
   o = sigmoid(soft_tree_output(rootnode, inst));
   if ((o > 0.5 && classno == 0) || (o < 0.5 && classno == 1))
     count++;
   inst = inst->next;
  }
 return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x88e84
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x2eaca
movl %eax, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x88cfa
callq 0x54568
ucomisd 0x19ecb(%rip), %xmm0    # 0xa2d18
seta %al
testl %r15d, %r15d
sete %cl
testb %cl, %al
jne 0x88e77
movsd 0x19eb6(%rip), %xmm1    # 0xa2d18
ucomisd %xmm0, %xmm1
seta %al
cmpl $0x1, %r15d
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x88e79
incl %ebp
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x88e2a
jmp 0x88e86
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softtree.c
// Function: free_soft_tree_ws
void free_soft_tree_ws(Decisionnodeptr node)
{
 matrix_free(node->w);
 if (node->leaftype != CONSTANTLEAF)
  {
   matrix_free(node->left->w);
   matrix_free(node->right->w);
  } 
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movq 0x40(%rbx), %rsi
callq 0x3dbad
cmpl $0x0, 0x60(%rbx)
je 0x89794
movq (%rbx), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x3dbad
movq 0x8(%rbx), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
popq %rbx
jmp 0x3dbad
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softtree.c
// Function: copy_soft_tree_ws
void copy_soft_tree_ws(Decisionnodeptr dest, Decisionnodeptr src)
{
 dest->w = matrix_copy(src->w);
 if (src->leaftype == CONSTANTLEAF)
  {
   dest->left->w0 = src->left->w0;
   dest->right->w0 = src->right->w0;
  }
 else
  {
   dest->left->w = matrix_copy(src->left->w);
   dest->right->w = matrix_copy(src->right->w);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rdi
movq 0x40(%rsi), %rsi
callq 0x3ca3c
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
cmpl $0x0, 0x60(%r14)
je 0x89858
movq (%rbx), %r15
movq (%r14), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x3ca3c
movq %rax, 0x38(%r15)
movq %rdx, 0x40(%r15)
movq 0x8(%rbx), %rbx
movq 0x8(%r14), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x3ca3c
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
jmp 0x8987a
movq (%r14), %rax
movsd 0x48(%rax), %xmm0
movq (%rbx), %rax
movsd %xmm0, 0x48(%rax)
movq 0x8(%r14), %rax
movsd 0x48(%rax), %xmm0
movq 0x8(%rbx), %rax
movsd %xmm0, 0x48(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softtree.c
// Function: soft_tree_dimension_reduction
void soft_tree_dimension_reduction(Decisionnodeptr node, char st[READLINELENGTH], int level)
{
 int i, count;
	if (node->featureno != LEAF_NODE)
	 {
   count = 0;
   for (i = 0; i < current_dataset->multifeaturecount; i++)
     if (node->w.values[i][0] != 0)
       count++;
   sprintf(st,"%s%d-%d;", st, level, count);
   soft_tree_dimension_reduction(node->left, st, level + 1);
   soft_tree_dimension_reduction(node->right, st, level + 1);
	 }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x48931(%rip), %r13     # 0xd2870
xorpd %xmm1, %xmm1
leaq 0x1da07(%rip), %r12     # 0xa7951
cmpl $-0x1, 0x30(%r15)
je 0x89fb7
movq (%r13), %rax
movslq 0x1c0(%rax), %rax
testq %rax, %rax
jle 0x89f89
movq 0x40(%r15), %rcx
xorl %edx, %edx
xorl %r8d, %r8d
movq (%rcx,%rdx,8), %rsi
movsd (%rsi), %xmm0
cmpneqsd %xmm1, %xmm0
movq %xmm0, %rsi
subl %esi, %r8d
incq %rdx
cmpq %rdx, %rax
jne 0x89f6a
jmp 0x89f8c
xorl %r8d, %r8d
movq %r14, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x41b0
movq (%r15), %rdi
incl %ebx
movq %r14, %rsi
movl %ebx, %edx
callq 0x89f27
xorpd %xmm1, %xmm1
movq 0x8(%r15), %r15
jmp 0x89f4a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softtree.c
// Function: create_softtree_K_class
int create_softtree_K_class(Decisionnodeptr rootnode, Decisionnodeptr node, Instanceptr cvdata, Softregtree_parameterptr param)
{
 if (node != rootnode)
   node->instances = NULL;
 if (find_best_soft_tree_split_K_class(rootnode, node, cvdata, param))
  {
   create_softtree_K_class(rootnode, node->left, cvdata, param);
   create_softtree_K_class(rootnode, node->right, cvdata, param);
  }
 return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
cmpq %r12, %r15
je 0x89fe8
movq $0x0, 0x20(%r15)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x89880
testl %eax, %eax
je 0x8a023
movq (%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x89fc1
movq 0x8(%r15), %r15
testb $0x1, %r13b
movl $0x1, %eax
cmovel %eax, %ebp
movb $0x1, %r13b
jmp 0x89fdb
testb $0x1, %r13b
movl $0x1, %eax
cmovnel %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/softtree.c
// Function: create_softtree
int create_softtree(Decisionnodeptr rootnode, Decisionnodeptr node, Instanceptr cvdata, Softregtree_parameterptr param)
{
 if (node != rootnode)
   node->instances = NULL;
 if (find_best_soft_tree_split(rootnode, node, cvdata, param))
  {
   create_softtree(rootnode, node->left, cvdata, param);
   create_softtree(rootnode, node->right, cvdata, param);
  }
 return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
cmpq %r12, %r15
je 0x8a065
movq $0x0, 0x20(%r15)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x89b93
testl %eax, %eax
je 0x8a0a0
movq (%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8a03e
movq 0x8(%r15), %r15
testb $0x1, %r13b
movl $0x1, %eax
cmovel %eax, %ebp
movb $0x1, %r13b
jmp 0x8a058
testb $0x1, %r13b
movl $0x1, %eax
cmovnel %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/srm.c
// Function: vc_bound
double vc_bound(double rho)
{
 /*!Last Changed 11.03.2006*/
 double val1, val2, val3;
 if (rho < 0.5)
   return 1;
 val1 = log(2 * rho) + 1;
 val2 = rho - VC_K;
 val3 = val1 / val2;
 return VC_A * val3 * (sqrt(1 + VC_B / val3) + 1);
}

// Assembly:
movapd %xmm0, %xmm1
movsd 0x18c50(%rip), %xmm0    # 0xa2d18
ucomisd %xmm1, %xmm0
jbe 0x8a0d7
movsd 0x1844a(%rip), %xmm0    # 0xa2520
retq
pushq %rax
movapd %xmm1, %xmm0
addsd %xmm1, %xmm0
movsd %xmm1, (%rsp)
callq 0x4160
movapd %xmm0, %xmm1
movsd 0x1842a(%rip), %xmm2    # 0xa2520
addsd %xmm2, %xmm1
movsd (%rsp), %xmm0
addsd 0x242a9(%rip), %xmm0    # 0xae3b0
divsd %xmm0, %xmm1
movsd 0x242a5(%rip), %xmm3    # 0xae3b8
mulsd %xmm1, %xmm3
movsd 0x242a1(%rip), %xmm0    # 0xae3c0
divsd %xmm1, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x8a137
sqrtsd %xmm0, %xmm0
jmp 0x8a146
movsd %xmm3, (%rsp)
callq 0x4300
movsd (%rsp), %xmm3
addsd 0x183d2(%rip), %xmm0    # 0xa2520
mulsd %xmm3, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/srm.c
// Function: solve_vc_bound_equation
double solve_vc_bound_equation(double epsilon)
{
 /*!Last Changed 11.03.2006*/
 double start = 0.5, end = 30, middle = 0, lastmiddle, val;
 if (epsilon > 1)
   return 0.5;
 while (epsilon < vc_bound(end))
   end *= 10;
 do
  {
   lastmiddle = middle;
   middle = (start + end) / 2; 
   val = vc_bound(middle);
   if (val > epsilon)
     start = middle;
   else
     end = middle;
  }while (fabs(middle - lastmiddle) > DBL_DELTA);
 return middle;
}

// Assembly:
subq $0x48, %rsp
ucomisd 0x183bd(%rip), %xmm0    # 0xa2520
jbe 0x8a172
movsd 0x18bab(%rip), %xmm4    # 0xa2d18
jmp 0x8a254
movapd %xmm0, %xmm1
movsd 0x1abba(%rip), %xmm0    # 0xa4d38
movsd %xmm1, 0x8(%rsp)
callq 0x8a0bc
ucomisd 0x8(%rsp), %xmm0
movsd 0x1aba1(%rip), %xmm2    # 0xa4d38
jbe 0x8a1c8
movsd 0x1ab97(%rip), %xmm2    # 0xa4d38
mulsd 0x1ab87(%rip), %xmm2    # 0xa4d30
movapd %xmm2, 0x10(%rsp)
movapd 0x10(%rsp), %xmm0
callq 0x8a0bc
ucomisd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm2
ja 0x8a1a1
movsd 0x18b48(%rip), %xmm1    # 0xa2d18
xorpd %xmm3, %xmm3
movsd %xmm3, 0x28(%rsp)
movapd %xmm2, 0x10(%rsp)
movapd %xmm2, %xmm0
movsd %xmm1, 0x20(%rsp)
addsd %xmm1, %xmm0
mulsd 0x18b22(%rip), %xmm0    # 0xa2d18
movapd %xmm0, 0x30(%rsp)
callq 0x8a0bc
movapd 0x30(%rsp), %xmm4
movsd 0x8(%rsp), %xmm2
ucomisd %xmm2, %xmm0
movapd %xmm4, %xmm1
ja 0x8a21d
movsd 0x20(%rsp), %xmm1
cmpltsd %xmm0, %xmm2
movapd %xmm2, %xmm0
andnpd %xmm4, %xmm0
andpd 0x10(%rsp), %xmm2
movapd %xmm4, %xmm3
subsd 0x28(%rsp), %xmm3
andpd 0x18f9e(%rip), %xmm3    # 0xa31e0
ucomisd 0x18b8e(%rip), %xmm3    # 0xa2dd8
orpd %xmm0, %xmm2
movapd %xmm4, %xmm3
ja 0x8a1d4
movapd %xmm4, %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/srm.c
// Function: create_epsilon_estimate
Epsilonestimateptr create_epsilon_estimate(double epsilon)
{
 /*!Last Changed 06.04.2006*/
 Epsilonestimateptr newepsilonestimate;
 newepsilonestimate = safemalloc(sizeof(Epsilonestimate), "create_epsilon_estimate", 2);
 newepsilonestimate->epsilon = epsilon;
 newepsilonestimate->next = NULL;
 return newepsilonestimate;
}

// Assembly:
pushq %rax
movsd %xmm0, (%rsp)
leaq 0x2415e(%rip), %rsi     # 0xae3c8
movl $0x10, %edi
movl $0x2, %edx
callq 0x390f5
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/srm.c
// Function: create_vc_estimate
Vcestimateptr create_vc_estimate(int n, Epsilonestimateptr epsilonptr)
{
 /*!Last Changed 06.04.2006*/
 Vcestimateptr newvcestimate;
 newvcestimate = safemalloc(sizeof(Vcestimate), "create_vc_estimate", 2);
 newvcestimate->n = n;
 newvcestimate->next = NULL;
 newvcestimate->before = NULL;
 newvcestimate->epsilonestimates = epsilonptr;
 newvcestimate->count = 1;
 return newvcestimate;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x24145(%rip), %rsi     # 0xae3e0
movl $0x30, %edi
movl $0x2, %edx
callq 0x390f5
movl %ebp, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rbx, 0x18(%rax)
movl $0x1, 0x4(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/srm.c
// Function: deallocate_vc_estimates
void deallocate_vc_estimates(Vcestimateptr header)
{
 /*!Last Changed 01.04.2006*/
 Vcestimateptr tmp, next;
 tmp = header;
 while (tmp)
  {
   next = tmp->next;
   deallocate_epsilon_estimates(tmp->epsilonestimates);
   safe_free(tmp);
   tmp = next;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x8a31e
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %r14
testq %rdi, %rdi
je 0x8a309
movq 0x8(%rdi), %r15
callq 0x39194
movq %r15, %rdi
testq %r15, %r15
jne 0x8a2f8
movq %rbx, %rdi
callq 0x39194
movq %r14, %rbx
testq %r14, %r14
jne 0x8a2eb
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/srm.c
// Function: add_single_epsilon_estimate
void add_single_epsilon_estimate(Vcestimateptr* header, int n, double epsilon)
{
 /*!Last Changed 01.04.2006*/
 Vcestimateptr newvcestimate, tmpvc;
 Epsilonestimateptr newepsilonestimate;
 newepsilonestimate = create_epsilon_estimate(epsilon);
 tmpvc = *header;
 /* Finds the design point*/
 while (tmpvc && tmpvc->n != n)
   tmpvc = tmpvc->next;
 /*If there is a design point with the given sample size*/
 if (tmpvc)
  {
   newepsilonestimate->next = tmpvc->epsilonestimates;
   tmpvc->epsilonestimates = newepsilonestimate;
   (tmpvc->count)++;
  }
 /* If not, generate a new design point*/
 else
  {
   newvcestimate = create_vc_estimate(n, newepsilonestimate);
   if (*header)
    {
     newvcestimate->next = *header;
     (*header)->before = newvcestimate;
    }
   *header = newvcestimate;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x2408f(%rip), %rsi     # 0xae3c8
movl $0x10, %edi
movl $0x2, %edx
callq 0x390f5
movq %rax, %r14
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movq (%rbx), %rax
testq %rax, %rax
je 0x8a36f
cmpl %ebp, (%rax)
je 0x8a3b1
movq 0x20(%rax), %rax
jmp 0x8a360
leaq 0x2406a(%rip), %rsi     # 0xae3e0
movl $0x30, %edi
movl $0x2, %edx
callq 0x390f5
movl %ebp, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %r14, 0x18(%rax)
movl $0x1, 0x4(%rax)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x8a3ac
movq %rcx, 0x20(%rax)
movq (%rbx), %rcx
movq %rax, 0x28(%rcx)
movq %rax, (%rbx)
jmp 0x8a3c0
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%r14)
movq %r14, 0x18(%rax)
incl 0x4(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/srm.c
// Function: mse_fitting_for_vc_dimension
double mse_fitting_for_vc_dimension(Vcestimateptr estimates, double vcdimension, int n)
{
 /*!Last Changed 01.04.2006*/
 Vcestimateptr tmpvc = estimates;
 Epsilonestimateptr tmpepsilon;
 int count = 0;
 double mse = 0, add;
 while (tmpvc)
  {
   if (tmpvc->n != n)
    {
     tmpepsilon = tmpvc->epsilonestimates;
     while (tmpepsilon)
      {
       add = tmpepsilon->epsilon - vc_bound(tmpvc->n / vcdimension);
       mse += add * add;
       count++;
       tmpepsilon = tmpepsilon->next;
      }
    }
   tmpvc = tmpvc->next;
  }
 return mse / count;
}

// Assembly:
testq %rdi, %rdi
je 0x8a784
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movapd %xmm0, %xmm2
movq %rdi, %r14
xorl %ebp, %ebp
xorpd %xmm1, %xmm1
movsd %xmm0, (%rsp)
cmpl %ebx, (%r14)
jne 0x8a71d
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x8a70d
jmp 0x8a76d
movq 0x18(%r14), %r15
testq %r15, %r15
je 0x8a712
movsd %xmm1, 0x10(%rsp)
movsd (%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl (%r14), %xmm0
divsd %xmm2, %xmm0
callq 0x8a0bc
movsd (%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm3
subsd %xmm0, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm1
incl %ebp
movq 0x8(%r15), %r15
jmp 0x8a721
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8a78c
movsd 0x18584(%rip), %xmm1    # 0xa2d10
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/srm.c
// Function: vc_estimates_for_a_design
Vcestimateptr vc_estimates_for_a_design(void* parameters, int nodecount, Datasetptr d, int experimentcount, double averagevaluecount)
{
 /*!Last Changed 06.11.2007 added preestimation value*/
 /*!Last Changed 01.10.2006*/
 /*!Last Changed 01.04.2006*/
 int multiplier, n, k, ncount;
 double p, epsilon;
 Vcestimateptr header = NULL;
 ((Nodeboundedtree_parameterptr) parameters)->nodecount = nodecount;
 if (in_list(get_parameter_l("modelselectionmethod"), 3, MODEL_SELECTION_UNI, MODEL_SELECTION_LIN, MODEL_SELECTION_QUA))
   if (((Nodeboundedtree_parameterptr) parameters)->usediscrete)
     multiplier = decisiontree_vc_dimension_preestimation_discrete(d, (int) (nodecount * log2(averagevaluecount)));
   else
     multiplier = decisiontree_vc_dimension_preestimation(d, nodecount, get_parameter_l("modelselectionmethod") - 5);
 else
   multiplier = decisiontree_vc_dimension_preestimation(d, nodecount, MODEL_QUA);
 for (p = 1.5; p <= 30; p += 1.5)
  {
   n = (int) (multiplier * p);
   for (k = 0; k < experimentcount; k++)
    {
     epsilon = vc_single_epsilon_estimate(parameters, d, n, &ncount);
     if (ncount == nodecount)
       add_single_epsilon_estimate(&header, n, epsilon);
    }
  }
 return header;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, (%rsp)
movl %ecx, 0xc(%rsp)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq $0x0, 0x20(%rsp)
movl %esi, (%rdi)
leaq 0x17e81(%rip), %rdi     # 0xa27d6
callq 0x535f7
movl %eax, %edi
movl $0x3, %esi
movl $0x5, %edx
movl $0x6, %ecx
movl $0x7, %r8d
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0x8a9ae
cmpl $0x0, 0xc(%r15)
je 0x8a9ba
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x38e99
mulsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %esi
movq %r14, %rdi
callq 0x9fe94
jmp 0x8a9d3
movq %r14, %rdi
movl %ebp, %esi
movl $0x2, %edx
jmp 0x8a9ce
leaq 0x17e15(%rip), %rdi     # 0xa27d6
callq 0x535f7
leal -0x5(%rax), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x9ff1b
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x183f8(%rip), %xmm0    # 0xa2de0
leaq 0x1c(%rsp), %r12
movsd %xmm0, (%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x8aa34
movsd (%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %ebx
movl 0xc(%rsp), %r13d
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0x8a791
cmpl %ebp, 0x1c(%rsp)
jne 0x8aa2f
leaq 0x20(%rsp), %rdi
movl %ebx, %esi
callq 0x8a31f
decl %r13d
jne 0x8aa0d
movsd (%rsp), %xmm1
addsd 0x1839f(%rip), %xmm1    # 0xa2de0
movsd 0x1a2ef(%rip), %xmm0    # 0xa4d38
movsd %xmm1, (%rsp)
ucomisd %xmm1, %xmm0
jae 0x8a9f2
movq 0x20(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/srm.c
// Function: vc_estimate_uniform_of_decision_tree
void vc_estimate_uniform_of_decision_tree(int featurecount, int nodecount, int experimentcount, char* featuretypes, int* featurevaluecounts)
{
 /*!Last Changed 24.09.2006 added different feature types*/
 /*!Last Changed 03.05.2006 run for a specific featurecount and nodecount*/
 /*!Last Changed 01.04.2006*/
 /*!Last Changed 11.03.2006*/
 void* parameters;
 double vcdimension, averagecount;
 Vcestimateptr estimates;
 parameters = prepare_supervised_algorithm_parameters(NBTREE);
 ((Nodeboundedtree_parameterptr) parameters)->prunetype = NOPRUNING;
 if (featurevaluecounts[0] > 1)
   ((Nodeboundedtree_parameterptr) parameters)->usediscrete = BOOLEAN_TRUE;
 else
   ((Nodeboundedtree_parameterptr) parameters)->usediscrete = BOOLEAN_FALSE;
 current_dataset = generate_random_dataset("VC-Estimate", featurecount, featuretypes, featurevaluecounts, 2);
 averagecount = average_valuecount(current_dataset);
 estimates = vc_estimates_for_a_design(parameters, nodecount, current_dataset, experimentcount, averagecount);
 vcdimension = vc_dimension_for_a_design(estimates, UNIFORM_DESIGN, -1);
 set_default_variable("out1", vcdimension);
 deallocate_vc_estimates(estimates);
 free_dataset(current_dataset);
 free_supervised_algorithm_parameters(NBTREE, parameters);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r13d
movl $0x3fd, %edi            # imm = 0x3FD
callq 0x5b37
movq %rax, %rbx
movl $0x3, 0x14(%rax)
xorl %eax, %eax
cmpl $0x2, (%r15)
setge %al
movl %eax, 0xc(%rbx)
leaq 0x23979(%rip), %rdi     # 0xae421
movl %r13d, %esi
movq %r12, %rdx
movq %r15, %rcx
movl $0x2, %r8d
callq 0x1560a
leaq 0x47dad(%rip), %r15     # 0xd2870
movq %rax, (%r15)
movq %rax, %rdi
callq 0x14f4e
movq (%r15), %rdx
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %ecx
callq 0x8a924
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x8a3da
leaq 0x1b4c1(%rip), %rdi     # 0xa5fb8
callq 0x3403a
movq %r14, %rdi
callq 0x8a2de
movq (%r15), %rdi
callq 0x13765
movl $0x3fd, %edi            # imm = 0x3FD
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4d19
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/srm.c
// Function: move_vc_estimates
int move_vc_estimates(Vcestimateptr header, Vcestimateptr from, Vcestimateptr to, Datasetptr d, void* parameters, int nodecount, double previousmse)
{
 /*!Last Changed 05.04.2006*/
 Epsilonestimateptr deleted, added;
 double epsilon, vcdimension, mse;
 int ncount;
 if (to->issaturated)
   return FAILURE;
 epsilon = vc_single_epsilon_estimate(parameters, d, to->n, &ncount);
 if (ncount == nodecount)
  {
   deleted = from->epsilonestimates;
   from->epsilonestimates = from->epsilonestimates->next;
   (from->count)--;
   added = create_epsilon_estimate(epsilon);
   added->next = to->epsilonestimates;
   to->epsilonestimates = added;
   (to->count)++;
   vcdimension = vc_dimension_for_a_design(header, OPTIMIZED_DESIGN, -1);
   mse = mse_fitting_for_vc_dimension(header, vcdimension, -1);   
   if (mse < previousmse)
    {
     safe_free(deleted);
     if (from->count == 0)
      {
       from->before->next = from->next;
       if (from->next)
         from->next->before = from->before;
       safe_free(from);
      }
     return SUCCESS;
    }
   else
    {
     (to->count)--;
     to->epsilonestimates = to->epsilonestimates->next;
     (from->count)++;
     deleted->next = from->epsilonestimates;
     from->epsilonestimates = deleted;
     safe_free(added);
     return FAILURE;
    }
  }
 else
   return FAILURE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %ebp, %ebp
cmpl $0x0, 0x8(%rdx)
jne 0x8af15
movl %r9d, %r15d
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movsd %xmm0, 0x8(%rsp)
movl (%rdx), %edx
leaq 0x14(%rsp), %r13
movq %r8, %rdi
movq %rcx, %rsi
movq %r13, %rcx
callq 0x8a791
cmpl %r15d, (%r13)
jne 0x8af15
movq 0x18(%rbx), %r15
movq 0x8(%r15), %rax
movq %rax, 0x18(%rbx)
decl 0x4(%rbx)
leaq 0x23575(%rip), %rsi     # 0xae3c8
movl $0x10, %edi
movl $0x2, %edx
movsd %xmm0, (%rsp)
callq 0x390f5
movq %rax, %r13
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
movq 0x18(%r14), %rax
movq %rax, 0x8(%r13)
movq %r13, 0x18(%r14)
incl 0x4(%r14)
movl $0x1, %ebp
movq %r12, %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x8a3da
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8a6e6
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8aeec
movq %r15, %rdi
callq 0x39194
cmpl $0x0, 0x4(%rbx)
jne 0x8af15
movq 0x20(%rbx), %rcx
movq 0x28(%rbx), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x8aee2
movq %rax, 0x28(%rcx)
movq %rbx, %rdi
callq 0x39194
jmp 0x8af15
decl 0x4(%r14)
movq 0x18(%r14), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%r14)
incl 0x4(%rbx)
movq 0x18(%rbx), %rax
movq %rax, 0x8(%r15)
movq %r15, 0x18(%rbx)
movq %r13, %rdi
callq 0x39194
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/srm.c
// Function: is_featurelist_valid
BOOLEAN is_featurelist_valid(int* featurelist, int* ruleset, int rulecount)
{
 /*!Last Changed 21.02.2008*/
 int i, j = 0, k, available[10], fno;
 for (i = 0; i < rulecount; i++)
  {
   if (ruleset[i] > 1)
    {
     for (k = 0; k < ruleset[i]; k++)
       available[k] = BOOLEAN_FALSE;
     for (k = 0; k < ruleset[i]; k++)
      {
       fno = featurelist[j + k] / 10;
       if (available[fno])
         return BOOLEAN_FALSE;
       available[fno] = BOOLEAN_TRUE;
      }
    }
   j += ruleset[i];
  }
 return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movl $0x1, %ebx
testl %edx, %edx
jle 0x8afbd
movq %rsi, %r14
movl %edx, %r13d
xorl %ebp, %ebp
xorl %r12d, %r12d
movslq (%r14,%rbp,4), %r15
cmpq $0x2, %r15
jl 0x8afab
leaq (,%r15,4), %rdx
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x4050
movslq %r12d, %rax
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
xorl %ecx, %ecx
movslq (%rax,%rcx,4), %rdx
imulq $0x66666667, %rdx, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x22, %rdx
addl %esi, %edx
movslq %edx, %rdx
cmpl $0x0, 0x10(%rsp,%rdx,4)
jne 0x8afbb
movl $0x1, 0x10(%rsp,%rdx,4)
incq %rcx
cmpq %rcx, %r15
jne 0x8af79
addl %r12d, %r15d
incq %rbp
movl %r15d, %r12d
cmpq %r13, %rbp
jne 0x8af4d
jmp 0x8afbd
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: gaussian_vector
double gaussian_vector(Instanceptr x, Instanceptr mean, double stdev)
{
 /*Last Changed 11.07.2006 if stdev = 0 returns 0*/
 int i;
 double sum = 0, x_i, m_i;
 if (stdev == 0)
   return 0;
 for (i = 0; i < current_dataset->multifeaturecount - 1; i++)
  {
   x_i = real_feature(x, i);
   m_i = real_feature(mean, i);
   sum += (x_i - m_i) * (x_i - m_i);
  }
 return (1 / (stdev * sqrt(2 * PI))) * safeexp(-sum / (2 * stdev * stdev));
}

// Assembly:
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x8b3e1
jp 0x8b3e1
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x18(%rsp)
leaq 0x47478(%rip), %r15     # 0xd2870
movq (%r15), %rax
xorpd %xmm2, %xmm2
cmpl $0x2, 0x1c0(%rax)
jl 0x8b457
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movapd %xmm2, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x2e4b6
movsd %xmm0, 0x20(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2e4b6
movapd (%rsp), %xmm2
movsd 0x20(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm2
incl %ebp
movq (%r15), %rax
movl 0x1c0(%rax), %eax
decl %eax
cmpl %eax, %ebp
jl 0x8b410
movsd 0x1c741(%rip), %xmm0    # 0xa7ba0
movsd 0x18(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x170af(%rip), %xmm3    # 0xa2520
divsd %xmm0, %xmm3
movsd %xmm3, (%rsp)
xorpd 0x17d4e(%rip), %xmm2    # 0xa31d0
movapd %xmm1, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
divsd %xmm0, %xmm2
movapd %xmm2, %xmm0
callq 0x38e72
mulsd (%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: gaussian_multivariate
double gaussian_multivariate(Instanceptr inst, double* mean, matrix covariance)
{
 /*!Last Changed 12.01.2009 added mahalanobis_distance*/
 /*!Last Changed 25.02.2007*/
 matrix x, mu;
 double det, result;
 int d = current_dataset->multifeaturecount - 1;
 det = matrix_determinant(covariance);
 if (dequal(det, 0.0))
   return 0.0;
 x = instance_to_matrix(inst);
 /*Prepare mean matrix*/
 mu = matrix_alloc(1, x.col);
 memcpy(mu.values[0], mean, x.col * sizeof(double));
 result = (1 / sqrt(pow(2 * PI, d) * det)) * safeexp(-mahalanobis_distance(x, mu, covariance) / 2);
 matrix_free(x);
 matrix_free(mu);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x473a4(%rip), %rax     # 0xd2870
movq (%rax), %rax
movl 0x1c0(%rax), %r13d
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x3f436
xorpd %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x20(%rsp)
callq 0x38d52
testl %eax, %eax
jne 0x8b5dd
decl %r13d
movq %r15, %rdi
callq 0x2e851
movq %rax, %r15
movq %rdx, 0x18(%rsp)
movq %rax, %rsi
shrq $0x20, %rsi
movl $0x1, %edi
callq 0x3c6e5
movq %rax, 0x10(%rsp)
movq %rdx, %rbp
movq (%rdx), %rdi
movq %r15, %rdx
sarq $0x1d, %rdx
andq $-0x8, %rdx
movq %r12, %rsi
callq 0x4310
xorps %xmm1, %xmm1
cvtsi2sd %r13d, %xmm1
movsd 0x22f40(%rip), %xmm0    # 0xae490
callq 0x42f0
movsd 0x20(%rsp), %xmm1
mulsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x8b572
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x8b57b
movapd %xmm1, %xmm0
callq 0x4300
movsd 0x16f9d(%rip), %xmm1    # 0xa2520
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
movq 0x18(%rsp), %r12
movq %r12, %rsi
movq 0x10(%rsp), %r13
movq %r13, %rdx
movq %rbp, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x3f534
mulsd 0x1781a(%rip), %xmm0    # 0xa2dd0
callq 0x38e72
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3dbad
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3dbad
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: produce_distribution
void produce_distribution(double probability, int howmany, int samplesize, char *f_name)
{
 /*Last Changed 23.04.2001*/
 FILE *myfile;
 int i, j, k;
 char pst[READLINELENGTH];
 if ((myfile = fopen(f_name, "w")) == NULL)
  {
   printf(m1314, f_name);
   return;
  }
 for (i = 0; i < howmany; i++)
  {
   k = 0;
   for (j = 0; j < samplesize; j++)
     if (produce_random_value(0, 1) < probability)
       k++;
   set_precision(pst, NULL, "\n");
   fprintf(myfile, pst, k / (samplesize + 0.0));
  }
 fclose(myfile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a148, %rsp          # imm = 0x7A148
movq %rdx, %r15
movl %esi, %ebp
movl %edi, %r14d
movsd %xmm0, 0x18(%rsp)
leaq 0x1d23b(%rip), %rsi     # 0xa88a1
movq %rdx, %rdi
callq 0x40f0
movq %rax, (%rsp)
testq %rax, %rax
je 0x8b729
testl %r14d, %r14d
jle 0x8b70e
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0x20(%rsp), %r12
xorpd %xmm0, %xmm0
testl %ebp, %ebp
jle 0x8b6d5
xorl %r15d, %r15d
movl %ebp, %ebx
xorpd %xmm0, %xmm0
movsd 0x16e6e(%rip), %xmm1    # 0xa2520
callq 0x39f62
xorl %eax, %eax
movsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
addl %eax, %r15d
decl %ebx
jne 0x8b6a6
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r12, %rdi
xorl %esi, %esi
leaq 0x1aa7e(%rip), %rdx     # 0xa616b
callq 0x39529
movq (%rsp), %rdi
movq %r12, %rsi
movsd 0x10(%rsp), %xmm0
movb $0x1, %al
callq 0x42e0
incl %r13d
cmpl %r14d, %r13d
jne 0x8b699
movq (%rsp), %rdi
callq 0x42a0
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22f50(%rip), %rdi     # 0xae680
movq %r15, %rsi
xorl %eax, %eax
addq $0x7a148, %rsp          # imm = 0x7A148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4030
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: file_mean
double file_mean(char **files,int filecount)
{
/*Last Changed 26.04.2002*/
 FILE *myfile;
 double sum=0,temp;
 int counts,i,total=0,j;
 for (i=0;i<filecount;i++)
  {
   counts=file_length(files[i]);
   if ((myfile=fopen(files[i],"r"))==NULL)
    {
     printf(m1274, files[i]);
     return 0;
    }
   for (j=0;j<counts;j++)
    {
     fscanf(myfile,"%lf",&temp);
     sum+=temp;
    }
   total+=counts;
   fclose(myfile);
  }
 return sum/total;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
testl %esi, %esi
jle 0x8bcb9
movl %esi, %eax
movq %rax, 0x18(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x1aff1(%rip), %r15     # 0xa6c10
leaq 0x20(%rsp), %r12
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x10(%rsp), %r13
movq (%r13,%r14,8), %rdi
callq 0x37e22
movl %eax, %ebx
movq (%r13,%r14,8), %rdi
leaq 0x1cc49(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x8bcc3
movq %rax, %r13
movl %ebp, 0xc(%rsp)
movl %ebx, %ebp
testl %ebx, %ebx
movsd (%rsp), %xmm0
jle 0x8bc86
movsd %xmm0, (%rsp)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4070
movsd (%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
decl %ebp
jne 0x8bc62
movsd %xmm0, (%rsp)
movl 0xc(%rsp), %ebp
addl %ebx, %ebp
movq %r13, %rdi
callq 0x42a0
incq %r14
cmpq 0x18(%rsp), %r14
jne 0x8bc29
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x8bcde
movsd 0x1704f(%rip), %xmm0    # 0xa2d10
jmp 0x8bcde
movq 0x10(%rsp), %rax
movq (%rax,%r14,8), %rsi
leaq 0x17537(%rip), %rdi     # 0xa320a
xorl %eax, %eax
callq 0x4030
xorpd %xmm0, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: no_correction
void no_correction(Comparisonptr comparisons, int compcount, double confidence)
{
 /*Last Changed 14.05.2005*/
 int i;
 for (i = 0; i < compcount; i++)
   if (comparisons[i].confidence < confidence)
     comparisons[i].accepted = 0;
}

// Assembly:
testl %esi, %esi
jle 0x8bd16
movl %esi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
xorl %ecx, %ecx
ucomisd 0x8(%rdi,%rcx), %xmm0
jbe 0x8bd0d
movl $0x0, 0x10(%rdi,%rcx)
addq $0x18, %rcx
cmpq %rcx, %rax
jne 0x8bcfd
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: bonferroni_correction
void bonferroni_correction(Comparisonptr comparisons, int compcount, double confidence)
{
 /*Last Changed 18.11.2004*/
 int i;
 double corrected = confidence / compcount;
 for (i = 0; i < compcount; i++)
   if (comparisons[i].confidence < corrected)
     comparisons[i].accepted = 0;
}

// Assembly:
testl %esi, %esi
jle 0x8bd48
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
movl %esi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
xorl %ecx, %ecx
ucomisd 0x8(%rdi,%rcx), %xmm0
jbe 0x8bd3f
movl $0x0, 0x10(%rdi,%rcx)
addq $0x18, %rcx
cmpq %rcx, %rax
jne 0x8bd2f
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/statistics.c
// Function: holm_correction
void holm_correction(Comparisonptr comparisons, int compcount, double confidence)
{
 /*Last Changed 18.11.2004*/
 int i, j;
 double corrected;
 Comparison tmp;
 for (i = 0; i < compcount; i++)
   for (j = i + 1; j < compcount; j++)
     if (comparisons[i].confidence > comparisons[j].confidence)
      {
       tmp = comparisons[i];
       comparisons[i] = comparisons[j];
       comparisons[j] = tmp;
      }
 i = 0;
 corrected = confidence / (compcount - i);
 while (i < compcount && comparisons[i].confidence < corrected)
  {
   comparisons[i].accepted = 0;
   i++;
   corrected = confidence / (compcount - i);
  }
}

// Assembly:
pushq %rbx
movl %esi, %eax
testl %esi, %esi
jle 0x8bdd5
leaq 0x18(%rdi), %rcx
movl $0x1, %edx
xorl %r8d, %r8d
movq %r8, %r9
incq %r8
cmpq %rax, %r8
jae 0x8bdc9
leaq (%r9,%r9,2), %r9
leaq (%rdi,%r9,8), %r9
movq %rax, %r10
movq %rcx, %r11
movsd 0x8(%r9), %xmm1
ucomisd 0x8(%r11), %xmm1
jbe 0x8bdbd
movq 0x10(%r9), %rbx
movq %rbx, -0x10(%rsp)
movups (%r9), %xmm1
movaps %xmm1, -0x20(%rsp)
movq 0x10(%r11), %rbx
movq %rbx, 0x10(%r9)
movups (%r11), %xmm1
movups %xmm1, (%r9)
movq -0x10(%rsp), %rbx
movq %rbx, 0x10(%r11)
movapd -0x20(%rsp), %xmm1
movupd %xmm1, (%r11)
addq $0x18, %r11
decq %r10
cmpq %r10, %rdx
jne 0x8bd79
incq %rdx
addq $0x18, %rcx
cmpq %rax, %r8
jne 0x8bd60
testl %esi, %esi
jle 0x8be02
addq $0x10, %rdi
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
ucomisd -0x8(%rdi), %xmm2
jbe 0x8be02
movl $0x0, (%rdi)
addq $0x18, %rdi
decq %rax
jne 0x8bddd
popq %rbx
retq