LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_array_support_vector
void save_array_support_vector(FILE* modelfile, Datasetptr d, Svm_nodeptr* array, int size)
{
 /*Last Changed 26.12.2005*/
 int i;
 for (i = 0; i < size; i++)
   save_support_vector(modelfile, d, array[i]);
}

// Assembly:
testl %ecx, %ecx
jle 0x850b5
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl %ecx, %r15d
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdx
movq %r14, %rdi
callq 0x84fd5
incq %r12
cmpq %r12, %r15
jne 0x85096
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_instance
void save_instance(FILE* modelfile, Datasetptr d, Instanceptr inst, int class_saved)
{
 /*!Last Changed 15.01.2009 added also class or regression information*/
 /*!Last Changed 22.12.2005*/
 int i;
 char pst[READLINELENGTH];
 set_precision(pst, NULL, " "); 
 for (i = 0; i < d->multifeaturecount; i++)
   if (i != d->classdefno)
     fprintf(modelfile, pst, inst->values[i].floatvalue);
   else
     if (d->classno == 0)
       fprintf(modelfile, pst, inst->values[i].floatvalue);
     else
       fprintf(modelfile, "%d ", inst->values[i].stringindex);
 fprintf(modelfile, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x205b6(%rip), %rdx     # 0xa568d
movq %rsp, %rdi
xorl %esi, %esi
callq 0x39529
cmpl $0x0, 0x1c0(%r15)
jle 0x85143
movq %rsp, %r12
leaq 0x27bb8(%rip), %r13     # 0xaccad
xorl %ebp, %ebp
movl 0x1407128(%r15), %eax
cmpq %rax, %rbp
jne 0x8511f
cmpl $0x0, 0x10(%r15)
movq (%r14), %rax
je 0x85122
movl (%rax,%rbp,8), %edx
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x42e0
jmp 0x85134
movq (%r14), %rax
movsd (%rax,%rbp,8), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
incq %rbp
movslq 0x1c0(%r15), %rax
cmpq %rax, %rbp
jl 0x850f7
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4150
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_instance_2d
void save_instance_2d(FILE* modelfile, Datasetptr d, Instanceptr inst, int class_saved)
{
 /*!Last Changed 15.01.2009 added also class or regression information*/
 /*!Last Changed 22.12.2005*/
 int i, dim = multifeaturecount_2d(d) + 1;
 char pst[READLINELENGTH];
 set_precision(pst, NULL, " "); 
 for (i = 0; i < dim; i++)
   if (i != d->classdefno)
     fprintf(modelfile, pst, inst->values[i].floatvalue);
   else
     if (d->classno == 0)
       fprintf(modelfile, pst, inst->values[i].floatvalue);
     else
       fprintf(modelfile, "%d ", inst->values[i].stringindex);
 fprintf(modelfile, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x13726
movl %eax, %r12d
leaq 0x204ff(%rip), %rdx     # 0xa568d
movq %rsp, %rdi
xorl %esi, %esi
callq 0x39529
testl %r12d, %r12d
js 0x851ee
incl %r12d
movq %rsp, %r13
xorl %ebp, %ebp
movl 0x1407128(%r15), %eax
cmpq %rax, %rbp
jne 0x851d1
cmpl $0x0, 0x10(%r15)
movq (%r14), %rax
je 0x851d4
movl (%rax,%rbp,8), %edx
movq %rbx, %rdi
leaq 0x27ae5(%rip), %rsi     # 0xaccad
xorl %eax, %eax
callq 0x42e0
jmp 0x851e6
movq (%r14), %rax
movsd (%rax,%rbp,8), %xmm0
movq %rbx, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x42e0
incq %rbp
cmpq %rbp, %r12
jne 0x851a5
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4150
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_instance_discrete
void save_instance_discrete(FILE* modelfile, Datasetptr d, Instanceptr inst)
{
 /*Last Changed 22.12.2005*/
 int i;
 char pst[READLINELENGTH];
 set_precision(pst, NULL, " "); 
 for (i = 0; i < d->featurecount; i++)
   switch (d->features[i].type)
    {
     case REAL    :
     case INTEGER :
					case REGDEF  :fprintf(modelfile, pst, inst->values[i].floatvalue);
                   break;
     case STRING  :
     case CLASSDEF:fprintf(modelfile, "%d ", inst->values[i].stringindex);
                   break;
     default      :printf(m1238, d->features[i].type);
                   break;
    }
 fprintf(modelfile, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2045f(%rip), %rdx     # 0xa568d
movq %rsp, %rdi
xorl %esi, %esi
callq 0x39529
cmpl $0x0, 0x1bc(%r15)
jle 0x852b5
leaq 0x30f08(%r15), %r12
movl $0x15, %ebp
xorl %r13d, %r13d
movl (%r12), %esi
cmpl $0x4, %esi
ja 0x85291
btl %esi, %ebp
jae 0x85277
movq (%r14), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
movq %rsp, %rsi
movb $0x1, %al
callq 0x42e0
jmp 0x8529f
movq (%r14), %rax
movl (%rax,%r13,8), %edx
movq %rbx, %rdi
leaq 0x27a25(%rip), %rsi     # 0xaccad
xorl %eax, %eax
callq 0x42e0
jmp 0x8529f
leaq 0x1e0d6(%rip), %rdi     # 0xa336e
xorl %eax, %eax
callq 0x4030
incq %r13
movslq 0x1bc(%r15), %rax
addq $0x340, %r12            # imm = 0x340
cmpq %rax, %r13
jl 0x85251
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4150
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_output_mean_and_variance
void save_output_mean_and_variance(FILE* modelfile, double mean, double variance)
{
 /*Last Changed 27.12.2005*/
 char pst[READLINELENGTH];
 set_precision(pst, NULL, " ");
	fprintf(modelfile, pst, mean);
 set_precision(pst, NULL, "\n");
	fprintf(modelfile, pst, variance);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x2039a(%rip), %rdx     # 0xa568d
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x39529
movq %rbx, %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x42e0
leaq 0x20e50(%rip), %rdx     # 0xa616b
movq %r14, %rdi
xorl %esi, %esi
callq 0x39529
movq %rbx, %rdi
movq %r14, %rsi
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x42e0
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_mean_and_variance
void save_mean_and_variance(FILE* modelfile, Datasetptr d, Instance mean, Instance variance, int mustrealize)
{
 /*Last Changed 22.12.2005*/
	if (mustrealize)
	 {
   save_instance(modelfile, d, &mean, BOOLEAN_FALSE);
   save_instance(modelfile, d, &variance, BOOLEAN_FALSE);
	 }
	else
	 {
   save_instance_discrete(modelfile, d, &mean);
   save_instance_discrete(modelfile, d, &variance);
	 }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %eax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x50(%rsp), %r14
leaq 0x20(%rsp), %rdx
testl %eax, %eax
je 0x85373
callq 0x850b6
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x850b6
jmp 0x85386
callq 0x8520d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x8520d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_model_gaussian
void save_model_gaussian(FILE* modelfile, Datasetptr d, Model_gaussianptr m)
{
 /*Last Changed 22.12.2005*/
 int i;
 Instanceptr m_i;
 m_i = m->mean;
 for (i = 0; i < d->classno; i++)
  {
   save_instance(modelfile, d, m_i, BOOLEAN_FALSE);
   m_i = m_i->next;
  }
 save_array(modelfile, m->variance, d->classno);
 save_array(modelfile, m->priors, d->classno);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rsi), %edx
testl %edx, %edx
jle 0x853fc
xorl %ebp, %ebp
movq %r15, %r12
movq (%r12), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x850b6
addq $0x10, %r12
incl %ebp
movl 0x10(%r14), %edx
cmpl %edx, %ebp
jl 0x853dc
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x84e7d
movq 0x10(%r15), %rsi
movl 0x10(%r14), %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x84e7d
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_model_knn
void save_model_knn(FILE* modelfile, Datasetptr d, Instanceptr m)
{
 /*Last Changed 22.12.2005*/
 Instanceptr tmp;
 fprintf(modelfile, "%d\n", data_size(m));
 tmp = m;
 while (tmp)
  {
   save_instance_discrete(modelfile, d, tmp);
   tmp = tmp->next;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x2fa14
leaq 0x2810c(%rip), %rsi     # 0xad549
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x42e0
testq %rbx, %rbx
je 0x85462
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8520d
movq 0x10(%rbx), %rbx
jmp 0x85449
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_model_softtree
void save_model_softtree(FILE* modelfile, Datasetptr d, Decisionnodeptr m, int level)
{
 /*Last Changed 28.09.2011*/
 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->w0);   
   else
     save_matrix(modelfile, m->w);   
  }
 else
  {
   save_matrix(modelfile, m->w);
   save_model_softtree(modelfile, d, m->left, level + 1);
   save_model_softtree(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 0x854ac
leaq 0x288e5(%rip), %r12     # 0xadd74
movl %ebp, %r13d
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x42c0
decl %r13d
jne 0x85492
leaq 0x20cb8(%rip), %rdx     # 0xa616b
movq %rsp, %rdi
xorl %esi, %esi
callq 0x39529
movl 0x30(%r14), %edx
leaq 0x277e5(%rip), %rsi     # 0xaccad
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
cmpl $-0x1, 0x30(%r14)
je 0x8550e
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %rbx, %rdi
callq 0x84de0
movq (%r14), %rdx
incl %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x85468
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x85468
jmp 0x85558
movq 0x20(%r14), %rdi
callq 0x2fa14
movl 0x60(%r14), %edx
leaq 0x2778b(%rip), %rsi     # 0xaccad
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x60(%r14)
je 0x85545
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %rbx, %rdi
callq 0x84de0
jmp 0x85558
movsd 0x48(%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
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_model_rbf
void save_model_rbf(FILE* modelfile, Datasetptr d, Rbfnetworkptr m)
{
	/*Last Changed 19.08.2007*/
	fprintf(modelfile, "%d %d\n", m->hidden, m->output);
	save_matrix(modelfile, m->weights.m);
	save_matrix(modelfile, m->weights.s);
	save_matrix(modelfile, m->weights.w);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdx), %edx
movl 0x4(%r14), %ecx
leaq 0x1d665(%rip), %rsi     # 0xa2e2c
xorl %eax, %eax
callq 0x42e0
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
callq 0x84de0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x84de0
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x84de0
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_model_mlpgeneric
void save_model_mlpgeneric(FILE* modelfile, Datasetptr d, Mlpnetworkptr m)
{
 /*Last Changed 25.12.2005*/
	int i;
	fprintf(modelfile, "%d %d %d\n", m->P.dimnum, m->P.classnum, m->P.layernum);
 save_array_int(modelfile, m->P.hidden, m->P.layernum);
	for (i = 0; i <= m->P.layernum; i++)
			save_matrix(modelfile, m->weights[i]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl 0x8(%rdx), %ecx
movl 0xc(%rdx), %edx
movl 0x5c(%rbx), %r8d
leaq 0x1d5fc(%rip), %rsi     # 0xa2e20
xorl %eax, %eax
callq 0x42e0
leaq 0x50(%rbx), %rsi
movl 0x5c(%rbx), %edx
movq %r14, %rdi
callq 0x84eee
cmpl $0x0, 0x5c(%rbx)
js 0x85871
movq $-0x1, %r15
movl $0x8, %r12d
movq (%rbx), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r14, %rdi
callq 0x84de0
movslq 0x5c(%rbx), %rax
incq %r15
addq $0x10, %r12
cmpq %rax, %r15
jl 0x8584d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_model_multildt
void save_model_multildt(FILE* modelfile, Datasetptr d, Decisionnodeptr m, int level)
{
 /*Last Changed 25.12.2005*/
 char pst[READLINELENGTH];
 int i;
	for (i = 0; i < level; i++)
		 fprintf(modelfile, "  ");
 set_precision(pst, NULL, " "); 
 fprintf(modelfile, "%d ", m->featureno);
 if (m->featureno == LEAF_NODE)
  {
   fprintf(modelfile, "%d ", m->classno);
   save_array_int(modelfile, m->counts, d->classno);
  }
 else
	 {
  	fprintf(modelfile, pst, m->w0);
   save_matrix(modelfile, m->w);
   save_model_multildt(modelfile, d, m->left, level + 1);
   save_model_multildt(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, %r15
movq %rsi, %r14
movq %rdi, %rbx
testl %ecx, %ecx
jle 0x858c1
leaq 0x284d0(%rip), %r12     # 0xadd74
movl %ebp, %r13d
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x42c0
decl %r13d
jne 0x858a7
leaq 0x1fdc5(%rip), %rdx     # 0xa568d
movq %rsp, %rdi
xorl %esi, %esi
callq 0x39529
movl 0x30(%r15), %edx
leaq 0x273d0(%rip), %rsi     # 0xaccad
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
cmpl $-0x1, 0x30(%r15)
je 0x85936
movsd 0x48(%r15), %xmm0
movq %rsp, %rsi
movq %rbx, %rdi
movb $0x1, %al
callq 0x42e0
movq 0x38(%r15), %rsi
movq 0x40(%r15), %rdx
movq %rbx, %rdi
callq 0x84de0
movq (%r15), %rdx
incl %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x8587d
movq 0x8(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x8587d
jmp 0x8595e
movl 0x34(%r15), %edx
leaq 0x2736c(%rip), %rsi     # 0xaccad
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
movq 0xa0(%r15), %rsi
movl 0x10(%r14), %edx
movq %rbx, %rdi
callq 0x84eee
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_model_nodeboundedtree
void save_model_nodeboundedtree(FILE* modelfile, Datasetptr d, Decisionnodeptr m, int level)
{
 /*Last Changed 19.03.2006*/
 char pst[READLINELENGTH];
 int i;
	for (i = 0; i < level; i++)
		 fprintf(modelfile, "  ");
 set_precision(pst, NULL, " "); 
 fprintf(modelfile, "%d ", m->featureno);
	switch (m->featureno)
	 {
	  case LEAF_NODE:fprintf(modelfile, "%d ", m->classno);
                  save_array_int(modelfile, m->counts, d->classno);
                  break;
			case LINEAR   :
			case QUADRATIC:fprintf(modelfile, pst, m->w0);
                  save_matrix(modelfile, m->w);
                  break;
			default       :fprintf(modelfile, pst, m->split);
				              break;
	 }
	if (m->featureno != LEAF_NODE)
	 {
   save_model_nodeboundedtree(modelfile, d, m->left, level + 1);
   save_model_nodeboundedtree(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, %ebx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
testl %ecx, %ecx
jle 0x859b2
leaq 0x283dd(%rip), %r13     # 0xadd74
movl %ebx, %ebp
movl $0x2, %esi
movl $0x1, %edx
movq %r13, %rdi
movq %r15, %rcx
callq 0x42c0
decl %ebp
jne 0x85999
leaq 0x1fcd4(%rip), %rdx     # 0xa568d
movq %rsp, %rdi
xorl %esi, %esi
callq 0x39529
movl 0x30(%r12), %edx
leaq 0x272de(%rip), %rsi     # 0xaccad
movq %r15, %rdi
xorl %eax, %eax
callq 0x42e0
movl 0x30(%r12), %eax
leal 0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0x85a0e
movsd 0x48(%r12), %xmm0
movq %rsp, %rsi
movq %r15, %rdi
movb $0x1, %al
callq 0x42e0
movq 0x38(%r12), %rsi
movq 0x40(%r12), %rdx
movq %r15, %rdi
callq 0x84de0
jmp 0x85a53
cmpl $-0x1, %eax
jne 0x85a3f
movl 0x34(%r12), %edx
leaq 0x2728e(%rip), %rsi     # 0xaccad
movq %r15, %rdi
xorl %eax, %eax
callq 0x42e0
movq 0xa0(%r12), %rsi
movl 0x10(%r14), %edx
movq %r15, %rdi
callq 0x84eee
jmp 0x85a53
movsd 0x28(%r12), %xmm0
movq %rsp, %rsi
movq %r15, %rdi
movb $0x1, %al
callq 0x42e0
cmpl $-0x1, 0x30(%r12)
je 0x85a80
movq (%r12), %rdx
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %ecx
callq 0x85970
movq 0x8(%r12), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %ecx
callq 0x85970
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_model_nearestmean
void save_model_nearestmean(FILE* modelfile, Datasetptr d, Instanceptr m)
{
 /*Last Changed 25.12.2005*/
 int i;
 Instanceptr m_i;
 m_i = m;
 for (i = 0; i < d->classno; i++)
  {
   save_instance_discrete(modelfile, d, m_i);
   m_i = m_i->next;
  }
}

// Assembly:
cmpl $0x0, 0x10(%rsi)
jle 0x85ace
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8520d
movq 0x10(%rbx), %rbx
incl %ebp
cmpl 0x10(%r14), %ebp
jl 0x85aaa
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_model_naivebayes
void save_model_naivebayes(FILE* modelfile, Datasetptr d, Model_naivebayesptr m)
{
 /*Last Changed 11.08.2007*/
 int i, j;
 save_array_two(modelfile, m->m, d->classno, d->featurecount);
	save_array(modelfile, m->priors, d->classno);
	save_array(modelfile, m->s, d->featurecount);
 for (i = 0; i < d->classno; i++)
		 for (j = 0; j < d->featurecount; j++)
				 if (d->features[j].type == STRING)
						 save_array(modelfile, m->p[i][j], d->features[j].valuecount);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rsi
movl 0x10(%r14), %edx
movl 0x1bc(%r14), %ecx
callq 0x84f3d
movq 0x10(%rbx), %rsi
movl 0x10(%r14), %edx
movq %r15, %rdi
callq 0x84e7d
movq 0x8(%rbx), %rsi
movl 0x1bc(%r14), %edx
movq %r15, %rdi
callq 0x84e7d
cmpl $0x0, 0x10(%r14)
jle 0x85b7e
leaq 0x30f20(%r14), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
cmpl $0x0, 0x1bc(%r14)
jle 0x85b72
movq (%rsp), %rbp
xorl %r12d, %r12d
cmpl $0x1, -0x18(%rbp)
jne 0x85b5c
movq 0x18(%rbx), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%r12,8), %rsi
movl (%rbp), %edx
movq %r15, %rdi
callq 0x84e7d
incq %r12
movslq 0x1bc(%r14), %rax
addq $0x340, %rbp            # imm = 0x340
cmpq %rax, %r12
jl 0x85b3f
incq %r13
movslq 0x10(%r14), %rax
cmpq %rax, %r13
jl 0x85b2e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_model_qdaclass
void save_model_qdaclass(FILE* modelfile, Datasetptr d, Model_qdaclassptr m)
{
 /*Last Changed 05.08.2007*/
 int i;
 save_array(modelfile, m->w0, d->classno);
 save_array(modelfile, m->priors, d->classno);
 for (i = 0; i < d->classno; i++)
   save_matrix(modelfile, m->W[i]);
 for (i = 0; i < d->classno; i++)
   save_matrix(modelfile, m->w[i]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdx), %rsi
movl 0x10(%r14), %edx
callq 0x84e7d
movq 0x18(%rbx), %rsi
movl 0x10(%r14), %edx
movq %r15, %rdi
callq 0x84e7d
cmpl $0x0, 0x10(%r14)
jle 0x85bf0
movl $0x8, %r12d
xorl %r13d, %r13d
movq (%rbx), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r15, %rdi
callq 0x84de0
incq %r13
movslq 0x10(%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x85bcc
cmpl $0x0, 0x10(%r14)
jle 0x85c25
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r15, %rdi
callq 0x84de0
incq %r13
movslq 0x10(%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x85c00
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_model_ldaclass
void save_model_ldaclass(FILE* modelfile, Datasetptr d, Model_ldaclassptr m)
{
 /*Last Changed 26.12.2005*/
 int i;
 fprintf(modelfile, "%d %d\n", m->newfeaturecount, m->oldfeaturecount);
 save_array(modelfile, m->w0, d->classno);
 for (i = 0; i < d->classno; i++)
   save_matrix(modelfile, m->w[i]);
 save_matrix(modelfile, m->eigenvectors);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdx), %edx
movl 0x4(%rbx), %ecx
leaq 0x1d1df(%rip), %rsi     # 0xa2e2c
xorl %eax, %eax
callq 0x42e0
movq 0x8(%rbx), %rsi
movl 0x10(%r15), %edx
movq %r14, %rdi
callq 0x84e7d
cmpl $0x0, 0x10(%r15)
jle 0x85c99
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r14, %rdi
callq 0x84de0
incq %r13
movslq 0x10(%r15), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x85c74
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x84de0
// File: /workspace/github_c_makefile_star2_O1/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 0x2049e(%rip), %rdx     # 0xa616b
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x39529
movl 0x58(%r14), %edx
movl 0x5c(%r14), %ecx
leaq 0x1d143(%rip), %rsi     # 0xa2e2c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
movl (%r14), %edx
movl 0x4(%r14), %ecx
movl 0x8(%r14), %r8d
leaq 0x1d11b(%rip), %rsi     # 0xa2e20
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 0x39a80
testl %eax, %eax
jne 0x85d7b
movq 0x78(%r14), %rsi
movl 0x58(%r14), %edx
movq %rbx, %rdi
callq 0x84eee
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 0x84e7d
movl (%r14), %edi
movl $0x3, %esi
movl $0x2, %edx
movl $0x3, %ecx
movl $0x4, %r8d
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
jne 0x85e01
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 0x84e7d
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 0x84e7d
movq 0x68(%r14), %rsi
movl 0x58(%r14), %edx
movl 0x5c(%r14), %ecx
decl %edx
movq %rbx, %rdi
callq 0x84f3d
movslq 0x5c(%r14), %r15
testq %r15, %r15
jle 0x85e3b
movq 0x60(%r14), %r14
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdx
movq %rbx, %rdi
callq 0x84fd5
incq %r12
cmpq %r12, %r15
jne 0x85e27
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x26e38(%rip), %rsi     # 0xacca2
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, (%r14)
js 0x85ec7
movb 0x4(%r14), %bpl
leaq 0x1f80b(%rip), %rdx     # 0xa568d
movq %rsp, %rdi
xorl %esi, %esi
callq 0x39529
cmpb $0x2a, %bpl
jne 0x85f00
movsd 0x18(%r14), %xmm0
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
leaq 0x1f7de(%rip), %rdx     # 0xa568d
movq %r15, %rdi
xorl %esi, %esi
callq 0x39529
movsd 0x10(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x85f0c
leaq 0x2029d(%rip), %rdx     # 0xa616b
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x39529
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 0x84de0
jmp 0x85f13
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_O1/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 0x1ceda(%rip), %rsi     # 0xa2e1d
xorl %eax, %eax
callq 0x42e0
movq 0x10(%r15), %rsi
movl 0x10(%r14), %edx
movq %rbx, %rdi
callq 0x84eee
movq 0x18(%r15), %r14
testq %r14, %r14
je 0x85f74
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85e4a
movq 0x48(%r14), %r14
jmp 0x85f5e
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4150
// File: /workspace/github_c_makefile_star2_O1/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 0x1ce8b(%rip), %rsi     # 0xa2e2c
xorl %eax, %eax
callq 0x42e0
movq 0x18(%r15), %rsi
movl 0x10(%rbx), %edx
movq %r14, %rdi
callq 0x84eee
movq (%r15), %r15
testq %r15, %r15
je 0x85fd3
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x85f21
movq 0x30(%r15), %r15
jmp 0x85fba
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x27552(%rip), %rsi     # 0xad549
xorl %eax, %eax
callq 0x42e0
movq 0x30(%rbx), %rsi
movl 0x10(%r14), %edx
movq %r15, %rdi
callq 0x84eee
movq (%rbx), %r12
testq %r12, %r12
je 0x8602b
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x85f21
movq 0x30(%r12), %r12
jmp 0x86011
cmpl $0x0, 0x1bc(%r14)
jle 0x8607a
leaq 0x30f08(%r14), %r12
movl $0x8, %r13d
xorl %ebp, %ebp
cmpl $0x1, (%r12)
jne 0x86060
movq 0x28(%rbx), %rax
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r15, %rdi
callq 0x84de0
incq %rbp
movslq 0x1bc(%r14), %rax
addq $0x10, %r13
addq $0x340, %r12            # imm = 0x340
cmpq %rax, %rbp
jl 0x86044
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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, %r14
movl 0x20(%rdx), %edx
movl 0x24(%rbx), %ecx
movl 0x28(%rbx), %r8d
leaq 0x1cd72(%rip), %rsi     # 0xa2e20
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x20(%rbx)
jle 0x861b2
movq %rbx, %rcx
xorl %r13d, %r13d
movq %r14, 0x10(%rsp)
movq %rbx, 0x8(%rsp)
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
movl (%rax,%r13,4), %edx
movl (%rcx,%r13,4), %ecx
movq %r14, %rdi
leaq 0x1cd43(%rip), %rsi     # 0xa2e2c
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 %r14, %rdi
callq 0x84eee
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
cmpl $0x0, (%rax,%r13,4)
jle 0x8619d
xorl %ebp, %ebp
movq 0x18(%rcx), %rax
movq (%rax,%r13,8), %rax
cmpl $0x0, (%rax,%rbp,4)
leaq 0x27c40(%rip), %rbx     # 0xadd77
movq 0x10(%rsp), %r14
jle 0x8618d
movl $0x8, %r15d
xorl %r12d, %r12d
movq (%rcx), %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 %r14, %rdi
movq %rbx, %rsi
movb $0x1, %al
callq 0x42e0
movq 0x8(%rsp), %rcx
incq %r12
movq 0x18(%rcx), %rax
movq (%rax,%r13,8), %rax
movslq (%rax,%rbp,4), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x86147
incq %rbp
movq 0x8(%rcx), %rax
movslq (%rax,%r13,4), %rax
cmpq %rax, %rbp
jl 0x86124
incq %r13
movslq 0x20(%rcx), %rax
cmpq %rax, %r13
movq 0x10(%rsp), %r14
jl 0x860cf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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 0x1f4b3(%rip), %rdx     # 0xa568d
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x39529
movl (%r14), %edx
leaq 0x26abc(%rip), %rsi     # 0xaccad
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_O1/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 0x1f395(%rip), %rdx     # 0xa568d
movq %rsp, %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x39529
movl 0x40(%r14), %edx
leaq 0x2699d(%rip), %rsi     # 0xaccad
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 0x8635d
movq 0x20(%r14), %rsi
movl 0x40(%r14), %edx
movq %rbx, %rdi
callq 0x84e7d
jmp 0x863a8
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 0x84f3d
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x84de0
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x863fc
leaq 0x27995(%rip), %r12     # 0xadd74
movl %ebp, %r13d
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x42c0
decl %r13d
jne 0x863e2
leaq 0x1fd68(%rip), %rdx     # 0xa616b
movq %rsp, %rdi
xorl %esi, %esi
callq 0x39529
movl 0x68(%r14), %edx
leaq 0x26895(%rip), %rsi     # 0xaccad
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
movl 0x68(%r14), %eax
cmpl $-0x1, %eax
je 0x8646a
testl %eax, %eax
js 0x864a1
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 0x863b8
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x863b8
jmp 0x864f0
movq 0x20(%r14), %rdi
callq 0x2fa14
movl 0x6c(%r14), %edx
leaq 0x2682f(%rip), %rsi     # 0xaccad
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x6c(%r14)
je 0x864dd
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x84de0
jmp 0x864f0
cmpl $-0x6, %eax
je 0x8652b
cmpl $-0x3, %eax
je 0x86502
cmpl $-0x2, %eax
jne 0x86442
movq 0x80(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x850b6
movq 0x88(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x850b6
jmp 0x86442
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 0x85162
movq 0x88(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x85162
jmp 0x86442
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x84de0
jmp 0x86442
// File: /workspace/github_c_makefile_star2_O1/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 0x26d45(%rip), %rsi     # 0xad549
xorl %eax, %eax
callq 0x42e0
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x86829
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x850b6
movq 0x10(%r12), %r12
jmp 0x8680f
movq 0x10(%rbx), %rsi
movl (%rbx), %edx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x84e7d
// File: /workspace/github_c_makefile_star2_O1/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 0x327677(%rip), %r14    # 0x3af0a8
movq (%r14), %rdi
movq (%rbx), %rdx
leaq 0x2682a(%rip), %rsi     # 0xae268
xorl %eax, %eax
callq 0x42e0
movq (%r14), %rdi
movl 0x10(%rbx), %edx
leaq 0x26825(%rip), %rsi     # 0xae277
xorl %eax, %eax
callq 0x42e0
movq (%r14), %rdi
movl 0x20(%rbx), %edx
leaq 0x26820(%rip), %rsi     # 0xae286
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x10(%rbx)
jle 0x87b88
leaq 0x26335(%rip), %r13     # 0xaddb3
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 0x267f2(%rip), %rsi     # 0xae294
movq %rdx, (%rsp)
xorl %eax, %eax
callq 0x42e0
movq (%r14), %rcx
movl $0x8, %esi
movl $0x1, %edx
leaq 0x267e0(%rip), %rdi     # 0xae2a1
callq 0x42c0
movq 0x8(%rbx), %rax
movl 0x30(%rax,%r15), %eax
cmpl $-0x1, %eax
je 0x87b02
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 0x87acf
movq (%r14), %rsi
movl $0xa, %edi
callq 0x4150
movq (%r14), %rcx
movl $0x7, %esi
movl $0x1, %edx
leaq 0x26787(%rip), %rdi     # 0xae2aa
callq 0x42c0
movq 0x8(%rbx), %rax
leaq (,%rbp,8), %rcx
addq %rbp, %rcx
cmpl $0x0, 0x10(%rax,%rcx,8)
jle 0x87b67
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 0x87b40
movq (%r14), %rsi
movl $0xa, %edi
callq 0x4150
movslq 0x10(%rbx), %rax
movq (%rsp), %rcx
movq %rcx, %rbp
cmpq %rax, %rcx
jl 0x87a80
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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:
cmpl $0x0, 0x10(%rdi)
jle 0x87e67
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x32729c(%rip), %r12    # 0x3af0a8
leaq 0x26504(%rip), %r14     # 0xae317
cmpl $0x0, 0x10(%rbx)
jle 0x87e44
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 0x87e1c
movq (%r12), %rsi
movl $0xa, %edi
callq 0x4150
incq %r15
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jl 0x87e13
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, 0x10(%rdi)
jle 0x87f5e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x32721e(%rip), %r12    # 0x3af0a8
xorl %r15d, %r15d
cmpl $0x0, 0x10(%rbx)
jle 0x87f40
xorl %r13d, %r13d
cmpl $0x0, 0x10(%rbx)
jle 0x87f30
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x87f20
cmpq %r13, %r14
je 0x87f20
cmpq %rbp, %r14
je 0x87f20
movq (%r12), %rdi
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%rbp,8), %xmm0
leaq 0x2644c(%rip), %rsi     # 0xae31d
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 0x87f20
movq (%r12), %rcx
movl $0x1a, %esi
movl $0x1, %edx
leaq 0x26421(%rip), %rdi     # 0xae32d
callq 0x42c0
movq 0x490b8(%rip), %rax     # 0xd0fd0
movq (%rax), %rdi
callq 0x4350
incq %rbp
movslq 0x10(%rbx), %rax
cmpq %rax, %rbp
jl 0x87ea6
incq %r13
movslq 0x10(%rbx), %rax
cmpq %rax, %r13
jl 0x87e9a
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0x87e8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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 0x2091d(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x87fcd
movq %rax, %rbx
movq %rsp, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
testq %rax, %rax
je 0x87fc0
leaq 0x1cf5d(%rip), %r14     # 0xa4ef8
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 0x87f9e
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1c799(%rip), %rdi     # 0xa476d
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O1/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 0x26256(%rip), %xmm0    # 0xae248
jbe 0x88041
movapd %xmm0, %xmm2
divsd 0x26250(%rip), %xmm2    # 0xae250
movsd %xmm0, 0x8(%rsp)
movsd 0x2624a(%rip), %xmm1    # 0xae258
mulsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
cvttsd2si %xmm2, %ebx
leaq 0x26327(%rip), %rdi     # 0xae348
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 0x26217(%rip), %xmm0    # 0xae260
jbe 0x88092
movsd 0x26205(%rip), %xmm2    # 0xae258
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
divsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
cvttsd2si %xmm1, %ebx
leaq 0x262de(%rip), %rdi     # 0xae350
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 0x261be(%rip), %xmm0    # 0xae258
jbe 0x880d6
movapd %xmm0, %xmm1
divsd 0x261b0(%rip), %xmm1    # 0xae258
cvttsd2si %xmm1, %ebx
leaq 0x262a6(%rip), %rdi     # 0xae359
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 0x26284(%rip), %rdi     # 0xae361
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
jmp 0x4030
nopl (%rax)