LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_model_svm
void save_model_svm(FILE* modelfile, Datasetptr d, Svm_modelptr m)
{
 /*Last Changed 26.12.2005*/
 char pst[READLINELENGTH];
 set_precision(pst, NULL, "\n");
 fprintf(modelfile, "%d %d\n", m->nr_class, m->l);
 fprintf(modelfile, "%d %d %d\n", m->param.svm_type, m->param.kernel_type, m->param.degree);
 fprintf(modelfile, pst, m->param.gamma);
 fprintf(modelfile, pst, m->param.coef0);
 fprintf(modelfile, pst, m->param.p);
 if (!in_list(m->param.svm_type, 3, ONE_CLASS, EPSILON_SVR, NU_SVR))
   save_array_int(modelfile, m->nSV, m->nr_class);
 save_array(modelfile, m->rho, ((m->nr_class - 1) * m->nr_class) / 2);
 if (!in_list(m->param.svm_type, 3, ONE_CLASS, EPSILON_SVR, NU_SVR))
  {
   save_array(modelfile, m->probA, ((m->nr_class - 1) * m->nr_class) / 2);
   save_array(modelfile, m->probB, ((m->nr_class - 1) * m->nr_class) / 2);
  }
 save_array_two(modelfile, m->sv_coef, m->nr_class - 1, m->l);
 save_array_support_vector(modelfile, d, m->SV, m->l);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20c76(%rip), %rdx     # 0xa919b
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3a535
movl 0x58(%r14), %edx
movl 0x5c(%r14), %ecx
leaq 0x1d8eb(%rip), %rsi     # 0xa5e2c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
movl (%r14), %edx
movl 0x4(%r14), %ecx
movl 0x8(%r14), %r8d
leaq 0x1d8c3(%rip), %rsi     # 0xa5e20
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
movsd 0x10(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
movsd 0x18(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
movsd 0x48(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
movl (%r14), %edi
movl $0x3, %esi
movl $0x2, %edx
movl $0x3, %ecx
movl $0x4, %r8d
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
jne 0x885d3
movq 0x78(%r14), %rsi
movl 0x58(%r14), %edx
movq %rbx, %rdi
callq 0x87742
movq 0x70(%r14), %rsi
movl 0x58(%r14), %eax
leal -0x1(%rax), %ecx
imull %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
movq %rbx, %rdi
callq 0x876d1
movl (%r14), %edi
movl $0x3, %esi
movl $0x2, %edx
movl $0x3, %ecx
movl $0x4, %r8d
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
jne 0x88659
movq 0xa0(%r14), %rsi
movl 0x58(%r14), %eax
leal -0x1(%rax), %ecx
imull %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
movq %rbx, %rdi
callq 0x876d1
movq 0xa8(%r14), %rsi
movl 0x58(%r14), %eax
leal -0x1(%rax), %ecx
imull %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
movq %rbx, %rdi
callq 0x876d1
movq 0x68(%r14), %rsi
movl 0x58(%r14), %edx
movl 0x5c(%r14), %ecx
decl %edx
movq %rbx, %rdi
callq 0x87791
movslq 0x5c(%r14), %r15
testq %r15, %r15
jle 0x88693
movq 0x60(%r14), %r14
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdx
movq %rbx, %rdi
callq 0x87829
incq %r12
cmpq %r12, %r15
jne 0x8867f
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_condition
void save_condition(FILE* modelfile, Decisionconditionptr condition)
{
 /*Last Changed 26.12.2005*/
 char pst[READLINELENGTH];
 fprintf(modelfile, "%d %c ", condition->featureindex, condition->comparison);
 if (condition->featureindex >= 0)
  {
   if (condition->comparison != '*')
    {
     set_precision(pst, NULL, " ");
     fprintf(modelfile, pst, condition->value);
    }
   else 
    {    
     set_precision(pst, NULL, " ");
     fprintf(modelfile, pst, condition->lowerlimit);
     set_precision(pst, NULL, " ");
     fprintf(modelfile, pst, condition->upperlimit);    
    }
  }
 else
  {
   set_precision(pst, NULL, "\n");
   fprintf(modelfile, pst, condition->w0);
   save_matrix(modelfile, condition->w);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %edx
movsbl 0x4(%rsi), %ecx
leaq 0x276b8(%rip), %rsi     # 0xafd7a
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, (%r14)
js 0x8871f
movb 0x4(%r14), %bpl
leaq 0x2000b(%rip), %rdx     # 0xa86e5
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3a535
cmpb $0x2a, %bpl
jne 0x88758
movsd 0x18(%r14), %xmm0
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
leaq 0x1ffde(%rip), %rdx     # 0xa86e5
movq %r15, %rdi
xorl %esi, %esi
callq 0x3a535
movsd 0x10(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x88764
leaq 0x20a75(%rip), %rdx     # 0xa919b
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3a535
movsd 0x30(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x87634
jmp 0x8876b
movsd 0x8(%r14), %xmm0
movq %rsp, %rsi
movq %rbx, %rdi
movb $0x1, %al
callq 0x42e0
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_rule
void save_rule(FILE* modelfile, Decisionruleptr rule, Datasetptr d)
{
 /*Last Changed 26.12.2005*/
 Decisionconditionptr tmp;
 fprintf(modelfile, "%d %d %d %d\n", rule->classno, rule->decisioncount, rule->falsepositives, rule->covered);
 save_array_int(modelfile, rule->counts, d->classno);
 tmp = rule->start;
 while (tmp)
  {
   save_condition(modelfile, tmp);
   tmp = tmp->next;
  }
 fprintf(modelfile, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x28(%rsi), %ecx
movl 0x8(%rsi), %r8d
movl (%rsi), %edx
movl 0x4(%rsi), %r9d
leaq 0x1d682(%rip), %rsi     # 0xa5e1d
xorl %eax, %eax
callq 0x42e0
movq 0x10(%r15), %rsi
movl 0x10(%r14), %edx
movq %rbx, %rdi
callq 0x87742
movq 0x18(%r15), %r14
testq %r14, %r14
je 0x887cc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x886a2
movq 0x48(%r14), %r14
jmp 0x887b6
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4150
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_model_ripper
void save_model_ripper(FILE* modelfile, Datasetptr d, Rulesetptr m)
{
 /*Last Changed 26.12.2005*/
 Decisionruleptr tmp;
 fprintf(modelfile, "%d %d\n", m->defaultclass, m->rulecount);
 save_array_int(modelfile, m->counts, d->classno);
 tmp = m->start;
 while (tmp)
  {
   save_rule(modelfile, tmp, d);
   tmp = tmp->next;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10(%rdx), %ecx
movl 0x14(%rdx), %edx
leaq 0x1d633(%rip), %rsi     # 0xa5e2c
xorl %eax, %eax
callq 0x42e0
movq 0x18(%r15), %rsi
movl 0x10(%rbx), %edx
movq %r14, %rdi
callq 0x87742
movq (%r15), %r15
testq %r15, %r15
je 0x8882b
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x88779
movq 0x30(%r15), %r15
jmp 0x88812
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_model_rise
void save_model_rise(FILE* modelfile, Datasetptr d, Model_riseptr m)
{
 int i;
 Decisionruleptr tmp;
 fprintf(modelfile, "%d\n", m->rules.rulecount);
 save_array_int(modelfile, m->counts, d->classno);
 tmp = m->rules.start;
 while (tmp)
  {
   save_rule(modelfile, tmp, d);
   tmp = tmp->next;
  }
 for (i = 0; i < d->featurecount; i++)
   if (d->features[i].type == STRING)
     save_matrix(modelfile, m->svdm[i]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x10(%rdx), %edx
leaq 0x27d92(%rip), %rsi     # 0xb05e1
xorl %eax, %eax
callq 0x42e0
movq 0x30(%rbx), %rsi
movl 0x10(%r14), %edx
movq %r15, %rdi
callq 0x87742
movq (%rbx), %r12
testq %r12, %r12
je 0x88883
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x88779
movq 0x30(%r12), %r12
jmp 0x88869
movl 0x1bc(%r14), %eax
testl %eax, %eax
jle 0x888d6
leaq 0x30f08(%r14), %r12
movl $0x8, %r13d
xorl %ebp, %ebp
cmpl $0x1, (%r12)
jne 0x888c0
movq 0x28(%rbx), %rax
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r15, %rdi
callq 0x87634
movl 0x1bc(%r14), %eax
incq %rbp
movslq %eax, %rcx
addq $0x10, %r13
addq $0x340, %r12            # imm = 0x340
cmpq %rcx, %rbp
jl 0x8889d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_model_divs
void save_model_divs(FILE* modelfile, Datasetptr d, Model_divsptr m)
{
 int i, j, k;
 fprintf(modelfile, "%d %d %d\n", m->datacount, m->M, m->epsilon);
 for (i = 0; i < m->datacount; i++)
  {
   fprintf(modelfile, "%d %d\n", m->rulecounts[i], m->classno[i]);
   save_array_int(modelfile, m->conditioncounts[i], m->rulecounts[i]);
   for (j = 0; j < m->rulecounts[i]; j++)
    {
     for (k = 0; k < m->conditioncounts[i][j]; k++)
       fprintf(modelfile, "%d %c %.6f\n", m->hypotheses[i][j][k].featureindex, m->hypotheses[i][j][k].comparison, m->hypotheses[i][j][k].value);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movl 0x20(%rdx), %edx
movl 0x24(%rbx), %ecx
movl 0x28(%rbx), %r8d
leaq 0x1d516(%rip), %rsi     # 0xa5e20
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x20(%rbx)
jle 0x88a1c
movq %rbx, %rdi
movq 0x8(%rbx), %rax
leaq 0x284e6(%rip), %rsi     # 0xb0e0f
xorl %r13d, %r13d
movq %r15, 0x10(%rsp)
movq %rbx, 0x8(%rsp)
movq 0x10(%rsp), %rbx
movq %rsi, %r14
movl (%rax,%r13,4), %edx
movq 0x10(%rdi), %rax
movl (%rax,%r13,4), %ecx
movq %r15, %rdi
leaq 0x1d4d8(%rip), %rsi     # 0xa5e2c
xorl %eax, %eax
callq 0x42e0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx,%r13,8), %rsi
movl (%rax,%r13,4), %edx
movq %r15, %rdi
callq 0x87742
movq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rax
cmpl $0x0, (%rax,%r13,4)
jle 0x88a04
movq 0x18(%rdi), %rcx
xorl %ebp, %ebp
movq %r14, %rsi
movq (%rcx,%r13,8), %rdx
cmpl $0x0, (%rdx,%rbp,4)
jle 0x889f6
movl $0x8, %r15d
xorl %r12d, %r12d
movq (%rdi), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%rbp,8), %rax
movl -0x8(%rax,%r15), %edx
movsbl -0x4(%rax,%r15), %ecx
movsd (%rax,%r15), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
movb $0x1, %al
callq 0x42e0
movq 0x8(%rsp), %rdi
incq %r12
movq 0x18(%rdi), %rcx
movq (%rcx,%r13,8), %rax
movslq (%rax,%rbp,4), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x889a9
movq %r14, %rsi
movq 0x8(%rdi), %rax
incq %rbp
movslq (%rax,%r13,4), %rdx
cmpq %rdx, %rbp
jl 0x88996
jmp 0x88a07
movq %r14, %rsi
incq %r13
movslq 0x20(%rdi), %rcx
cmpq %rcx, %r13
movq 0x10(%rsp), %r15
jl 0x8893b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_model_onefeature
void save_model_onefeature(FILE* modelfile, Datasetptr d, Model_onefeatureptr m)
{
 /*Last Changed 27.12.2005*/
 char pst[READLINELENGTH];
 set_precision(pst, NULL, " ");
	fprintf(modelfile, "%d ", m->bestfeature);
	fprintf(modelfile, pst, m->bestsplit);
	fprintf(modelfile, pst, m->leftmean);
	fprintf(modelfile, pst, m->rightmean);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x7a120, %rsp          # imm = 0x7A120
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x1fca1(%rip), %rdx     # 0xa86e5
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3a535
movl (%r14), %edx
leaq 0x2732a(%rip), %rsi     # 0xafd85
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
movsd 0x8(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
movsd 0x10(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
movsd 0x18(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_model_quantizereg
void save_model_quantizereg(FILE* modelfile, Datasetptr d, Model_quantizeregptr m)
{
 /*Last Changed 27.12.2005*/
 char pst[READLINELENGTH];
 set_precision(pst, NULL, " ");
	fprintf(modelfile, "%d ", m->partitioncount);
	if (d->multifeaturecount == 2)
	 {
		 fprintf(modelfile, pst, m->binx);
		 fprintf(modelfile, pst, m->minx);
			save_array(modelfile, m->meansone, m->partitioncount);
	 }
	else
	 {
		 fprintf(modelfile, pst, m->binx);
		 fprintf(modelfile, pst, m->minx);
		 fprintf(modelfile, pst, m->biny);
		 fprintf(modelfile, pst, m->miny);
			save_array_two(modelfile, m->meanstwo, m->partitioncount, m->partitioncount);
			save_matrix(modelfile, m->eigenvectors);
	 }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7a120, %rsp          # imm = 0x7A120
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1fb83(%rip), %rdx     # 0xa86e5
movq %rsp, %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x3a535
movl 0x40(%r14), %edx
leaq 0x2720b(%rip), %rsi     # 0xafd85
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
movl 0x1c0(%r15), %ebp
movsd 0x8(%r14), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
movsd (%r14), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
cmpl $0x2, %ebp
jne 0x88bc7
movq 0x20(%r14), %rsi
movl 0x40(%r14), %edx
movq %rbx, %rdi
callq 0x876d1
jmp 0x88c12
movsd 0x18(%r14), %xmm0
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
movsd 0x10(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
movq 0x28(%r14), %rsi
movl 0x40(%r14), %ecx
movq %rbx, %rdi
movl %ecx, %edx
callq 0x87791
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x87634
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_model_regtree
void save_model_regtree(FILE* modelfile, Datasetptr d, Regressionnodeptr m, int level)
{
 /*Last Changed 29.05.2006*/
 char pst[READLINELENGTH];
 int i, size;
 for (i = 0; i < level; i++)
   fprintf(modelfile, "  ");
 set_precision(pst, NULL, "\n"); 
 fprintf(modelfile, "%d ", m->featureno);
 if (m->featureno == LEAF_NODE)
  {
   size = data_size(m->instances);
   fprintf(modelfile, "%d ", m->leaftype);
   if (m->leaftype == CONSTANTLEAF)
     fprintf(modelfile, pst, m->regressionvalue);   
   else
     save_matrix(modelfile, m->w);   
  }
 else
  {
   if (m->featureno >= 0)
     fprintf(modelfile, pst, m->split);   
   else
     if (m->featureno == LINEAR)
      {
       save_instance(modelfile, d, m->leftcenter, BOOLEAN_FALSE);
       save_instance(modelfile, d, m->rightcenter, BOOLEAN_FALSE);
      }
     else
       if (m->featureno == QUADRATIC)
        {
         save_instance_2d(modelfile, d, m->leftcenter, BOOLEAN_FALSE);
         save_instance_2d(modelfile, d, m->rightcenter, BOOLEAN_FALSE);
        }
       else
         if (m->featureno == SOFTLIN)
           save_matrix(modelfile, m->w);
   save_model_regtree(modelfile, d, m->left, level + 1);
   save_model_regtree(modelfile, d, m->right, level + 1);
  } 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testl %ecx, %ecx
jle 0x88c66
leaq 0x281c3(%rip), %r12     # 0xb0e0c
movl %ebp, %r13d
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x42c0
decl %r13d
jne 0x88c4c
leaq 0x2052e(%rip), %rdx     # 0xa919b
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3a535
movl 0x68(%r14), %edx
leaq 0x27103(%rip), %rsi     # 0xafd85
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
movl 0x68(%r14), %eax
cmpl $-0x1, %eax
je 0x88cd4
testl %eax, %eax
js 0x88d0b
movsd 0x50(%r14), %xmm0
movq %rsp, %rsi
movq %rbx, %rdi
movb $0x1, %al
callq 0x42e0
movq (%r14), %rdx
incl %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x88c22
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x88c22
jmp 0x88d5a
movq 0x20(%r14), %rdi
callq 0x30309
movl 0x6c(%r14), %edx
leaq 0x2709d(%rip), %rsi     # 0xafd85
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x6c(%r14)
je 0x88d47
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x87634
jmp 0x88d5a
cmpl $-0x6, %eax
je 0x88d95
cmpl $-0x3, %eax
je 0x88d6c
cmpl $-0x2, %eax
jne 0x88cac
movq 0x80(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8790a
movq 0x88(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8790a
jmp 0x88cac
movsd 0x70(%r14), %xmm0
movq %rsp, %rsi
movq %rbx, %rdi
movb $0x1, %al
callq 0x42e0
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x80(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x879b6
movq 0x88(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x879b6
jmp 0x88cac
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x87634
jmp 0x88cac
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_model_gprocessreg
void save_model_gprocessreg(FILE* modelfile, Datasetptr d, Model_gprocessregressionptr m)
{
 /*!Last Changed 15.01.2009*/
 Instanceptr tmp;
 fprintf(modelfile, "%d\n", m->size);
 tmp = m->data;
 while (tmp)
  {
   save_instance(modelfile, d, tmp, BOOLEAN_TRUE);
   tmp = tmp->next;
  }
 save_array(modelfile, m->weights, m->size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdx), %edx
leaq 0x27571(%rip), %rsi     # 0xb05e1
xorl %eax, %eax
callq 0x42e0
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x89095
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x8790a
movq 0x10(%r12), %r12
jmp 0x8907b
movq 0x10(%rbx), %rsi
movl (%rbx), %edx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x876d1
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/screen.c
// Function: graph_info
void graph_info(bayesiangraphptr mygraph)
{
 int i, j, pos;
 fprintf(output, "Graph Name:%s\n", mygraph->name);
 fprintf(output, "Node Count:%d\n", mygraph->nodecount);
 fprintf(output, "Arc Count:%d\n", mygraph->arccount);
 for (i = 0; i < mygraph->nodecount; i++)
  {
   fprintf(output, "Node %d: %s\n", i + 1, mygraph->nodes[i].name);
   fprintf(output, "Parents:");
   pos = mygraph->nodes[i].pointer;
   while (pos != -1)
    {
     fprintf(output, "%s ", mygraph->nodes[mygraph->dest[pos]].name);
     pos = mygraph->arcs[pos].pointer;
    }
   fprintf(output, "\n");
   fprintf(output, "Values:");
   for (j = 0; j < mygraph->nodes[i].value_count; j++)
     fprintf(output, "%s ", mygraph->nodes[i].values[j]);
   fprintf(output, "\n");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x327e17(%rip), %r14    # 0x3b20a8
movq (%r14), %rdi
movq (%rbx), %rdx
leaq 0x27062(%rip), %rsi     # 0xb1300
xorl %eax, %eax
callq 0x42e0
movq (%r14), %rdi
movl 0x10(%rbx), %edx
leaq 0x2705d(%rip), %rsi     # 0xb130f
xorl %eax, %eax
callq 0x42e0
movq (%r14), %rdi
movl 0x20(%rbx), %edx
leaq 0x27058(%rip), %rsi     # 0xb131e
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x10(%rbx)
jle 0x8a3e8
leaq 0x26b6d(%rip), %r13     # 0xb0e4b
xorl %ebp, %ebp
movq (%r14), %rdi
leaq 0x1(%rbp), %rdx
movq 0x8(%rbx), %rax
leaq (,%rbp,8), %rcx
leaq (%rcx,%rcx,8), %r15
movq (%rax,%r15), %rcx
leaq 0x2702a(%rip), %rsi     # 0xb132c
movq %rdx, (%rsp)
xorl %eax, %eax
callq 0x42e0
movq (%r14), %rcx
movl $0x8, %esi
movl $0x1, %edx
leaq 0x27018(%rip), %rdi     # 0xb1339
callq 0x42c0
movq 0x8(%rbx), %rax
movl 0x30(%rax,%r15), %eax
cmpl $-0x1, %eax
je 0x8a362
movq (%r14), %rdi
movq 0x8(%rbx), %rcx
movq 0x28(%rbx), %rdx
movslq %eax, %r12
movslq (%rdx,%r12,4), %rax
leaq (%rax,%rax,8), %rax
movq (%rcx,%rax,8), %rdx
movq %r13, %rsi
xorl %eax, %eax
callq 0x42e0
movq 0x18(%rbx), %rax
movl (%rax,%r12,4), %eax
jmp 0x8a32f
movq (%r14), %rsi
movl $0xa, %edi
callq 0x4150
movq (%r14), %rcx
movl $0x7, %esi
movl $0x1, %edx
leaq 0x26fbf(%rip), %rdi     # 0xb1342
callq 0x42c0
movq 0x8(%rbx), %rax
leaq (,%rbp,8), %rcx
addq %rbp, %rcx
cmpl $0x0, 0x10(%rax,%rcx,8)
jle 0x8a3c7
xorl %ebp, %ebp
movq (%r14), %rdi
movq 0x8(%rax,%r15), %rax
movq (%rax,%rbp,8), %rdx
movq %r13, %rsi
xorl %eax, %eax
callq 0x42e0
incq %rbp
movq 0x8(%rbx), %rax
movslq 0x10(%rax,%r15), %rcx
cmpq %rcx, %rbp
jl 0x8a3a0
movq (%r14), %rsi
movl $0xa, %edi
callq 0x4150
movslq 0x10(%rbx), %rax
movq (%rsp), %rcx
movq %rcx, %rbp
cmpq %rax, %rcx
jl 0x8a2e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/screen.c
// Function: print_zero_independence
void print_zero_independence(bayesiangraphptr mygraph)
{
/*Last Changed 04.02.2001*/
 int i, j;
 for (i = 0; i < mygraph->nodecount; i++)
  {
   for (j = 0; j < mygraph->nodecount; j++)
     fprintf(output, "%8.4f", mygraph->independence[i][j]);
   fprintf(output, "\n");
  }
}

// Assembly:
movl 0x10(%rdi), %eax
testl %eax, %eax
jle 0x8a6a0
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x327a61(%rip), %r12    # 0x3b20a8
leaq 0x26d61(%rip), %r14     # 0xb13af
testl %eax, %eax
jle 0x8a67d
xorl %r13d, %r13d
movq (%r12), %rdi
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r13,8), %xmm0
movq %r14, %rsi
movb $0x1, %al
callq 0x42e0
incq %r13
movslq 0x10(%rbx), %rax
cmpq %rax, %r13
jl 0x8a655
movq (%r12), %rsi
movl $0xa, %edi
callq 0x4150
incq %r15
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jl 0x8a64e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/screen.c
// Function: print_one_independence
void print_one_independence(bayesiangraphptr mygraph)
{
/*Last Changed 04.02.2001*/
 int i, j, k, l = 0;
 for (i = 0; i < mygraph->nodecount; i++)
   for (j = 0; j < mygraph->nodecount; j++)
     for (k = 0; k < mygraph->nodecount; k++)
       if ((i != j) && (i != k) && (j != k))
        {
         fprintf(output, "%d %d %d %8.4f\n", i, j, k, mygraph->one_independence[i][j][k]);
         l++;
         if (l % 23 == 0)
          {
           fprintf(output, "Press any key to continue\n");
           getc(stdin);
          }
        }
}

// Assembly:
movl 0x10(%rdi), %eax
testl %eax, %eax
jle 0x8a796
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x3279e4(%rip), %r12    # 0x3b20a8
xorl %r15d, %r15d
testl %eax, %eax
jle 0x8a779
xorl %r13d, %r13d
testl %eax, %eax
jle 0x8a76a
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x8a756
cmpq %r13, %r14
je 0x8a756
cmpq %rbp, %r14
je 0x8a756
movq (%r12), %rdi
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%rbp,8), %xmm0
leaq 0x26cae(%rip), %rsi     # 0xb13b5
movl %r14d, %edx
movl %r13d, %ecx
movl %ebp, %r8d
movb $0x1, %al
callq 0x42e0
imull $0xe9bd37a7, %r15d, %eax # imm = 0xE9BD37A7
incl %r15d
addl $0xef4de9bd, %eax       # imm = 0xEF4DE9BD
cmpl $0xb21642c, %eax        # imm = 0xB21642C
ja 0x8a756
movq (%r12), %rcx
movl $0x1a, %esi
movl $0x1, %edx
leaq 0x26c83(%rip), %rdi     # 0xb13c5
callq 0x42c0
movq 0x49882(%rip), %rax     # 0xd3fd0
movq (%rax), %rdi
callq 0x4350
incq %rbp
movl 0x10(%rbx), %eax
movslq %eax, %rcx
cmpq %rcx, %rbp
jl 0x8a6dc
jmp 0x8a76d
movslq %eax, %rcx
incq %r13
cmpq %rcx, %r13
jl 0x8a6d2
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x8a6c7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/screen.c
// Function: display_file
void display_file(char* file_name)
{
 FILE* infile;
 char line[READLINELENGTH];
 infile = fopen(file_name, "r");
 if (!infile)
  {
   printf(m1052);
   return;
  }
 while (fgets(line, READLINELENGTH, infile))
   printf("%s", line);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x7a120, %rsp          # imm = 0x7A120
leaq 0x211b1(%rip), %rsi     # 0xab95b
callq 0x40f0
testq %rax, %rax
je 0x8a805
movq %rax, %rbx
movq %rsp, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
testq %rax, %rax
je 0x8a7f8
leaq 0x1d77d(%rip), %r14     # 0xa7f50
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4030
movq %r15, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rbx, %rdx
callq 0x4120
testq %rax, %rax
jne 0x8a7d6
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cfa3(%rip), %rdi     # 0xa77af
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/screen.c
// Function: print_time
void print_time(double t)
{
 int tmp;
 if (t > SECONDS_IN_A_DAY)
  {
   tmp = (int)(t / SECONDS_IN_A_DAY);
   printf(m1310, tmp);
   t = t - tmp * SECONDS_IN_A_DAY;
  }
 if (t > SECONDS_IN_A_HOUR)
  {
   tmp = (int)(t / SECONDS_IN_A_HOUR);
   printf(m1311, tmp);
   t = t - tmp * SECONDS_IN_A_HOUR;
  }
 if (t > SECONDS_IN_A_MINUTE)
  {
   tmp = (int)(t / SECONDS_IN_A_MINUTE);
   printf(m1312, tmp);
   t = t - tmp * SECONDS_IN_A_MINUTE;
  }
 printf(m1313, t);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
ucomisd 0x26ab6(%rip), %xmm0    # 0xb12e0
jbe 0x8a879
movapd %xmm0, %xmm2
divsd 0x26ab0(%rip), %xmm2    # 0xb12e8
movsd %xmm0, 0x8(%rsp)
movsd 0x26aaa(%rip), %xmm1    # 0xb12f0
mulsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
cvttsd2si %xmm2, %ebx
leaq 0x26b87(%rip), %rdi     # 0xb13e0
movl %ebx, %esi
xorl %eax, %eax
callq 0x4030
movsd 0x8(%rsp), %xmm0
imull $0x15180, %ebx, %eax    # imm = 0x15180
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
ucomisd 0x26a77(%rip), %xmm0    # 0xb12f8
jbe 0x8a8ca
movsd 0x26a65(%rip), %xmm2    # 0xb12f0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
divsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
cvttsd2si %xmm1, %ebx
leaq 0x26b3e(%rip), %rdi     # 0xb13e8
movl %ebx, %esi
xorl %eax, %eax
callq 0x4030
movsd 0x8(%rsp), %xmm0
imull $0xe10, %ebx, %eax      # imm = 0xE10
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
ucomisd 0x26a1e(%rip), %xmm0    # 0xb12f0
jbe 0x8a90e
movapd %xmm0, %xmm1
divsd 0x26a10(%rip), %xmm1    # 0xb12f0
cvttsd2si %xmm1, %ebx
leaq 0x26b06(%rip), %rdi     # 0xb13f1
movl %ebx, %esi
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
callq 0x4030
movsd 0x8(%rsp), %xmm0
imull $0x3c, %ebx, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
leaq 0x26ae4(%rip), %rdi     # 0xb13f9
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
jmp 0x4030
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x8a9b3
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq %r14, %rdx
callq 0x76f0b
callq 0x55a80
movq (%rbx), %rdi
movsd %xmm0, 0x48(%rdi)
movsd 0x1abc4(%rip), %xmm1    # 0xa5520
subsd %xmm0, %xmm1
movq 0x8(%rbx), %rax
movsd %xmm1, 0x48(%rax)
movsd 0x48(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rsi
callq 0x8a924
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
movsd 0x48(%rdi), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rsi
callq 0x8a924
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x8a9d0
cmpl $0x0, 0x6c(%rbx)
je 0x8a9cb
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq %r14, %rdx
callq 0x76f0b
jmp 0x8a9d0
movsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x40(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8aa4b
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 0x2f35e
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8a924
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 0x8a9f6
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x8aa53
movsd 0x1b2bd(%rip), %xmm1    # 0xa5d10
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3ed51
cmpl $0x0, 0x6c(%rbx)
je 0x8ae83
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x3ed51
movq 0x8(%rbx), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
popq %rbx
jmp 0x3ed51
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3dae3
movq %rax, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
cmpl $0x0, 0x6c(%r14)
je 0x8aee6
movq (%rbx), %r15
movq (%r14), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x3dae3
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 0x3dae3
movq %rax, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
jmp 0x8af08
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_O3/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 0x8b2ff
movq (%rbx), %rdi
movapd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x8b2bb
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x8b2bb
addsd (%rsp), %xmm0
jmp 0x8b39f
cmpl $0x0, 0x6c(%rbx)
je 0x8b31e
movq 0x38(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
mulsd %xmm1, %xmm0
addsd (%rcx), %xmm0
jmp 0x8b323
movsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rbx), %rax
movsd 0x1a1eb(%rip), %xmm2    # 0xa5520
testq %rax, %rax
je 0x8b395
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 0x55a80
movq 0x18(%rbx), %rbx
cmpq (%rbx), %r14
je 0x8b37d
movsd 0x1a1ab(%rip), %xmm1    # 0xa5520
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd (%rsp), %xmm2
mulsd %xmm0, %xmm2
movq 0x18(%rbx), %rax
testq %rax, %rax
movsd 0x8(%rsp), %xmm1
jne 0x8b340
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq $0x0, 0x28(%r15)
cmpq %r12, %r15
je 0x8b3d0
movq $0x0, 0x20(%r15)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8af0e
testl %eax, %eax
je 0x8b3fc
movq (%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8b3a7
movq 0x8(%r15), %r15
jmp 0x8b3bb
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x8b4b9
movq %rsi, %r15
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
movq %r15, %rdx
callq 0x76f0b
callq 0x55a80
movq (%rbx), %rdi
movsd %xmm0, 0x78(%rdi)
movsd 0x1a0d6(%rip), %xmm1    # 0xa5520
subsd %xmm0, %xmm1
movq 0x8(%rbx), %rax
movsd %xmm1, 0x78(%rax)
movq %r15, %rsi
callq 0x8b410
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x8b410
leaq 0x4a3fb(%rip), %rcx     # 0xd5870
movq (%rcx), %rcx
movslq 0x10(%rcx), %rcx
testq %rcx, %rcx
jle 0x8b4d8
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 0x8b48f
jmp 0x8b4d8
movq 0x50(%rbx), %rsi
movq 0x70(%rbx), %rdi
leaq 0x4a3a8(%rip), %rax     # 0xd5870
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_O3/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 0x8b571
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
movq %r14, %rdx
callq 0x76f0b
callq 0x55a80
movq (%rbx), %rdi
movsd %xmm0, 0x78(%rdi)
movsd 0x1a006(%rip), %xmm1    # 0xa5520
subsd %xmm0, %xmm1
movq 0x8(%rbx), %rax
movsd %xmm1, 0x78(%rax)
movsd 0x78(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rsi
callq 0x8b4e2
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
movsd 0x78(%rdi), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rsi
callq 0x8b4e2
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x8b58e
cmpl $0x0, 0x60(%rbx)
je 0x8b589
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
movq %r14, %rdx
callq 0x76f0b
jmp 0x8b58e
movsd 0x48(%rbx), %xmm0
movsd %xmm0, 0x68(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8b5f1
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x4a2b9(%rip), %r12     # 0xd5870
movq %rbx, %rdi
callq 0x2f33a
movl %eax, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8b410
movq (%r12), %rcx
movl 0x10(%rcx), %esi
movq %rax, %rdi
callq 0x38031
xorl %ecx, %ecx
cmpl %r15d, %eax
setne %cl
addl %ecx, %ebp
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x8b5b7
jmp 0x8b5f3
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8b66c
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x2f33a
movl %eax, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8b4e2
callq 0x55a80
ucomisd 0x1a6e3(%rip), %xmm0    # 0xa5d18
seta %al
testl %r15d, %r15d
sete %cl
testb %cl, %al
jne 0x8b65f
movsd 0x1a6ce(%rip), %xmm1    # 0xa5d18
ucomisd %xmm0, %xmm1
seta %al
cmpl $0x1, %r15d
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x8b661
incl %ebp
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x8b612
jmp 0x8b66e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3ed51
cmpl $0x0, 0x60(%rbx)
je 0x8bf42
movq (%rbx), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x3ed51
movq 0x8(%rbx), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
popq %rbx
jmp 0x3ed51
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3dae3
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
cmpl $0x0, 0x60(%r14)
je 0x8c006
movq (%rbx), %r15
movq (%r14), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x3dae3
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 0x3dae3
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
jmp 0x8c028
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_O3/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:
cmpl $-0x1, 0x30(%rdi)
je 0x8c777
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x49179(%rip), %r13     # 0xd5870
xorpd %xmm1, %xmm1
leaq 0x1e2fb(%rip), %r12     # 0xaa9fd
movq (%r13), %rax
movslq 0x1c0(%rax), %rax
movl $0x0, %r8d
testq %rax, %rax
jle 0x8c73e
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 0x8c721
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 0x8c6d5
xorpd %xmm1, %xmm1
movq 0x8(%r15), %r15
cmpl $-0x1, 0x30(%r15)
jne 0x8c702
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq %r12, %r15
je 0x8c799
movq $0x0, 0x20(%r15)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8c02e
testl %eax, %eax
je 0x8c7c5
movq (%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8c778
movq 0x8(%r15), %r15
jmp 0x8c78c
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq %r12, %r15
je 0x8c7f7
movq $0x0, 0x20(%r15)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8c341
testl %eax, %eax
je 0x8c823
movq (%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8c7d6
movq 0x8(%r15), %r15
jmp 0x8c7ea
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x194d8(%rip), %xmm0    # 0xa5d18
ucomisd %xmm1, %xmm0
jbe 0x8c84f
movsd 0x18cd2(%rip), %xmm0    # 0xa5520
retq
pushq %rax
movapd %xmm1, %xmm0
addsd %xmm1, %xmm0
movsd %xmm1, (%rsp)
callq 0x4160
movapd %xmm0, %xmm1
movsd 0x18cb2(%rip), %xmm2    # 0xa5520
addsd %xmm2, %xmm1
movsd (%rsp), %xmm0
addsd 0x24bc9(%rip), %xmm0    # 0xb1448
divsd %xmm0, %xmm1
movsd 0x24bc5(%rip), %xmm3    # 0xb1450
mulsd %xmm1, %xmm3
movsd 0x24bc1(%rip), %xmm0    # 0xb1458
divsd %xmm1, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x8c8af
sqrtsd %xmm0, %xmm0
jmp 0x8c8be
movsd %xmm3, (%rsp)
callq 0x4300
movsd (%rsp), %xmm3
addsd 0x18c5a(%rip), %xmm0    # 0xa5520
mulsd %xmm3, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18c45(%rip), %xmm0    # 0xa5520
jbe 0x8c8ea
movsd 0x19433(%rip), %xmm4    # 0xa5d18
jmp 0x8c9cc
movapd %xmm0, %xmm1
movsd 0x1b4ca(%rip), %xmm0    # 0xa7dc0
movsd %xmm1, 0x8(%rsp)
callq 0x8c834
ucomisd 0x8(%rsp), %xmm0
movsd 0x1b4b1(%rip), %xmm2    # 0xa7dc0
jbe 0x8c940
movsd 0x1b4a7(%rip), %xmm2    # 0xa7dc0
mulsd 0x1b497(%rip), %xmm2    # 0xa7db8
movapd %xmm2, 0x10(%rsp)
movapd 0x10(%rsp), %xmm0
callq 0x8c834
ucomisd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm2
ja 0x8c919
movsd 0x193d0(%rip), %xmm1    # 0xa5d18
xorpd %xmm3, %xmm3
movsd %xmm3, 0x28(%rsp)
movapd %xmm2, 0x10(%rsp)
movapd %xmm2, %xmm0
movsd %xmm1, 0x20(%rsp)
addsd %xmm1, %xmm0
mulsd 0x193aa(%rip), %xmm0    # 0xa5d18
movapd %xmm0, 0x30(%rsp)
callq 0x8c834
movapd 0x30(%rsp), %xmm4
movsd 0x8(%rsp), %xmm2
ucomisd %xmm2, %xmm0
movapd %xmm4, %xmm1
ja 0x8c995
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 0x19826(%rip), %xmm3    # 0xa61e0
ucomisd 0x19416(%rip), %xmm3    # 0xa5dd8
orpd %xmm0, %xmm2
movapd %xmm4, %xmm3
ja 0x8c94c
movapd %xmm4, %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24a7e(%rip), %rsi     # 0xb1460
movl $0x10, %edi
movl $0x2, %edx
callq 0x3a0e1
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq $0x0, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x24a65(%rip), %rsi     # 0xb1478
movl $0x30, %edi
movl $0x2, %edx
callq 0x3a0e1
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