LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x1ddf5(%rip), %rdx     # 0x9910b
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x35305
movl 0x58(%r14), %edx
movl 0x5c(%r14), %ecx
leaq 0x1ab02(%rip), %rsi     # 0x95e34
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
movl (%r14), %edx
movl 0x4(%r14), %ecx
movl 0x8(%r14), %r8d
leaq 0x1aada(%rip), %rsi     # 0x95e28
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
pushq $0x2
popq %rbp
pushq $0x3
popq %rcx
pushq $0x4
popq %r8
movl %ecx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
jne 0x7b3bd
movq 0x78(%r14), %rsi
movl 0x58(%r14), %edx
movq %rbx, %rdi
callq 0x7a595
movq 0x70(%r14), %rsi
movl 0x58(%r14), %ecx
leal -0x1(%rcx), %eax
imull %ecx, %eax
cltd
idivl %ebp
movq %rbx, %rdi
movl %eax, %edx
callq 0x7a51f
movl (%r14), %edi
pushq $0x3
popq %rcx
pushq $0x4
popq %r8
movl %ecx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
jne 0x7b42d
movq 0xa0(%r14), %rsi
movl 0x58(%r14), %ecx
leal -0x1(%rcx), %eax
imull %ecx, %eax
cltd
idivl %ebp
movq %rbx, %rdi
movl %eax, %edx
callq 0x7a51f
movq 0xa8(%r14), %rsi
movl 0x58(%r14), %ecx
leal -0x1(%rcx), %eax
imull %ecx, %eax
cltd
idivl %ebp
movq %rbx, %rdi
movl %eax, %edx
callq 0x7a51f
movq 0x68(%r14), %rsi
movl 0x58(%r14), %edx
movl 0x5c(%r14), %ecx
decl %edx
movq %rbx, %rdi
callq 0x7a5e8
movq 0x60(%r14), %rdx
movl 0x5c(%r14), %ecx
movq %rbx, %rdi
callq 0x7a71b
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2482c(%rip), %rsi     # 0x9fcad
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, (%r14)
js 0x7b4de
movb 0x4(%r14), %bpl
leaq 0x1d1cc(%rip), %rdx     # 0x98665
movq %rsp, %rdi
xorl %esi, %esi
callq 0x35305
cmpb $0x2a, %bpl
jne 0x7b517
movsd 0x18(%r14), %xmm0
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
leaq 0x1d19f(%rip), %rdx     # 0x98665
movq %r15, %rdi
xorl %esi, %esi
callq 0x35305
movsd 0x10(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x7b523
leaq 0x1dc26(%rip), %rdx     # 0x9910b
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x35305
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 0x7a484
jmp 0x7b52a
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_O2/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl 0x28(%rsi), %ecx
movl 0x8(%rsi), %r8d
movl (%rsi), %edx
movl 0x4(%rsi), %r9d
leaq 0x1a8cb(%rip), %rsi     # 0x95e25
xorl %eax, %eax
callq 0x42e0
movq 0x10(%r14), %rsi
movl 0x10(%r15), %edx
movq %rbx, %rdi
callq 0x7a595
addq $0x18, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x7b58e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7b461
addq $0x48, %r14
jmp 0x7b575
pushq $0xa
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4150
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x10(%rdx), %ecx
movl 0x14(%rdx), %edx
leaq 0x1a87b(%rip), %rsi     # 0x95e34
xorl %eax, %eax
callq 0x42e0
movq 0x18(%rbx), %rsi
movl 0x10(%r14), %edx
movq %r15, %rdi
callq 0x7a595
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x7b5ec
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7b538
addq $0x30, %rbx
jmp 0x7b5d0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x24f35(%rip), %rsi     # 0xa0545
xorl %eax, %eax
callq 0x42e0
movq 0x30(%rbx), %rsi
movl 0x10(%r14), %edx
movq %r15, %rdi
callq 0x7a595
movq %rbx, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x7b647
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x7b538
addq $0x30, %r12
jmp 0x7b62a
leaq 0x30f08(%r14), %r12
pushq $0x8
popq %r13
xorl %ebp, %ebp
movslq 0x1bc(%r14), %rax
cmpq %rax, %rbp
jge 0x7b68c
cmpl $0x1, (%r12)
jne 0x7b67c
movq 0x28(%rbx), %rax
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r15, %rdi
callq 0x7a484
incq %rbp
addq $0x10, %r13
addq $0x340, %r12            # imm = 0x340
jmp 0x7b654
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl 0x20(%rdx), %edx
movl 0x24(%rbx), %ecx
movl 0x28(%rbx), %r8d
leaq 0x1a76b(%rip), %rsi     # 0x95e28
xorl %eax, %eax
callq 0x42e0
xorl %ebp, %ebp
movslq 0x20(%rbx), %rax
cmpq %rax, %rbp
jge 0x7b774
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movl (%rax,%rbp,4), %edx
movl (%rcx,%rbp,4), %ecx
movq %r14, %rdi
leaq 0x1a749(%rip), %rsi     # 0x95e34
xorl %eax, %eax
callq 0x42e0
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx,%rbp,8), %rsi
movl (%rax,%rbp,4), %edx
movq %r14, %rdi
callq 0x7a595
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movslq (%rax,%rbp,4), %rax
cmpq %rax, %r15
jge 0x7b76c
pushq $0x8
popq %r13
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
movq (%rax,%rbp,8), %rax
movslq (%rax,%r15,4), %rax
cmpq %rax, %r12
jge 0x7b767
movq (%rbx), %rax
movq (%rax,%rbp,8), %rax
movq (%rax,%r15,8), %rax
movl -0x8(%rax,%r13), %edx
movsbl -0x4(%rax,%r13), %ecx
movsd (%rax,%r13), %xmm0
movq %r14, %rdi
leaq 0x2561c(%rip), %rsi     # 0xa0d73
movb $0x1, %al
callq 0x42e0
incq %r12
addq $0x10, %r13
jmp 0x7b720
incq %r15
jmp 0x7b70c
incq %rbp
jmp 0x7b6c6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0x1cec9(%rip), %rdx     # 0x98665
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x35305
movl (%r14), %edx
leaq 0x24505(%rip), %rsi     # 0x9fcb8
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_O2/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 0x1cdab(%rip), %rdx     # 0x98665
movq %rsp, %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x35305
movl 0x40(%r14), %edx
leaq 0x243e6(%rip), %rsi     # 0x9fcb8
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 0x7b91f
movq 0x20(%r14), %rsi
movl 0x40(%r14), %edx
movq %rbx, %rdi
callq 0x7a51f
jmp 0x7b96a
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 0x7a5e8
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x7a484
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2478d(%rip), %rsi     # 0xa0545
xorl %eax, %eax
callq 0x42e0
leaq 0x8(%rbx), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x7bde0
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7a756
addq $0x10, %r12
jmp 0x7bdc3
movq 0x10(%rbx), %rsi
movl (%rbx), %edx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7a51f
// File: /workspace/github_c_makefile_star2_O2/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 0x32d43b(%rip), %r15    # 0x3aa0a8
movq (%r15), %rdi
movq (%rbx), %rdx
leaq 0x245e6(%rip), %rsi     # 0xa1260
xorl %eax, %eax
callq 0x42e0
movq (%r15), %rdi
movl 0x10(%rbx), %edx
leaq 0x245e1(%rip), %rsi     # 0xa126f
xorl %eax, %eax
callq 0x42e0
movq (%r15), %rdi
movl 0x20(%rbx), %edx
leaq 0x245dc(%rip), %rsi     # 0xa127e
xorl %eax, %eax
callq 0x42e0
leaq 0x240ff(%rip), %r12     # 0xa0daf
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jge 0x7cd96
movq (%r15), %rdi
movq 0x8(%rbx), %rax
imulq $0x48, %r14, %r13
incq %r14
movq (%rax,%r13), %rcx
leaq 0x245b3(%rip), %rsi     # 0xa128c
movl %r14d, %edx
xorl %eax, %eax
callq 0x42e0
movq (%r15), %rcx
leaq 0x245ac(%rip), %rdi     # 0xa1299
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
callq 0x42c0
movq 0x8(%rbx), %rax
leaq (%rax,%r13), %rbp
addq $0x30, %rbp
movslq (%rbp), %rbp
movq (%r15), %rsi
cmpq $-0x1, %rbp
je 0x7cd3c
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rcx
movslq (%rcx,%rbp,4), %rcx
shlq $0x2, %rbp
imulq $0x48, %rcx, %rcx
movq (%rax,%rcx), %rdx
movq %rsi, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x42e0
addq 0x18(%rbx), %rbp
jmp 0x7cd04
pushq $0xa
popq %rdi
callq 0x4150
movq (%r15), %rcx
leaq 0x24554(%rip), %rdi     # 0xa12a2
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x42c0
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
movslq 0x10(%rax,%r13), %rcx
movq (%r15), %rsi
cmpq %rcx, %rbp
jge 0x7cd89
addq %r13, %rax
movq 0x8(%rax), %rax
movq (%rax,%rbp,8), %rdx
movq %rsi, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x42e0
incq %rbp
jmp 0x7cd5b
pushq $0xa
popq %rdi
callq 0x4150
jmp 0x7ccb3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x32d12e(%rip), %r12    # 0x3aa0a8
leaq 0x2438e(%rip), %r14     # 0xa130f
pushq $0xa
popq %rbp
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jge 0x7cfca
xorl %r13d, %r13d
cltq
movq (%r12), %rsi
cmpq %rax, %r13
jge 0x7cfbe
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%r13,8), %xmm0
movq %rsi, %rdi
movq %r14, %rsi
movb $0x1, %al
callq 0x42e0
incq %r13
movl 0x10(%rbx), %eax
jmp 0x7cf90
movl %ebp, %edi
callq 0x4150
incq %r15
jmp 0x7cf84
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %eax
xorl %r14d, %r14d
leaq 0x32d0b4(%rip), %r15    # 0x3aa0a8
xorl %r12d, %r12d
movslq %eax, %rcx
cmpq %rcx, %r14
jge 0x7d0a2
xorl %r13d, %r13d
movslq %eax, %rcx
cmpq %rcx, %r13
jge 0x7d09a
xorl %ebp, %ebp
movslq %eax, %rcx
cmpq %rcx, %rbp
jge 0x7d092
cmpq %rbp, %r13
je 0x7d08a
cmpq %r13, %r14
je 0x7d08a
cmpq %rbp, %r14
je 0x7d08a
movq (%r15), %rdi
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%rbp,8), %xmm0
leaq 0x242cf(%rip), %rsi     # 0xa1315
movl %r14d, %edx
movl %r13d, %ecx
movl %ebp, %r8d
movb $0x1, %al
callq 0x42e0
incl %r12d
movl %r12d, %eax
cltd
pushq $0x17
popq %rcx
idivl %ecx
testl %edx, %edx
jne 0x7d08a
movq (%r15), %rcx
leaq 0x242b5(%rip), %rdi     # 0xa1325
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x42c0
movq 0x4ef4e(%rip), %rax     # 0xcbfd0
movq (%rax), %rdi
callq 0x4350
incq %rbp
movl 0x10(%rbx), %eax
jmp 0x7d014
incq %r13
jmp 0x7d006
incq %r14
jmp 0x7cff7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/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 0x1e7bb(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x7d10c
movq %rax, %rbx
movq %rsp, %r14
leaq 0x1adf5(%rip), %r15     # 0x97ed0
movq %r14, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rbx, %rdx
callq 0x4120
testq %rax, %rax
je 0x7d0ff
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4030
jmp 0x7d0db
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a63c(%rip), %rdi     # 0x9774f
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O2/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 0x2410f(%rip), %xmm0    # 0xa1240
jbe 0x7d17d
movapd %xmm0, %xmm2
divsd 0x24109(%rip), %xmm2    # 0xa1248
movsd %xmm0, 0x8(%rsp)
movsd 0x24103(%rip), %xmm1    # 0xa1250
mulsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
cvttsd2si %xmm2, %ebx
leaq 0x241e0(%rip), %rdi     # 0xa1340
movl %ebx, %esi
xorl %eax, %eax
callq 0x4030
movsd 0x8(%rsp), %xmm0
imull $0x15180, %ebx, %eax    # imm = 0x15180
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
ucomisd 0x240d3(%rip), %xmm0    # 0xa1258
jbe 0x7d1cb
movsd 0x240c1(%rip), %xmm2    # 0xa1250
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
divsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
cvttsd2si %xmm1, %ebx
leaq 0x2419a(%rip), %rdi     # 0xa1348
movl %ebx, %esi
xorl %eax, %eax
callq 0x4030
movsd 0x8(%rsp), %xmm0
imull $0xe10, %ebx, %eax      # imm = 0xE10
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
ucomisd 0x2407d(%rip), %xmm0    # 0xa1250
jbe 0x7d20c
movapd %xmm0, %xmm1
divsd 0x2406f(%rip), %xmm1    # 0xa1250
cvttsd2si %xmm1, %ebx
leaq 0x24165(%rip), %rdi     # 0xa1351
movl %ebx, %esi
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
callq 0x4030
movsd 0x8(%rsp), %xmm0
imull $0x3c, %ebx, %eax
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
leaq 0x24146(%rip), %rdi     # 0xa1359
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
jmp 0x4030
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x7d2af
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq %r14, %rdx
callq 0x6ce0c
callq 0x4dd58
movq (%rbx), %rdi
movsd %xmm0, 0x48(%rdi)
movsd 0x182c8(%rip), %xmm1    # 0x95520
subsd %xmm0, %xmm1
movq 0x8(%rbx), %rax
movsd %xmm1, 0x48(%rax)
movsd 0x48(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rsi
callq 0x7d220
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
movsd 0x48(%rdi), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rsi
callq 0x7d220
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x7d2cc
cmpl $0x0, 0x6c(%rbx)
je 0x7d2c7
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq %r14, %rdx
callq 0x6ce0c
jmp 0x7d2cc
movsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x40(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorpd %xmm1, %xmm1
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x7d32f
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0x2b4a0
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7d220
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
subsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm1
movq 0x10(%rbx), %rbx
incl %ebp
jmp 0x7d2ed
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3929f
cmpl $0x0, 0x6c(%rbx)
je 0x7d743
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x3929f
movq 0x8(%rbx), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
popq %rbx
jmp 0x3929f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x383f4
movq %rax, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
cmpl $0x0, 0x6c(%r14)
je 0x7d7a6
movq (%rbx), %r15
movq (%r14), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x383f4
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 0x383f4
movq %rax, 0x30(%rbx)
movq %rdx, 0x38(%rbx)
jmp 0x7d7c8
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_O2/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 %rbx
subq $0x20, %rsp
movapd %xmm0, %xmm1
movq %rdi, %rbx
cmpl $-0x1, 0x68(%rdi)
movsd %xmm0, 0x18(%rsp)
je 0x7dbb1
movq (%rbx), %rdi
movapd %xmm1, %xmm0
callq 0x7db6d
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
movsd 0x18(%rsp), %xmm0
callq 0x7db6d
addsd 0x8(%rsp), %xmm0
jmp 0x7dc46
cmpl $0x0, 0x6c(%rbx)
je 0x7dbd0
movq 0x38(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
mulsd %xmm1, %xmm0
addsd (%rcx), %xmm0
jmp 0x7dbd5
movsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x1793d(%rip), %xmm2    # 0x95520
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x7dc3c
movsd %xmm2, 0x8(%rsp)
movq 0x38(%rax), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
mulsd %xmm1, %xmm0
addsd (%rcx), %xmm0
callq 0x4dd58
movq 0x18(%rbx), %rax
cmpq (%rax), %rbx
je 0x7dc27
movsd 0x17901(%rip), %xmm1    # 0x95520
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
movq %rax, %rbx
movsd 0x18(%rsp), %xmm1
jmp 0x7dbe3
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0x28(%r15)
cmpq %r12, %r15
je 0x7dc6f
andq $0x0, 0x20(%r15)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x7d7ce
testl %eax, %eax
je 0x7dc9b
movq (%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x7dc4c
movq 0x8(%r15), %r15
jmp 0x7dc60
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x7dd51
movq %rsi, %r15
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
movq %r15, %rdx
callq 0x6ce0c
callq 0x4dd58
movq (%rbx), %rdi
movsd %xmm0, 0x78(%rdi)
movsd 0x1783a(%rip), %xmm1    # 0x95520
subsd %xmm0, %xmm1
movq 0x8(%rbx), %rax
movsd %xmm1, 0x78(%rax)
movq %r15, %rsi
callq 0x7dcac
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x7dcac
leaq 0x4fb5f(%rip), %rcx     # 0xcd870
movq (%rcx), %rcx
movl 0x10(%rcx), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0x7dd70
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
movsd 0x78(%rsi), %xmm0
movsd 0x78(%rdi), %xmm1
mulsd (%rax,%rdx,8), %xmm1
mulsd (%r14,%rdx,8), %xmm0
addsd %xmm1, %xmm0
movq 0x70(%rbx), %rsi
movsd %xmm0, (%rsi,%rdx,8)
incq %rdx
jmp 0x7dd1e
movq 0x50(%rbx), %rsi
movq 0x70(%rbx), %rdi
leaq 0x4fb10(%rip), %rax     # 0xcd870
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_O2/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 0x7de09
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
movq %r14, %rdx
callq 0x6ce0c
callq 0x4dd58
movq (%rbx), %rdi
movsd %xmm0, 0x78(%rdi)
movsd 0x1776e(%rip), %xmm1    # 0x95520
subsd %xmm0, %xmm1
movq 0x8(%rbx), %rax
movsd %xmm1, 0x78(%rax)
movsd 0x78(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rsi
callq 0x7dd7a
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
movsd 0x78(%rdi), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rsi
callq 0x7dd7a
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x7de26
cmpl $0x0, 0x60(%rbx)
je 0x7de21
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
movq %r14, %rdx
callq 0x6ce0c
jmp 0x7de26
movsd 0x48(%rbx), %xmm0
movsd %xmm0, 0x68(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x4fa26(%rip), %r12     # 0xcd870
testq %rbx, %rbx
je 0x7de84
movq %rbx, %rdi
callq 0x2b47e
movl %eax, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7dcac
movq (%r12), %rcx
movl 0x10(%rcx), %esi
movq %rax, %rdi
callq 0x336dd
xorl %ecx, %ecx
cmpl %r15d, %eax
setne %cl
addl %ecx, %ebp
movq 0x10(%rbx), %rbx
jmp 0x7de4a
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x7def8
movq %rbx, %rdi
callq 0x2b47e
movl %eax, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7dd7a
callq 0x4dd58
ucomisd 0x17e5a(%rip), %xmm0    # 0x95d20
seta %al
testl %r15d, %r15d
sete %cl
testb %cl, %al
jne 0x7def0
movsd 0x17e45(%rip), %xmm1    # 0x95d20
ucomisd %xmm0, %xmm1
seta %al
cmpl $0x1, %r15d
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x7def2
incl %ebp
movq 0x10(%rbx), %rbx
jmp 0x7de9e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3929f
cmpl $0x0, 0x60(%rbx)
je 0x7e745
movq (%rbx), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x3929f
movq 0x8(%rbx), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
popq %rbx
jmp 0x3929f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x383f4
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
cmpl $0x0, 0x60(%r14)
je 0x7e809
movq (%rbx), %r15
movq (%r14), %rax
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
callq 0x383f4
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 0x383f4
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
jmp 0x7e82b
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_O2/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 0x4e9a3(%rip), %r13     # 0xcd870
leaq 0x1ba59(%rip), %r12     # 0x9a92d
xorpd %xmm1, %xmm1
cmpl $-0x1, 0x30(%r15)
je 0x7ef41
movq (%r13), %rax
movl 0x1c0(%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %r8d, %r8d
cmpq %rcx, %rax
je 0x7ef16
movq 0x40(%r15), %rdx
movq (%rdx,%rcx,8), %rdx
movsd (%rdx), %xmm0
cmpneqsd %xmm1, %xmm0
movq %xmm0, %rdx
subl %edx, %r8d
incq %rcx
jmp 0x7eef3
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 0x7eeb5
xorpd %xmm1, %xmm1
movq 0x8(%r15), %r15
jmp 0x7eed8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7ef69
andq $0x0, 0x20(%r15)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x7e831
testl %eax, %eax
je 0x7ef95
movq (%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x7ef4b
movq 0x8(%r15), %r15
jmp 0x7ef5f
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7efc2
andq $0x0, 0x20(%r15)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x7eb34
testl %eax, %eax
je 0x7efee
movq (%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x7efa4
movq 0x8(%r15), %r15
jmp 0x7efb8
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x16d14(%rip), %xmm0    # 0x95d20
ucomisd %xmm1, %xmm0
jbe 0x7f01b
movsd 0x16506(%rip), %xmm0    # 0x95520
retq
pushq %rax
movapd %xmm1, %xmm0
addsd %xmm1, %xmm0
movsd %xmm1, (%rsp)
callq 0x4160
movapd %xmm0, %xmm1
movsd 0x164e6(%rip), %xmm2    # 0x95520
addsd %xmm2, %xmm1
movsd (%rsp), %xmm0
addsd 0x2235d(%rip), %xmm0    # 0xa13a8
divsd %xmm0, %xmm1
movsd 0x22359(%rip), %xmm3    # 0xa13b0
mulsd %xmm1, %xmm3
movsd 0x22355(%rip), %xmm0    # 0xa13b8
divsd %xmm1, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x7f07b
sqrtsd %xmm0, %xmm0
jmp 0x7f08a
movsd %xmm3, (%rsp)
callq 0x4300
movsd (%rsp), %xmm3
addsd 0x1648e(%rip), %xmm0    # 0x95520
mulsd %xmm3, %xmm0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16479(%rip), %xmm0    # 0x95520
jbe 0x7f0b6
movsd 0x16c6f(%rip), %xmm4    # 0x95d20
jmp 0x7f178
movsd %xmm0, 0x8(%rsp)
movsd 0x18c7c(%rip), %xmm0    # 0x97d40
movapd %xmm0, 0x10(%rsp)
callq 0x7f000
ucomisd 0x8(%rsp), %xmm0
jbe 0x7f0e7
movapd 0x10(%rsp), %xmm0
mulsd 0x18c53(%rip), %xmm0    # 0x97d38
jmp 0x7f0c4
movsd 0x16c31(%rip), %xmm1    # 0x95d20
xorps %xmm3, %xmm3
movapd 0x10(%rsp), %xmm2
movsd %xmm3, 0x28(%rsp)
movapd %xmm2, 0x10(%rsp)
movapd %xmm2, %xmm0
movsd %xmm1, 0x20(%rsp)
addsd %xmm1, %xmm0
mulsd 0x16c06(%rip), %xmm0    # 0x95d20
movapd %xmm0, 0x30(%rsp)
callq 0x7f000
movapd 0x30(%rsp), %xmm4
movsd 0x8(%rsp), %xmm2
ucomisd %xmm2, %xmm0
movapd %xmm4, %xmm1
ja 0x7f141
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 0x1707a(%rip), %xmm3    # 0x961e0
ucomisd 0x16c72(%rip), %xmm3    # 0x95de0
orpd %xmm0, %xmm2
movapd %xmm4, %xmm3
ja 0x7f0f8
movapd %xmm4, %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x22232(%rip), %rsi     # 0xa13c0
pushq $0x10
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
andq $0x0, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x22220(%rip), %rsi     # 0xa13d8
pushq $0x30
popq %rdi
pushq $0x2
popq %rdx
callq 0x34f59
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_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rbx, %rbx
je 0x7f21a
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %r14
callq 0x7f1de
movq %rbx, %rdi
callq 0x34ff7
movq %r14, %rbx
jmp 0x7f1fb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x7f181
movq %rbx, %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x7f244
cmpl %ebp, (%rcx)
je 0x7f266
addq $0x20, %rcx
jmp 0x7f232
movl %ebp, %edi
movq %rax, %rsi
callq 0x7f1a9
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x7f261
movq %rcx, 0x20(%rax)
movq (%rbx), %rcx
movq %rax, 0x28(%rcx)
movq %rax, (%rbx)
jmp 0x7f275
movq 0x18(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rax, 0x18(%rcx)
incl 0x4(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %ebp, %ebp
testq %r14, %r14
je 0x7f65d
cmpl %ebx, (%r14)
jne 0x7f612
movq 0x20(%r14), %r14
jmp 0x7f602
leaq 0x18(%r14), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x7f60c
movsd (%r15), %xmm0
movsd %xmm0, 0x10(%rsp)
cvtsi2sdl (%r14), %xmm0
divsd 0x8(%rsp), %xmm0
callq 0x7f000
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
incl %ebp
addq $0x8, %r15
jmp 0x7f616
cvtsi2sd %ebp, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq