LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: code_kernel_function
void code_kernel_function(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, Svm_parameter param)
{
 /*!Last Changed 25.06.2006*/
	char st[MAXLENGTH];
 code_set_variable(testcodefile, language, "sum", "0.0");
	code_for(testcodefile, language, "j", 0, d->multifeaturecount - 2, 1);
 code_array_index_variable(st, language, "testdataconverted", "j");  				             
	code_set_variable(testcodefile, language, "x_j", st);
 code_2d_array_index_variable(st, language, "sv", "i", "j");  
	code_set_variable(testcodefile, language, "sv_ij", st);
	switch (param.kernel_type){
	  case KLINEAR :
			case KPOLY   :
			case KSIGMOID:code_set_variable(testcodefile, language, "sum", "sum + x_j * sv_ij");
				             break;
			case KRBF    :code_set_variable(testcodefile, language, "sum", "sum + (x_j - sv_ij) * (x_j - sv_ij)");
				             break;
   case KPREDEFINED:break;
	};	
	code_endfor(testcodefile, language, "j");
	switch (param.kernel_type){
			case KPOLY   :code_set_variable(testcodefile, language, "sum", "pow(gamma * sum + coef0, degree)");
				             break;
			case KSIGMOID:code_set_variable(testcodefile, language, "sum", "tanh(gamma * sum + coef0)");
				             break;
			case KRBF    :code_set_variable(testcodefile, language, "sum", "exp(-gamma * sum)");
				             break;
   default      :break;
	};	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7a120, %rsp          # imm = 0x7A120
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x2b214(%rip), %rdx     # 0xa0c11
leaq 0x2b175(%rip), %rcx     # 0xa0b79
callq 0x72b25
movl 0x1c0(%r15), %r8d
addl $-0x2, %r8d
leaq 0x2aefd(%rip), %r15     # 0xa0918
pushq $0x1
popq %r9
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x73938
leaq 0x2adb3(%rip), %rdx     # 0xa07e8
movq %rsp, %r12
movq %r12, %rdi
movl %ebx, %esi
movq %r15, %rcx
callq 0x7327f
leaq 0x2aee0(%rip), %rdx     # 0xa092c
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rcx
callq 0x72b25
leaq 0x2b245(%rip), %rdx     # 0xa0ca5
leaq 0x2b1b6(%rip), %rcx     # 0xa0c1d
movq %r12, %rdi
movl %ebx, %esi
movq %r15, %r8
callq 0x7329c
leaq 0x2af15(%rip), %rdx     # 0xa0990
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rcx
callq 0x72b25
movl 0x7a154(%rsp), %ebp
cmpl $0x2, %ebp
jb 0x75a9b
je 0x75ad6
cmpl $0x3, %ebp
jne 0x75ab3
leaq 0x2b16f(%rip), %rdx     # 0xa0c11
leaq 0x2aedb(%rip), %rcx     # 0xa0984
movq %r14, %rdi
movl %ebx, %esi
callq 0x72b25
movq %r14, %rdi
movl %ebx, %esi
callq 0x73b72
decl %ebp
cmpl $0x2, %ebp
ja 0x75b10
movl %ebp, %eax
leaq 0x2a59b(%rip), %rdx     # 0xa0068
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
jmp 0x75aff
leaq 0x2b134(%rip), %rdx     # 0xa0c11
leaq 0x2aeb2(%rip), %rcx     # 0xa0996
movq %r14, %rdi
movl %ebx, %esi
callq 0x72b25
movq %r14, %rdi
movl %ebx, %esi
callq 0x73b72
leaq 0x2aef6(%rip), %rcx     # 0xa09f5
leaq 0x2b10b(%rip), %rdx     # 0xa0c11
movq %r14, %rdi
movl %ebx, %esi
callq 0x72b25
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/savecode.c
// Function: generate_test_code_selectmax
void generate_test_code_selectmax(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, Model_selectmaxptr m)
{
 /*!Last Changed 17.05.2006*/
 code_function_header(testcodefile, "selectmax", d->featurecount, language);
 code_start(testcodefile, language);
 code_function_return_classification(testcodefile, "selectmax", language, m->classno);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl 0x1bc(%rdx), %edx
leaq 0x240ba(%rip), %r15     # 0x99bf6
movq %r15, %rsi
movl %ebp, %ecx
callq 0x72674
movq %r14, %rdi
movl %ebp, %esi
callq 0x726d3
movl (%rbx), %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x72fce
movq %r14, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7320f
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: generate_test_code_onefeature
void generate_test_code_onefeature(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, Model_onefeatureptr m)
{
 /*!Last Changed 02.06.2006*/
 char st[MAXLENGTH], st2[MAXLENGTH];
 code_function_header(testcodefile, "onefeature", d->featurecount, language);
 code_start(testcodefile, language);
 code_array_index(st, language, "testdata", m->bestfeature);
 sprintf(st2, "%.6f", m->bestsplit);
 code_if(testcodefile, language, "<=", st, st2);
 code_function_return_regression(testcodefile, "onefeature", language, m->leftmean);
 code_else(testcodefile, language);
 code_function_return_regression(testcodefile, "onefeature", language, m->rightmean);
 code_endif(testcodefile, language);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf4248, %rsp          # imm = 0xF4248
movq %rcx, %r15
movl %esi, %ebx
movq %rdi, %r14
movl 0x1bc(%rdx), %edx
leaq 0x241ba(%rip), %r12     # 0x99d53
movq %r12, %rsi
movl %ebx, %ecx
callq 0x72674
movq %r14, %rdi
movl %ebx, %esi
callq 0x726d3
movl (%r15), %ecx
leaq 0x2acab(%rip), %rdx     # 0xa0862
leaq 0x7a120(%rsp), %r13
movq %r13, %rdi
movl %ebx, %esi
callq 0x73250
movsd 0x8(%r15), %xmm0
leaq 0x2a5d8(%rip), %rsi     # 0xa01ae
movq %rsp, %rbp
movq %rbp, %rdi
movb $0x1, %al
callq 0x41b0
leaq 0x232a8(%rip), %rdx     # 0x98e92
movq %r14, %rdi
movl %ebx, %esi
movq %r13, %rcx
movq %rbp, %r8
callq 0x736fc
movsd 0x10(%r15), %xmm0
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x7314b
movq %r14, %rdi
movl %ebx, %esi
callq 0x737c1
movsd 0x18(%r15), %xmm0
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x7314b
movq %r14, %rdi
movl %ebx, %esi
callq 0x737fd
movq %r14, %rdi
movl %ebx, %esi
callq 0x7320f
addq $0xf4248, %rsp          # imm = 0xF4248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: generate_test_code_selectaverage
void generate_test_code_selectaverage(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, double* m)
{
 /*!Last Changed 02.06.2006*/
 code_function_header(testcodefile, "selectaverage", d->featurecount, language);
 code_start(testcodefile, language);
 code_function_return_regression(testcodefile, "selectaverage", language, *m);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl 0x1bc(%rdx), %edx
leaq 0x24109(%rip), %r15     # 0x99d75
movq %r15, %rsi
movl %ebp, %ecx
callq 0x72674
movq %r14, %rdi
movl %ebp, %esi
callq 0x726d3
movsd (%rbx), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x7314b
movq %r14, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7320f
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: generate_test_code_c45
void generate_test_code_c45(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, Decisionnodeptr m)
{
 /*!Last Changed 14.06.2006*/
 code_function_header(testcodefile, "c45", d->featurecount, language);
 code_start(testcodefile, language);  
 code_decisionnode(testcodefile, language, "c45", "testdata", d, m, 0);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl 0x1bc(%rdx), %edx
leaq 0x22d9a(%rip), %r12     # 0x99c42
movq %r12, %rsi
movl %ebp, %ecx
callq 0x72674
movq %r15, %rdi
movl %ebp, %esi
callq 0x726d3
andl $0x0, (%rsp)
leaq 0x2999b(%rip), %rcx     # 0xa0862
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r14, %r8
movq %rbx, %r9
callq 0x748e8
movq %r15, %rdi
movl %ebp, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7320f
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: generate_test_code_ldt
void generate_test_code_ldt(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, Decisionnodeptr m)
{
 /*!Last Changed 14.06.2006*/
 code_function_header(testcodefile, "ldt", d->featurecount, language);
 code_constant_start(testcodefile, language);
	code_1d_array_constant_instance(testcodefile, language, d, "mean", d->featurecount, &mean);
	code_1d_array_constant_instance(testcodefile, language, d, "variance", d->featurecount, &variance);
	code_variable_start(testcodefile, language);
 code_add_variable(testcodefile, language, INTEGER_VARIABLE, 1, "i");
 code_add_array_variable(testcodefile, language, 1, REAL_VARIABLE, "testdataconverted", d->featurecount);
 code_start(testcodefile, language);  
 code_normalize(testcodefile, language, d);
 code_decisionnode(testcodefile, language, "ldt", "testdataconverted", d, m, 0);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movl 0x1bc(%rdx), %edx
leaq 0x1e810(%rip), %rsi     # 0x95723
movl %ebx, %ecx
callq 0x72674
movq %r14, %rdi
movl %ebx, %esi
callq 0x72b0a
movl 0x1bc(%r12), %r8d
leaq 0x2a8b8(%rip), %rcx     # 0xa17eb
leaq 0x33306e(%rip), %r9     # 0x3a9fa8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x73bdf
movl 0x1bc(%r12), %r8d
leaq 0x1f4ce(%rip), %rcx     # 0x96424
leaq 0x33307b(%rip), %r9     # 0x3a9fd8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x73bdf
movq %r14, %rdi
movl %ebx, %esi
callq 0x72fb3
leaq 0x29ca2(%rip), %r8      # 0xa0c1d
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x72de1
movl 0x1bc(%r12), %r9d
leaq 0x2984b(%rip), %r13     # 0xa07e8
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %ebp, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x72b76
movq %r14, %rdi
movl %ebx, %esi
callq 0x726d3
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x75838
andl $0x0, (%rsp)
movq %r14, %rdi
movl %ebx, %esi
leaq 0x1e74c(%rip), %rdx     # 0x95723
movq %r13, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0x748e8
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7320f
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: generate_test_code_regtree
void generate_test_code_regtree(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, Regressionnodeptr m)
{
 /*!Last Changed 14.06.2006*/
 code_function_header(testcodefile, "regtree", d->featurecount, language);
 code_constant_start(testcodefile, language);
	code_1d_array_constant_instance(testcodefile, language, d, "mean", d->multifeaturecount - 1, &mean);
	code_1d_array_constant_instance(testcodefile, language, d, "variance", d->multifeaturecount - 1, &variance);
	code_variable_start(testcodefile, language);
 code_add_variable(testcodefile, language, INTEGER_VARIABLE, 4, "i", "j", "k", "a");
 code_add_array_variable(testcodefile, language, 1, REAL_VARIABLE, "testdataconverted", d->multifeaturecount);
 code_start(testcodefile, language);
	code_realize(testcodefile, language, d, YES);
 code_regressionnode(testcodefile, language, d, m, 0);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movl 0x1bc(%rdx), %edx
leaq 0x22c9d(%rip), %rsi     # 0x99dc7
movl %ebx, %ecx
callq 0x72674
movq %r14, %rdi
movl %ebx, %esi
callq 0x72b0a
movl 0x1c0(%r12), %r8d
decl %r8d
leaq 0x2a69e(%rip), %rcx     # 0xa17eb
leaq 0x332e54(%rip), %r9     # 0x3a9fa8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x73bdf
movl 0x1c0(%r12), %r8d
decl %r8d
leaq 0x1f2b1(%rip), %rcx     # 0x96424
leaq 0x332e5e(%rip), %r9     # 0x3a9fd8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x73bdf
movq %r14, %rdi
movl %ebx, %esi
callq 0x72fb3
leaq 0x20c88(%rip), %r10     # 0x97e20
leaq 0x29b47(%rip), %r11     # 0xa0ce6
leaq 0x29a77(%rip), %r8      # 0xa0c1d
leaq 0x2976b(%rip), %r9      # 0xa0918
pushq $0x4
popq %rcx
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x72de1
popq %rax
popq %rcx
movl 0x1c0(%r12), %r9d
leaq 0x29615(%rip), %r8      # 0xa07e8
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x72b76
movq %r14, %rdi
movl %ebx, %esi
callq 0x726d3
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x753f5
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x745e8
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7320f
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: generate_test_code_ripper
void generate_test_code_ripper(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, char* algorithm, Rulesetptr m)
{
 /*!Last Changed 15.06.2006*/
 int i;
 Decisionruleptr rule;
 code_function_header(testcodefile, algorithm, d->featurecount, language);
	code_start(testcodefile, language);
 rule = m->start;
 while (rule)
  {
   code_rule(testcodefile, language, d, algorithm, rule);
   code_function_return_classification(testcodefile, algorithm, language, rule->classno);   
   code_else(testcodefile, language);
   rule = rule->next;
  }
 code_function_return_classification(testcodefile, algorithm, language, m->defaultclass);
 for (i = 0; i < m->rulecount; i++)
   code_endif(testcodefile, language);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movl 0x1bc(%rdx), %edx
movq %rcx, %rsi
movl %ebp, %ecx
callq 0x72674
movq %r14, %rdi
movl %ebp, %esi
callq 0x726d3
movq %rbx, %r13
movq (%r13), %r13
testq %r13, %r13
je 0x77294
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r13, %r8
callq 0x74e4f
movl (%r13), %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x72fce
movq %r14, %rdi
movl %ebp, %esi
callq 0x737c1
addq $0x30, %r13
jmp 0x7725a
movl 0x14(%rbx), %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x72fce
xorl %r15d, %r15d
cmpl 0x10(%rbx), %r15d
jge 0x772bc
movq %r14, %rdi
movl %ebp, %esi
callq 0x737fd
incl %r15d
jmp 0x772a7
movq %r14, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7320f
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: generate_test_code_multildt
void generate_test_code_multildt(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, Decisionnodeptr m, char* algorithmname)
{
 /*!Last Changed 24.06.2006*/
 code_function_header(testcodefile, algorithmname, d->featurecount, language);
 code_constant_start(testcodefile, language);
	code_1d_array_constant_instance(testcodefile, language, d, "mean", d->multifeaturecount - 1, &mean);
	code_1d_array_constant_instance(testcodefile, language, d, "variance", d->multifeaturecount - 1, &variance);
	code_variable_start(testcodefile, language);
 code_add_variable(testcodefile, language, INTEGER_VARIABLE, 4, "i", "j", "k", "a");
 code_add_array_variable(testcodefile, language, 1, REAL_VARIABLE, "testdataconverted", d->multifeaturecount);
 code_start(testcodefile, language);  
	code_realize(testcodefile, language, d, YES);
 code_decisionnode(testcodefile, language, algorithmname, "testdataconverted", d, m, 0);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, (%rsp)
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movl 0x1bc(%rdx), %edx
movq %r8, %rsi
movl %ebx, %ecx
callq 0x72674
movq %r14, %rdi
movl %ebx, %esi
callq 0x72b0a
movl 0x1c0(%r12), %r8d
decl %r8d
leaq 0x27feb(%rip), %rcx     # 0xa17eb
leaq 0x3307a1(%rip), %r9     # 0x3a9fa8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x73bdf
movl 0x1c0(%r12), %r8d
decl %r8d
leaq 0x1cbfe(%rip), %rcx     # 0x96424
leaq 0x3307ab(%rip), %r9     # 0x3a9fd8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x73bdf
movq %r14, %rdi
movl %ebx, %esi
callq 0x72fb3
leaq 0x1e5d5(%rip), %r10     # 0x97e20
leaq 0x27494(%rip), %r11     # 0xa0ce6
leaq 0x273c4(%rip), %r8      # 0xa0c1d
leaq 0x270b8(%rip), %r9      # 0xa0918
pushq $0x4
popq %rcx
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x72de1
popq %rax
popq %rcx
movl 0x1c0(%r12), %r9d
leaq 0x26f62(%rip), %rbp     # 0xa07e8
pushq $0x1
popq %r15
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
movl %r15d, %ecx
movq %rbp, %r8
xorl %eax, %eax
callq 0x72b76
movq %r14, %rdi
movl %ebx, %esi
callq 0x726d3
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x753f5
subq $0x8, %rsp
movq %r14, %rdi
movl %ebx, %esi
movq %r13, %rdx
movq %rbp, %rcx
movq %r12, %r8
movq 0x8(%rsp), %r9
pushq $0x0
callq 0x748e8
popq %rax
popq %rcx
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7320f
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savemodel.c
// Function: save_matrix
void save_matrix(FILE* modelfile, matrix m)
{
 /*Last Changed 25.12.2005*/
	int i, j;
 char pst[READLINELENGTH];
 set_precision(pst, NULL, " ");
	for (i = 0; i < m.row; i++)
	 {
		 for (j = 0; j < m.col; j++)
				 fprintf(modelfile, pst, m.values[i][j]);
			fprintf(modelfile, "\n");
	 }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r14
movq %rsi, %r13
shrq $0x20, %r13
leaq 0x1e1b9(%rip), %rdx     # 0x98665
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x35305
testl %r13d, %r13d
cmovlel %r12d, %r13d
testl %ebp, %ebp
movl $0x0, %eax
cmovgl %ebp, %eax
movq %rax, 0x8(%rsp)
cmpq 0x8(%rsp), %r12
je 0x7a50d
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x7a4fd
movq (%rbx,%r12,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
incq %rbp
jmp 0x7a4dd
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x4150
incq %r12
jmp 0x7a4d4
addq $0x7a138, %rsp          # imm = 0x7A138
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_array
void save_array(FILE* modelfile, double* array, int size)
{
 /*Last Changed 22.12.2005*/
 int i;
 char pst[READLINELENGTH];
 set_precision(pst, NULL, " "); 
 for (i = 0; i < size; i++)
   fprintf(modelfile, pst, array[i]);
 fprintf(modelfile, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1e126(%rip), %rdx     # 0x98665
xorl %r12d, %r12d
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x35305
testl %ebp, %ebp
movl $0x0, %r13d
cmovgl %ebp, %r13d
cmpq %r12, %r13
je 0x7a578
movsd (%r14,%r12,8), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
incq %r12
jmp 0x7a55b
pushq $0xa
popq %rdi
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_O2/olcaytaner[P]Isell/savemodel.c
// Function: save_array_int
void save_array_int(FILE* modelfile, int* array, int size)
{
 /*Last Changed 26.12.2005*/
 int i;
 for (i = 0; i < size; i++)
   fprintf(modelfile, "%d ", array[i]);
 fprintf(modelfile, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %r14d
leaq 0x25702(%rip), %r12     # 0x9fcb8
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x7a5d4
movl (%r15,%r13,4), %edx
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x42e0
incq %r13
jmp 0x7a5b9
pushq $0xa
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4150
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savemodel.c
// Function: save_array_two
void save_array_two(FILE* modelfile, double** array, int size1, int size2)
{
 /*Last Changed 25.12.2005*/
 int i, j;
 char pst[READLINELENGTH];
 set_precision(pst, NULL, " "); 
 for (i = 0; i < size1; i++)
	 {
		 for (j = 0; j < size2; j++)
     fprintf(modelfile, pst, array[i][j]);
   fprintf(modelfile, "\n");
	 }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movl %ecx, %ebx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
leaq 0x1e05a(%rip), %rdx     # 0x98665
xorl %ebp, %ebp
leaq 0x10(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x35305
testl %ebx, %ebx
cmovlel %ebp, %ebx
testl %r14d, %r14d
cmovlel %ebp, %r14d
movq %r14, 0x8(%rsp)
cmpq 0x8(%rsp), %rbp
je 0x7a668
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x7a658
movq (%r15,%rbp,8), %rax
movsd (%rax,%r14,8), %xmm0
movq %r12, %rdi
movq %r13, %rsi
movb $0x1, %al
callq 0x42e0
incq %r14
jmp 0x7a637
pushq $0xa
popq %rdi
movq %r12, %rsi
callq 0x4150
incq %rbp
jmp 0x7a62d
addq $0x7a138, %rsp          # imm = 0x7A138
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_support_vector
void save_support_vector(FILE* modelfile, Datasetptr d, Svm_nodeptr sv)
{
 /*Last Changed 26.12.2005*/
 int i = 0;
 char pst[READLINELENGTH];
 set_precision(pst, NULL, " ");
 while (sv[i].index != -1)
  {
   fprintf(modelfile, "%d ", sv[i].index);
   fprintf(modelfile, pst, sv[i].value);
   i++;
  }
 fprintf(modelfile, "%d ", sv[i].index);
 fprintf(modelfile, pst, sv[i].value);
 fprintf(modelfile, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x1dfd0(%rip), %rdx     # 0x98665
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x35305
addq $0x8, %r14
leaq 0x2560b(%rip), %r12     # 0x9fcb8
movl -0x8(%r14), %edx
cmpl $-0x1, %edx
je 0x7a6db
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x42e0
movsd (%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
addq $0x10, %r14
jmp 0x7a6ad
leaq 0x255d6(%rip), %rsi     # 0x9fcb8
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
movsd (%r14), %xmm0
movq %rsp, %rsi
movq %rbx, %rdi
movb $0x1, %al
callq 0x42e0
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x4150
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1deee(%rip), %rdx     # 0x98665
movq %rsp, %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x35305
leaq 0x2552d(%rip), %r13     # 0x9fcb8
xorl %ebp, %ebp
movslq 0x1c0(%r15), %rax
cmpq %rax, %rbp
jge 0x7a7db
movl 0x1407128(%r15), %eax
cmpq %rax, %rbp
jne 0x7a7c1
cmpl $0x0, 0x10(%r15)
movq (%r14), %rax
je 0x7a7c4
movl (%rax,%rbp,8), %edx
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x42e0
jmp 0x7a7d6
movq (%r14), %rax
movsd (%rax,%rbp,8), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
incq %rbp
jmp 0x7a78d
pushq $0xa
popq %rdi
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_O2/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 0x126ea
movl %eax, %ebp
leaq 0x1de42(%rip), %rdx     # 0x98665
movq %rsp, %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x35305
movslq %ebp, %rbp
xorl %r13d, %r13d
cmpq %rbp, %r13
jg 0x7a883
movl 0x1407128(%r15), %eax
cmpq %rax, %r13
jne 0x7a868
cmpl $0x0, 0x10(%r15)
movq (%r14), %rax
je 0x7a86b
movl (%rax,%r13,8), %edx
movq %rbx, %rdi
leaq 0x25459(%rip), %rsi     # 0x9fcb8
xorl %eax, %eax
callq 0x42e0
jmp 0x7a87e
movq (%r14), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
incq %r13
jmp 0x7a836
pushq $0xa
popq %rdi
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_O2/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 0x1dda4(%rip), %rdx     # 0x98665
movq %rsp, %rdi
xorl %esi, %esi
callq 0x35305
leaq 0x30f08(%r15), %r13
pushq $0x15
popq %rbp
xorl %r12d, %r12d
movslq 0x1bc(%r15), %rax
cmpq %rax, %r12
jge 0x7a93e
movl (%r13), %esi
cmpl $0x4, %esi
ja 0x7a924
btl %esi, %ebp
jae 0x7a90a
movq (%r14), %rax
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
movq %rsp, %rsi
movb $0x1, %al
callq 0x42e0
jmp 0x7a932
movq (%r14), %rax
movl (%rax,%r12,8), %edx
movq %rbx, %rdi
leaq 0x2539d(%rip), %rsi     # 0x9fcb8
xorl %eax, %eax
callq 0x42e0
jmp 0x7a932
leaq 0x1ba43(%rip), %rdi     # 0x9636e
xorl %eax, %eax
callq 0x4030
incq %r12
addq $0x340, %r13            # imm = 0x340
jmp 0x7a8d8
pushq $0xa
popq %rdi
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_O2/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 0x1dceb(%rip), %rdx     # 0x98665
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x35305
movq %rbx, %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x42e0
leaq 0x1e769(%rip), %rdx     # 0x9910b
movq %r14, %rdi
xorl %esi, %esi
callq 0x35305
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_O2/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 0x7a9fa
callq 0x7a756
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7a756
jmp 0x7aa0d
callq 0x7a8a0
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7a8a0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ebp, %ebp
movq %rdx, %r12
movl 0x10(%r14), %edx
cmpl %edx, %ebp
jge 0x7aa7e
movq (%r12), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x7a756
addq $0x10, %r12
incl %ebp
jmp 0x7aa5c
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x7a51f
movq 0x10(%r15), %rsi
movl 0x10(%r14), %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a51f
// File: /workspace/github_c_makefile_star2_O2/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 0x2c3cc
leaq 0x25a86(%rip), %rsi     # 0xa0545
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x42e0
testq %rbx, %rbx
je 0x7aae4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7a8a0
movq 0x10(%rbx), %rbx
jmp 0x7aacb
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x7a138, %rsp          # imm = 0x7A138
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
xorl %ebp, %ebp
testl %ecx, %ecx
movl %ecx, 0x4(%rsp)
cmovgl %ecx, %ebp
movq %rdi, %rbx
leaq 0x26258(%rip), %r12     # 0xa0d70
pushq $0x2
popq %r13
pushq $0x1
popq %r15
subl $0x1, %ebp
jb 0x7ab38
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x42c0
jmp 0x7ab20
leaq 0x1e5cc(%rip), %rdx     # 0x9910b
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x35305
movl 0x30(%r14), %edx
leaq 0x25162(%rip), %rsi     # 0x9fcb8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
cmpl $-0x1, 0x30(%r14)
je 0x7aba5
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %rbx, %rdi
callq 0x7a484
movq (%r14), %rdx
movl 0x4(%rsp), %ebp
incl %ebp
movq %rbx, %rdi
movq 0x8(%rsp), %r15
movq %r15, %rsi
movl %ebp, %ecx
callq 0x7aaea
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x7aaea
jmp 0x7abf1
movq 0x20(%r14), %rdi
callq 0x2c3cc
movl 0x60(%r14), %edx
leaq 0x250ff(%rip), %rsi     # 0x9fcb8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x60(%r14)
je 0x7abdc
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %rbx, %rdi
callq 0x7a484
jmp 0x7abf1
movsd 0x48(%r14), %xmm0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movb $0x1, %al
callq 0x42e0
addq $0x7a138, %rsp          # imm = 0x7A138
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_c45
void save_model_c45(FILE* modelfile, Datasetptr d, Decisionnodeptr m, int level)
{
 /*Last Changed 22.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 >= 0 && in_list(d->features[m->featureno].type, 2, REAL, INTEGER))
   fprintf(modelfile, pst, m->split);
 if (m->featureno == LEAF_NODE)
  {
   fprintf(modelfile, "%d ", m->classno);
   save_array_int(modelfile, m->counts, d->classno);
   return;
  }
 else
	 {
		 fprintf(modelfile, "\n");
   if (in_list(d->features[m->featureno].type, 2, REAL, INTEGER))
    {
     save_model_c45(modelfile, d, m->left, level + 1);
     save_model_c45(modelfile, d, m->right, level + 1);
    }
   else
     for (i = 0; i < d->features[m->featureno].valuecount; i++)
       save_model_c45(modelfile, d, &(m->string[i]), level + 1);
	 }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movq %rdx, %r14
movq %rsi, (%rsp)
xorl %ebp, %ebp
testl %ecx, %ecx
movl %ecx, 0xc(%rsp)
cmovgl %ecx, %ebp
movq %rdi, %r15
leaq 0x26140(%rip), %r12     # 0xa0d70
pushq $0x2
popq %r13
pushq $0x1
popq %rbx
subl $0x1, %ebp
jb 0x7ac4f
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x42c0
jmp 0x7ac37
leaq 0x1da0f(%rip), %rdx     # 0x98665
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x35305
movl 0x30(%r14), %edx
leaq 0x2504b(%rip), %rsi     # 0x9fcb8
movq %r15, %rdi
xorl %eax, %eax
callq 0x42e0
movslq 0x30(%r14), %rax
testq %rax, %rax
js 0x7acc0
imulq $0x340, %rax, %rax      # imm = 0x340
movq (%rsp), %r12
movl 0x30f08(%r12,%rax), %edi
pushq $0x2
popq %rdx
movl %edx, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x7acba
movsd 0x28(%r14), %xmm0
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movb $0x1, %al
callq 0x42e0
movl 0x30(%r14), %eax
jmp 0x7acc4
movq (%rsp), %r12
cmpl $-0x1, %eax
je 0x7ad22
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0x4150
movslq 0x30(%r14), %rax
imulq $0x340, %rax, %rax      # imm = 0x340
movl 0x30f08(%r12,%rax), %edi
pushq $0x2
popq %rdx
movl %edx, %esi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x35812
movl 0xc(%rsp), %ebp
incl %ebp
testl %eax, %eax
je 0x7ad5d
movq (%r14), %rdx
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %ecx
callq 0x7ac03
movq 0x8(%r14), %rdx
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %ecx
callq 0x7ac03
jmp 0x7ad4b
movl 0x34(%r14), %edx
leaq 0x24f8b(%rip), %rsi     # 0x9fcb8
movq %r15, %rdi
xorl %eax, %eax
callq 0x42e0
movq 0xa0(%r14), %rsi
movl 0x10(%r12), %edx
movq %r15, %rdi
callq 0x7a595
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30f08(%r12), %rbx
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x30(%r14), %rax
imulq $0x340, %rax, %rax      # imm = 0x340
movslq 0x18(%rbx,%rax), %rax
cmpq %rax, %r13
jge 0x7ad4b
movq 0x10(%r14), %rdx
addq %r12, %rdx
movq %r15, %rdi
movq (%rsp), %rsi
movl %ebp, %ecx
callq 0x7ac03
incq %r13
addq $0x160, %r12            # imm = 0x160
jmp 0x7ad6b
// File: /workspace/github_c_makefile_star2_O2/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 0x1b022(%rip), %rsi     # 0x95e34
xorl %eax, %eax
callq 0x42e0
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
callq 0x7a484
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x7a484
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7a484
// File: /workspace/github_c_makefile_star2_O2/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 0x1afb9(%rip), %rsi     # 0x95e28
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x42e0
leaq 0x50(%rbx), %rsi
movl 0x5c(%rbx), %edx
movq %r14, %rdi
callq 0x7a595
pushq $0x8
popq %r12
movslq 0x5c(%rbx), %rax
cmpq %rax, %r15
jg 0x7aeb2
movq (%rbx), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r14, %rdi
callq 0x7a484
incq %r15
addq $0x10, %r12
jmp 0x7ae8c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x7a138, %rsp          # imm = 0x7A138
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
xorl %ebp, %ebp
testl %ecx, %ecx
movl %ecx, 0x4(%rsp)
cmovgl %ecx, %ebp
movq %rdi, %r15
leaq 0x25e84(%rip), %r12     # 0xa0d70
pushq $0x2
popq %r13
pushq $0x1
popq %rbx
subl $0x1, %ebp
jb 0x7af0b
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x42c0
jmp 0x7aef3
leaq 0x1d753(%rip), %rdx     # 0x98665
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x35305
movl 0x30(%r14), %edx
leaq 0x24d8f(%rip), %rsi     # 0x9fcb8
movq %r15, %rdi
xorl %eax, %eax
callq 0x42e0
cmpl $-0x1, 0x30(%r14)
je 0x7af8d
movsd 0x48(%r14), %xmm0
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movb $0x1, %al
callq 0x42e0
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %r15, %rdi
callq 0x7a484
movq (%r14), %rdx
movl 0x4(%rsp), %ebp
incl %ebp
movq %r15, %rdi
movq 0x8(%rsp), %rbx
movq %rbx, %rsi
movl %ebp, %ecx
callq 0x7aebe
movq 0x8(%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %ecx
callq 0x7aebe
jmp 0x7afb9
movl 0x34(%r14), %edx
leaq 0x24d20(%rip), %rsi     # 0x9fcb8
movq %r15, %rdi
xorl %eax, %eax
callq 0x42e0
movq 0xa0(%r14), %rsi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %edx
movq %r15, %rdi
callq 0x7a595
addq $0x7a138, %rsp          # imm = 0x7A138
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_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 $0x7a138, %rsp          # imm = 0x7A138
movq %rdx, %r15
movq %rsi, 0x8(%rsp)
xorl %ebx, %ebx
testl %ecx, %ecx
movl %ecx, 0x4(%rsp)
cmovgl %ecx, %ebx
movq %rdi, %r12
leaq 0x25d77(%rip), %r13     # 0xa0d70
pushq $0x2
popq %rbp
pushq $0x1
popq %r14
subl $0x1, %ebx
jb 0x7b018
movq %r13, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x42c0
jmp 0x7b000
leaq 0x1d646(%rip), %rdx     # 0x98665
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x35305
movl 0x30(%r15), %edx
leaq 0x24c82(%rip), %rsi     # 0x9fcb8
movq %r12, %rdi
xorl %eax, %eax
callq 0x42e0
movl 0x30(%r15), %eax
leal 0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0x7b073
movsd 0x48(%r15), %xmm0
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
movb $0x1, %al
callq 0x42e0
movq 0x38(%r15), %rsi
movq 0x40(%r15), %rdx
movq %r12, %rdi
callq 0x7a484
jmp 0x7b0bb
cmpl $-0x1, %eax
jne 0x7b0a6
movl 0x34(%r15), %edx
leaq 0x24c35(%rip), %rsi     # 0x9fcb8
movq %r12, %rdi
xorl %eax, %eax
callq 0x42e0
movq 0xa0(%r15), %rsi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %edx
movq %r12, %rdi
callq 0x7a595
jmp 0x7b0bb
movsd 0x28(%r15), %xmm0
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
movb $0x1, %al
callq 0x42e0
cmpl $-0x1, 0x30(%r15)
je 0x7b0ee
movq (%r15), %rdx
movl 0x4(%rsp), %ebx
incl %ebx
movq %r12, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rsi
movl %ebx, %ecx
callq 0x7afcb
movq 0x8(%r15), %rdx
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %ecx
callq 0x7afcb
addq $0x7a138, %rsp          # imm = 0x7A138
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_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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
cmpl 0x10(%r14), %ebp
jge 0x7b12e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7a8a0
movq 0x10(%rbx), %rbx
incl %ebp
jmp 0x7b112
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7a5e8
movq 0x10(%rbx), %rsi
movl 0x10(%r14), %edx
movq %r15, %rdi
callq 0x7a51f
movq 0x8(%rbx), %rsi
movl 0x1bc(%r14), %edx
movq %r15, %rdi
callq 0x7a51f
leaq 0x30f20(%r14), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
movslq 0x10(%r14), %rax
cmpq %rax, %r13
jge 0x7b1db
movq (%rsp), %rbp
xorl %r12d, %r12d
movslq 0x1bc(%r14), %rax
cmpq %rax, %r12
jge 0x7b1d6
cmpl $0x1, -0x18(%rbp)
jne 0x7b1ca
movq 0x18(%rbx), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%r12,8), %rsi
movl (%rbp), %edx
movq %r15, %rdi
callq 0x7a51f
incq %r12
addq $0x340, %rbp            # imm = 0x340
jmp 0x7b1a1
incq %r13
jmp 0x7b191
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_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 0x7a51f
movq 0x18(%rbx), %rsi
movl 0x10(%r14), %edx
movq %r15, %rdi
callq 0x7a51f
pushq $0x8
popq %r12
xorl %r13d, %r13d
movslq 0x10(%r14), %rax
cmpq %rax, %r13
jge 0x7b246
movq (%rbx), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r15, %rdi
callq 0x7a484
incq %r13
addq $0x10, %r12
jmp 0x7b220
pushq $0x8
popq %r12
xorl %r13d, %r13d
cltq
cmpq %rax, %r13
jge 0x7b276
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r15, %rdi
callq 0x7a484
incq %r13
movl 0x10(%r14), %eax
addq $0x10, %r12
jmp 0x7b24d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1ab96(%rip), %rsi     # 0x95e34
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x42e0
movq 0x8(%rbx), %rsi
movl 0x10(%r15), %edx
movq %r14, %rdi
callq 0x7a51f
pushq $0x8
popq %r13
movslq 0x10(%r15), %rax
cmpq %rax, %r12
jge 0x7b2e3
movq 0x10(%rbx), %rax
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r14, %rdi
callq 0x7a484
incq %r12
addq $0x10, %r13
jmp 0x7b2bc
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7a484