LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_forward_propagation_regression_output
void code_forward_propagation_regression_output(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, int col, char* weightname, char* inputname, char* outputname)
{
 /*!Last Changed 24.06.2006*/
 char st[MAXLENGTH];
 code_array_index_variable(st, language, weightname, "0");
 code_set_variable(testcodefile, language, "sum", st);   
 code_for(testcodefile, language, "j", 1, col - 1, 1);
 code_array_index_variable(st, language, weightname, "j");
 code_set_variable(testcodefile, language, "weights_j", st);        
 code_array_index_variable(st, language, inputname, "j - 1");            
 code_set_variable(testcodefile, language, "x_j", st);        
 code_set_variable(testcodefile, language, "sum", "sum + weights_j * x_j");        
 code_endfor(testcodefile, language, "j");
 code_set_variable(testcodefile, language, outputname, "sum");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movq %r9, %rbx
movq %r8, 0x8(%rsp)
movq %rcx, %r12
movl %edx, %r13d
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r15d
cmpl $0x5, %esi
ja 0x8026c
leaq 0x53b2e(%rip), %rax     # 0xd3d80
movq (%rax,%r15,8), %rsi
leaq 0x25f4c(%rip), %rcx     # 0xa61a9
leaq 0x10(%rsp), %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x41b0
leaq 0x30a3a(%rip), %rdx     # 0xb0cad
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
callq 0x7d316
decl %r13d
leaq 0x30728(%rip), %rdx     # 0xb09b4
movq %r14, %rdi
movl %ebp, %esi
movl $0x1, %ecx
movl %r13d, %r8d
movl $0x1, %r9d
callq 0x7e3dc
cmpl $0x5, %ebp
ja 0x802ca
leaq 0x53ad0(%rip), %rax     # 0xd3d80
movq (%rax,%r15,8), %rsi
leaq 0x306f9(%rip), %rcx     # 0xb09b4
leaq 0x10(%rsp), %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x41b0
leaq 0x306db(%rip), %rdx     # 0xb09ac
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
callq 0x7d316
cmpl $0x5, %ebp
ja 0x80308
leaq 0x53a94(%rip), %rax     # 0xd3d80
movq (%rax,%r15,8), %rsi
leaq 0x30aa5(%rip), %rcx     # 0xb0d9c
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x41b0
leaq 0x306b9(%rip), %rdx     # 0xb09c8
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
callq 0x7d316
leaq 0x30988(%rip), %r15     # 0xb0cad
leaq 0x3068a(%rip), %rcx     # 0xb09b6
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x7d316
movq %r14, %rdi
movl %ebp, %esi
callq 0x7e686
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x7d316
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_compare_and_set_bound
void code_compare_and_set_bound(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* comparison, char* value, char* bestbound, char* index)
{
 /*!Last Changed 16.06.2006*/
 code_if(testcodefile, language, comparison, value, bestbound);
 code_set_variable(testcodefile, language, bestbound, value);
 code_set_variable(testcodefile, language, index, "i"); 
 code_endif(testcodefile, language);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %rbp
movl %esi, %edi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %rbp, %r8
callq 0x7df46
movq %r14, %rdi
movl %ebx, %esi
movq %rbp, %rdx
callq 0x7e093
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7d316
leaq 0x308fb(%rip), %rcx     # 0xb0cb9
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x7d316
movq %r14, %rdi
movl %ebx, %esi
callq 0x7e23a
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_find_bound_of_list
void code_find_bound_of_list(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* listname, int list_length, char* initialbound, char* bestbound, char* index, char* comparison)
{
 /*!Last Changed 16.06.2006*/
 char st[MAXLENGTH];
 code_set_variable(testcodefile, language, bestbound, initialbound);
 code_for(testcodefile, language, "i", 0, list_length - 1, 1);   
 code_array_index_variable(st, language, listname, "i");  
 code_compare_and_set_bound(testcodefile, language, comparison, st, bestbound, index);
 code_endfor(testcodefile, language, "i");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %r9, %r15
movl %ecx, %r12d
movq %rdx, %rbp
movl %esi, %ebx
movq %rdi, %r14
movq 0x7a168(%rsp), %r13
movq %r9, %rdx
movq %r8, %rcx
callq 0x7d316
decl %r12d
leaq 0x30896(%rip), %rdx     # 0xb0cb9
movq %r14, %rdi
movl %ebx, %esi
xorl %ecx, %ecx
movl %r12d, %r8d
movl $0x1, %r9d
callq 0x7e3dc
cmpl $0x5, %ebx
ja 0x8045e
movl %ebx, %eax
leaq 0x5393a(%rip), %rcx     # 0xd3d80
movq (%rcx,%rax,8), %rsi
leaq 0x30868(%rip), %rcx     # 0xb0cb9
movq %rsp, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x41b0
movq %rsp, %rcx
movq %r14, %rdi
movl %ebx, %esi
movq %r13, %rdx
movq %r15, %r8
movq 0x7a160(%rsp), %r9
callq 0x80365
movq %r14, %rdi
movl %ebx, %esi
callq 0x7e686
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_increment
void code_increment(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, char* index)
{
 /*!Last Changed 25.06.2006*/
 char st[MAXLENGTH], st2[MAXLENGTH];
 code_array_index_variable(st, language, arrayname, index);  
 strcpy(st2, st);
 sprintf(st2, "%s + 1", st2);
 code_set_variable(testcodefile, language, st, st2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf4248, %rsp          # imm = 0xF4248
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x5, %esi
ja 0x804c4
movl %ebx, %eax
leaq 0x538ca(%rip), %rsi     # 0xd3d80
movq (%rsi,%rax,8), %rsi
movq %rsp, %rdi
xorl %eax, %eax
callq 0x41b0
leaq 0x7a120(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4270
leaq 0x304eb(%rip), %rsi     # 0xb09cc
movq %r15, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x41b0
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x7d316
addq $0xf4248, %rsp          # imm = 0xF4248
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movl %esi, %ebx
movq %rdi, %r14
movl 0x1bc(%rdx), %edx
leaq 0x28dcb(%rip), %rsi     # 0xa9cce
movl %ebx, %ecx
callq 0x7ce21
cmpl $0x2, %ebx
jne 0x80f28
leaq 0x2f1fa(%rip), %rdi     # 0xb0110
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
incl 0x3312ba(%rip)          # 0x3b21e8
movl (%r15), %ecx
leaq 0x28d96(%rip), %rsi     # 0xa9cce
movq %r14, %rdi
movl %ebx, %edx
callq 0x7d813
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x7db1b
// File: /workspace/github_c_makefile_star2_O3/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 $0x16e368, %rsp         # imm = 0x16E368
movq %rcx, %r15
movl %esi, %ebx
movq %rdi, %r14
movl 0x1bc(%rdx), %edx
leaq 0x28eb4(%rip), %rsi     # 0xa9e2b
movl %ebx, %ecx
callq 0x7ce21
cmpl $0x2, %ebx
jne 0x80f9c
leaq 0x2f186(%rip), %rdi     # 0xb0110
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
incl 0x331246(%rip)          # 0x3b21e8
movl (%r15), %ecx
leaq 0x2f952(%rip), %rdx     # 0xb08fe
leaq 0x7a120(%rsp), %r12
movq %r12, %rdi
movl %ebx, %esi
callq 0x7db6a
movsd 0x8(%r15), %xmm0
leaq 0x2f27f(%rip), %rsi     # 0xb024a
movq %rsp, %r13
movq %r13, %rdi
movb $0x1, %al
callq 0x41b0
leaq 0x27f43(%rip), %rsi     # 0xa8f22
leaq 0xf4240(%rsp), %rbp
movl %ebx, %edi
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
callq 0x7df46
movq %r14, %rdi
movl %ebx, %esi
movq %rbp, %rdx
callq 0x7e093
movsd 0x10(%r15), %xmm0
leaq 0x28e1a(%rip), %r12     # 0xa9e2b
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x7da0f
movq %r14, %rdi
movl %ebx, %esi
callq 0x7e1e3
movsd 0x18(%r15), %xmm0
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x7da0f
movq %r14, %rdi
movl %ebx, %esi
callq 0x7e23a
movq %r14, %rdi
movl %ebx, %esi
callq 0x7db1b
addq $0x16e368, %rsp         # imm = 0x16E368
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movl %esi, %ebx
movq %rdi, %r14
movl 0x1bc(%rdx), %edx
leaq 0x28dd2(%rip), %rsi     # 0xa9e4d
movl %ebx, %ecx
callq 0x7ce21
cmpl $0x2, %ebx
jne 0x810a0
leaq 0x2f082(%rip), %rdi     # 0xb0110
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
incl 0x331142(%rip)          # 0x3b21e8
movsd (%r15), %xmm0
leaq 0x28d9b(%rip), %rsi     # 0xa9e4d
movq %r14, %rdi
movl %ebx, %edx
callq 0x7da0f
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x7db1b
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movl 0x1bc(%rdx), %edx
leaq 0x270e7(%rip), %rsi     # 0xa9d1a
movl %ebx, %ecx
callq 0x7ce21
cmpl $0x2, %ebx
jne 0x82c58
leaq 0x2d4ca(%rip), %rdi     # 0xb0110
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
incl 0x32f58a(%rip)          # 0x3b21e8
movl $0x0, (%rsp)
leaq 0x270ae(%rip), %rdx     # 0xa9d1a
leaq 0x2dc8b(%rip), %rcx     # 0xb08fe
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %r8
movq %r15, %r9
callq 0x7f78c
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7db1b
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movl 0x1bc(%rdx), %edx
leaq 0x22a6b(%rip), %rsi     # 0xa5723
movl %ebx, %ecx
callq 0x7ce21
cmpl $0x2, %ebx
jne 0x82d48
leaq 0x2d5ce(%rip), %rdi     # 0xb029d
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
movl 0x1bc(%r12), %r8d
leaq 0x2eb9b(%rip), %rcx     # 0xb188b
leaq 0x32f2b1(%rip), %r9     # 0x3b1fa8
movq %r14, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x7e724
movl 0x1bc(%r12), %r8d
leaq 0x2370e(%rip), %rcx     # 0xa6424
leaq 0x32f2bb(%rip), %r9     # 0x3b1fd8
movq %r14, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x7e724
leaq 0x2d5cc(%rip), %rdi     # 0xb0300
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
jmp 0x82d8e
movl 0x1bc(%r12), %r8d
leaq 0x2eb34(%rip), %rcx     # 0xb188b
leaq 0x32f24a(%rip), %r9     # 0x3b1fa8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x7e724
movl 0x1bc(%r12), %r8d
leaq 0x236aa(%rip), %rcx     # 0xa6424
leaq 0x32f257(%rip), %r9     # 0x3b1fd8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x7e724
leaq 0x2df24(%rip), %r8      # 0xb0cb9
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x7d617
movl 0x1bc(%r12), %r9d
leaq 0x2dacd(%rip), %r8      # 0xb0884
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x7d384
cmpl $0x2, %ebx
jne 0x82deb
leaq 0x2d337(%rip), %rdi     # 0xb0110
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
incl 0x32f3f7(%rip)          # 0x3b21e8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x80ac7
movl $0x0, (%rsp)
leaq 0x22917(%rip), %rdx     # 0xa5723
leaq 0x2da71(%rip), %rcx     # 0xb0884
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %r8
movq %r15, %r9
callq 0x7f78c
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7db1b
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movl 0x1bc(%rdx), %edx
leaq 0x26ea7(%rip), %rsi     # 0xa9e9f
movl %ebx, %ecx
callq 0x7ce21
cmpl $0x2, %ebx
jne 0x8301d
leaq 0x2d292(%rip), %rdi     # 0xb029d
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
movl 0x1c0(%r12), %r8d
decl %r8d
leaq 0x2e85c(%rip), %rcx     # 0xb188b
leaq 0x32ef72(%rip), %r9     # 0x3b1fa8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x7e724
movl 0x1c0(%r12), %r8d
decl %r8d
leaq 0x233cf(%rip), %rcx     # 0xa6424
leaq 0x32ef7c(%rip), %r9     # 0x3b1fd8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x7e724
cmpl $0x2, %ebx
jne 0x83108
leaq 0x2d287(%rip), %rdi     # 0xb0300
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
leaq 0x24e0e(%rip), %r10     # 0xa7ea0
leaq 0x2dce9(%rip), %r11     # 0xb0d82
leaq 0x2dc19(%rip), %r8      # 0xb0cb9
leaq 0x2d90d(%rip), %r9      # 0xb09b4
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
movl $0x4, %ecx
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x7d617
addq $0x10, %rsp
movl 0x1c0(%r12), %r9d
leaq 0x2d7b0(%rip), %r8      # 0xb0884
movq %r14, %rdi
movl $0x2, %esi
movl $0x1, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x7d384
leaq 0x2d01c(%rip), %rdi     # 0xb0110
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
jmp 0x83164
leaq 0x24d91(%rip), %r10     # 0xa7ea0
leaq 0x2dc6c(%rip), %r11     # 0xb0d82
leaq 0x2db9c(%rip), %r8      # 0xb0cb9
leaq 0x2d890(%rip), %r9      # 0xb09b4
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movl $0x4, %ecx
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x7d617
addq $0x10, %rsp
movl 0x1c0(%r12), %r9d
leaq 0x2d736(%rip), %r8      # 0xb0884
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x7d384
incl 0x32f07e(%rip)          # 0x3b21e8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
movl $0x1, %ecx
callq 0x8050d
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x7f421
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7db1b
// File: /workspace/github_c_makefile_star2_O3/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 0x7ce21
cmpl $0x2, %ebp
jne 0x831eb
leaq 0x2cf37(%rip), %rdi     # 0xb0110
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
incl 0x32eff7(%rip)          # 0x3b21e8
movq (%rbx), %r13
testq %r13, %r13
je 0x8322a
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r13, %r8
callq 0x7fde8
movl (%r13), %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x7d813
movq %r14, %rdi
movl %ebp, %esi
callq 0x7e1e3
movq 0x30(%r13), %r13
jmp 0x831f4
movl 0x14(%rbx), %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x7d813
cmpl $0x0, 0x10(%rbx)
jle 0x83256
xorl %r15d, %r15d
movq %r14, %rdi
movl %ebp, %esi
callq 0x7e23a
incl %r15d
cmpl 0x10(%rbx), %r15d
jl 0x83243
movq %r14, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7db1b
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rdi, %r15
leaq 0x21090(%rip), %rdx     # 0xa86e5
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x3a535
testl %r14d, %r14d
jle 0x876bf
movq %r14, %rax
movq %r14, %r13
shrq $0x20, %r13
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
testl %r13d, %r13d
jle 0x876a8
xorl %r14d, %r14d
movq (%rbx,%rbp,8), %rax
movsd (%rax,%r14,8), %xmm0
movq %r15, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
incq %r14
cmpq %r14, %r13
jne 0x87689
movl $0xa, %edi
movq %r15, %rsi
callq 0x4150
incq %rbp
cmpq 0x8(%rsp), %rbp
jne 0x87681
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_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 0x20ff4(%rip), %rdx     # 0xa86e5
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3a535
testl %ebp, %ebp
jle 0x87723
movl %ebp, %r12d
xorl %r13d, %r13d
movq %rsp, %r15
movsd (%r14,%r13,8), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x42e0
incq %r13
cmpq %r13, %r12
jne 0x87708
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_O3/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
movq %rdi, %rbx
testl %edx, %edx
jle 0x8777b
movq %rsi, %r14
movl %edx, %r12d
leaq 0x28626(%rip), %r15     # 0xafd85
xorl %r13d, %r13d
movl (%r14,%r13,4), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x42e0
incq %r13
cmpq %r13, %r12
jne 0x87762
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4150
// File: /workspace/github_c_makefile_star2_O3/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, 0x4(%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20f30(%rip), %rdx     # 0xa86e5
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x3a535
testl %ebp, %ebp
jle 0x87817
movl %ebp, %eax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %ebp
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
cmpl $0x0, 0x4(%rsp)
jle 0x87800
xorl %r13d, %r13d
movq (%r14,%rbx,8), %rax
movsd (%rax,%r13,8), %xmm0
movq %r15, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
incq %r13
cmpq %r13, %rbp
jne 0x877e1
movl $0xa, %edi
movq %r15, %rsi
callq 0x4150
incq %rbx
cmpq 0x8(%rsp), %rbx
jne 0x877d7
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_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 0x20ea1(%rip), %rdx     # 0xa86e5
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3a535
movl (%r14), %edx
cmpl $-0x1, %edx
je 0x8788d
leaq 0x28528(%rip), %r15     # 0xafd85
movq %rsp, %r12
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x42e0
movsd 0x8(%r14), %xmm0
movq %rbx, %rdi
movq %r12, %rsi
movb $0x1, %al
callq 0x42e0
movl 0x10(%r14), %edx
addq $0x10, %r14
cmpl $-0x1, %edx
jne 0x87860
leaq 0x284f1(%rip), %rsi     # 0xafd85
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x42e0
movsd 0x8(%r14), %xmm0
movq %rsp, %rsi
movq %rbx, %rdi
movb $0x1, %al
callq 0x42e0
movl $0xa, %edi
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_O3/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 0x87909
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 0x87829
incq %r12
cmpq %r12, %r15
jne 0x878ea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x20dba(%rip), %rdx     # 0xa86e5
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3a535
cmpl $0x0, 0x1c0(%r15)
jle 0x87997
movq %rsp, %r12
leaq 0x2843c(%rip), %r13     # 0xafd85
xorl %ebp, %ebp
movl 0x1407128(%r15), %eax
cmpq %rax, %rbp
jne 0x87973
cmpl $0x0, 0x10(%r15)
movq (%r14), %rax
je 0x87976
movl (%rax,%rbp,8), %edx
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x42e0
jmp 0x87988
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 0x8794b
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_O3/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 0x1372c
movl %eax, %r12d
leaq 0x20d03(%rip), %rdx     # 0xa86e5
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3a535
testl %r12d, %r12d
js 0x87a42
incl %r12d
movq %rsp, %r13
xorl %ebp, %ebp
movl 0x1407128(%r15), %eax
cmpq %rax, %rbp
jne 0x87a25
cmpl $0x0, 0x10(%r15)
movq (%r14), %rax
je 0x87a28
movl (%rax,%rbp,8), %edx
movq %rbx, %rdi
leaq 0x28369(%rip), %rsi     # 0xafd85
xorl %eax, %eax
callq 0x42e0
jmp 0x87a3a
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 0x879f9
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_O3/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 0x20c63(%rip), %rdx     # 0xa86e5
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3a535
cmpl $0x0, 0x1bc(%r15)
jle 0x87b09
leaq 0x30f08(%r15), %r12
movl $0x15, %ebp
xorl %r13d, %r13d
movl (%r12), %esi
cmpl $0x4, %esi
ja 0x87ae5
btl %esi, %ebp
jae 0x87acb
movq (%r14), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
movq %rsp, %rsi
movb $0x1, %al
callq 0x42e0
jmp 0x87af3
movq (%r14), %rax
movl (%rax,%r13,8), %edx
movq %rbx, %rdi
leaq 0x282a9(%rip), %rsi     # 0xafd85
xorl %eax, %eax
callq 0x42e0
jmp 0x87af3
leaq 0x1e882(%rip), %rdi     # 0xa636e
xorl %eax, %eax
callq 0x4030
incq %r13
movslq 0x1bc(%r15), %rax
addq $0x340, %r12            # imm = 0x340
cmpq %rax, %r13
jl 0x87aa5
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_O3/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 0x20b9e(%rip), %rdx     # 0xa86e5
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3a535
movq %rbx, %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x42e0
leaq 0x2162c(%rip), %rdx     # 0xa919b
movq %r14, %rdi
xorl %esi, %esi
callq 0x3a535
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_O3/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 0x87bc7
callq 0x8790a
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x8790a
jmp 0x87bda
callq 0x87a61
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x87a61
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x87c50
xorl %ebp, %ebp
movq %r15, %r12
movq (%r12), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x8790a
addq $0x10, %r12
incl %ebp
movl 0x10(%r14), %edx
cmpl %edx, %ebp
jl 0x87c30
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x876d1
movq 0x10(%r15), %rsi
movl 0x10(%r14), %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x876d1
// File: /workspace/github_c_makefile_star2_O3/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 0x30309
leaq 0x28950(%rip), %rsi     # 0xb05e1
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x42e0
testq %rbx, %rbx
je 0x87cb6
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x87a61
movq 0x10(%rbx), %rbx
jmp 0x87c9d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x87d00
leaq 0x29129(%rip), %r12     # 0xb0e0c
movl %ebp, %r13d
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x42c0
decl %r13d
jne 0x87ce6
leaq 0x21494(%rip), %rdx     # 0xa919b
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3a535
movl 0x30(%r14), %edx
leaq 0x28069(%rip), %rsi     # 0xafd85
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
cmpl $-0x1, 0x30(%r14)
je 0x87d62
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %rbx, %rdi
callq 0x87634
movq (%r14), %rdx
incl %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x87cbc
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x87cbc
jmp 0x87dac
movq 0x20(%r14), %rdi
callq 0x30309
movl 0x60(%r14), %edx
leaq 0x2800f(%rip), %rsi     # 0xafd85
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x60(%r14)
je 0x87d99
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %rbx, %rdi
callq 0x87634
jmp 0x87dac
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_O3/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 0x1de12(%rip), %rsi     # 0xa5e2c
xorl %eax, %eax
callq 0x42e0
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
callq 0x87634
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x87634
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x87634
// File: /workspace/github_c_makefile_star2_O3/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 0x1dda9(%rip), %rsi     # 0xa5e20
xorl %eax, %eax
callq 0x42e0
leaq 0x50(%rbx), %rsi
movl 0x5c(%rbx), %edx
movq %r14, %rdi
callq 0x87742
cmpl $0x0, 0x5c(%rbx)
js 0x880c4
movq $-0x1, %r15
movl $0x8, %r12d
movq (%rbx), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r14, %rdi
callq 0x87634
movslq 0x5c(%rbx), %rax
incq %r15
addq $0x10, %r12
cmpq %rax, %r15
jl 0x880a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x88114
leaq 0x28d15(%rip), %r12     # 0xb0e0c
movl %ebp, %r13d
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x42c0
decl %r13d
jne 0x880fa
leaq 0x205ca(%rip), %rdx     # 0xa86e5
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3a535
movl 0x30(%r15), %edx
leaq 0x27c55(%rip), %rsi     # 0xafd85
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
cmpl $-0x1, 0x30(%r15)
je 0x88189
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 0x87634
movq (%r15), %rdx
incl %ebp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x880d0
movq 0x8(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x880d0
jmp 0x881b1
movl 0x34(%r15), %edx
leaq 0x27bf1(%rip), %rsi     # 0xafd85
movq %rbx, %rdi
xorl %eax, %eax
callq 0x42e0
movq 0xa0(%r15), %rsi
movl 0x10(%r14), %edx
movq %rbx, %rdi
callq 0x87742
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_model_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 0x88205
leaq 0x28c22(%rip), %r13     # 0xb0e0c
movl %ebx, %ebp
movl $0x2, %esi
movl $0x1, %edx
movq %r13, %rdi
movq %r15, %rcx
callq 0x42c0
decl %ebp
jne 0x881ec
leaq 0x204d9(%rip), %rdx     # 0xa86e5
movq %rsp, %rdi
xorl %esi, %esi
callq 0x3a535
movl 0x30(%r12), %edx
leaq 0x27b63(%rip), %rsi     # 0xafd85
movq %r15, %rdi
xorl %eax, %eax
callq 0x42e0
movl 0x30(%r12), %eax
leal 0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0x88261
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 0x87634
jmp 0x882a6
cmpl $-0x1, %eax
jne 0x88292
movl 0x34(%r12), %edx
leaq 0x27b13(%rip), %rsi     # 0xafd85
movq %r15, %rdi
xorl %eax, %eax
callq 0x42e0
movq 0xa0(%r12), %rsi
movl 0x10(%r14), %edx
movq %r15, %rdi
callq 0x87742
jmp 0x882a6
movsd 0x28(%r12), %xmm0
movq %rsp, %rsi
movq %r15, %rdi
movb $0x1, %al
callq 0x42e0
cmpl $-0x1, 0x30(%r12)
je 0x882d3
movq (%r12), %rdx
incl %ebx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %ecx
callq 0x881c3
movq 0x8(%r12), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %ecx
callq 0x881c3
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_model_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 0x88321
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 0x87a61
movq 0x10(%rbx), %rbx
incl %ebp
cmpl 0x10(%r14), %ebp
jl 0x882fd
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x87791
movq 0x10(%rbx), %rsi
movl 0x10(%r14), %edx
movq %r15, %rdi
callq 0x876d1
movq 0x8(%rbx), %rsi
movl 0x1bc(%r14), %edx
movq %r15, %rdi
callq 0x876d1
movl 0x10(%r14), %ecx
testl %ecx, %ecx
jle 0x883d9
movl 0x1bc(%r14), %eax
leaq 0x30f20(%r14), %rdx
movq %rdx, (%rsp)
xorl %r13d, %r13d
testl %eax, %eax
jle 0x883ce
movq (%rsp), %rbp
xorl %r12d, %r12d
cmpl $0x1, -0x18(%rbp)
jne 0x883b8
movq 0x18(%rbx), %rax
movq (%rax,%r13,8), %rax
movq (%rax,%r12,8), %rsi
movl (%rbp), %edx
movq %r15, %rdi
callq 0x876d1
movl 0x1bc(%r14), %eax
incq %r12
movslq %eax, %rcx
addq $0x340, %rbp            # imm = 0x340
cmpq %rcx, %r12
jl 0x88394
movl 0x10(%r14), %ecx
incq %r13
movslq %ecx, %rdx
cmpq %rdx, %r13
jl 0x88389
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savemodel.c
// Function: save_model_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 0x876d1
movq 0x18(%rbx), %rsi
movl 0x10(%r14), %edx
movq %r15, %rdi
callq 0x876d1
cmpl $0x0, 0x10(%r14)
jle 0x8847d
movl $0x8, %r12d
xorl %r13d, %r13d
movq (%rbx), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r15, %rdi
callq 0x87634
incq %r13
movslq 0x10(%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x88427
testl %eax, %eax
jle 0x8847d
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r15, %rdi
callq 0x87634
incq %r13
movslq 0x10(%r14), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x88458
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1d987(%rip), %rsi     # 0xa5e2c
xorl %eax, %eax
callq 0x42e0
movq 0x8(%rbx), %rsi
movl 0x10(%r15), %edx
movq %r14, %rdi
callq 0x876d1
cmpl $0x0, 0x10(%r15)
jle 0x884f1
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r14, %rdi
callq 0x87634
incq %r13
movslq 0x10(%r15), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x884cc
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x87634