LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_1d_array_constant_instance
void code_1d_array_constant_instance(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, char* arrayname, int size, Instanceptr values)
{
 /*!Last Changed 19.10.2007 updated Java*/
	/*!Last Changed 27.06.2006*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :fprintf(testcodefile, "const double %s[%d] = ", arrayname, size);
                         break;
   case JAVA_LANGUAGE   :fprintf(testcodefile, "final double[] %s = ", arrayname);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "%s: array[1..%d] of real = ", arrayname, size);
																									break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "%s = ", arrayname);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "real %s(%d) = ", arrayname, size);
																									break;
 };  
 if (size == d->featurecount)   
   code_constant_instance(testcodefile, language, d, values, -1);
 else
   if (size == d->multifeaturecount - 1)
     code_constant_instance_realized(testcodefile, language, d, values, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movl %r8d, %r12d
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
cmpl $0x5, %esi
ja 0x7ce5c
movl %ebp, %eax
leaq 0x300a1(%rip), %rdx     # 0xaceac
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq 0x307b6(%rip), %rsi     # 0xad5d1
jmp 0x7ce36
leaq 0x307c4(%rip), %rsi     # 0xad5e8
jmp 0x7ce4f
leaq 0x307d0(%rip), %rsi     # 0xad5fd
jmp 0x7ce36
leaq 0x307e3(%rip), %rsi     # 0xad619
movq %r15, %rdi
movq %rcx, %rdx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x42e0
jmp 0x7ce5c
leaq 0x307a8(%rip), %rsi     # 0xad5f7
movq %r15, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x42e0
cmpl %r12d, 0x1bc(%r14)
jne 0x7ce83
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7b797
movl 0x1c0(%r14), %eax
decl %eax
cmpl %r12d, %eax
jne 0x7ceaf
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7b94c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_constant
void code_2d_array_constant(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2, double** values)
{
 /*!Last Changed 12.06.2006*/
 int i;
 code_2d_array_start(testcodefile, language, arrayname, size1, size2);
 for (i = 0; i < size1; i++)
   code_constant_subarray(testcodefile, language, size2, values[i], i);
 code_2d_array_end(testcodefile, language); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r12d
movl %esi, %r14d
movq %rdi, %r15
callq 0x7d134
testl %r12d, %r12d
jle 0x7d11b
movl %r12d, %r13d
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rcx
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %r12d, %r8d
callq 0x7b706
incq %r12
cmpq %r12, %r13
jne 0x7d0ff
movq %r15, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7d183
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_start
void code_2d_array_start(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2)
{
 /*!Last Changed 19.10.2007 updated Java, C, C++*/
 /*!Last Changed 05.06.2006*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :fprintf(testcodefile, "const double %s[%d][%d] = {", arrayname, size1, size2);
                         break;
   case JAVA_LANGUAGE   :fprintf(testcodefile, "final double[][] %s = {", arrayname);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "%s: array[1..%d][1..%d] of real = (", arrayname, size1, size2);
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "%s = [", arrayname);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "real %s(%d, %d) = (", arrayname, size1, size2);
                         break;
 };  
}

// Assembly:
cmpl $0x5, %esi
ja 0x7d174
movl %esi, %eax
leaq 0x2fdb2(%rip), %rsi     # 0xacef4
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
leaq 0x305b0(%rip), %rsi     # 0xad702
jmp 0x7d16d
leaq 0x305c3(%rip), %rsi     # 0xad71e
jmp 0x7d17c
leaq 0x305d2(%rip), %rsi     # 0xad736
jmp 0x7d16d
leaq 0x305ed(%rip), %rsi     # 0xad75a
xorl %eax, %eax
jmp 0x42e0
retq
leaq 0x3053f(%rip), %rsi     # 0xad6bb
xorl %eax, %eax
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_constant_matrix
void code_2d_array_constant_matrix(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2, matrixptr matrixarray)
{
 /*!Last Changed 08.08.2007*/
 int i;
 code_2d_array_start(testcodefile, language, arrayname, size1, size2);
 for (i = 0; i < size1; i++)
   code_constant_subarray(testcodefile, language, size2, matrixarray[i].values[0], i);
 code_2d_array_end(testcodefile, language); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r12d
movl %esi, %r14d
movq %rdi, %r15
callq 0x7d134
testl %r12d, %r12d
jle 0x7d1fb
movl %r12d, %r13d
addq $0x8, %rbx
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax), %rcx
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %r12d, %r8d
callq 0x7b706
incq %r12
addq $0x10, %rbx
cmpq %r12, %r13
jne 0x7d1d9
movq %r15, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7d183
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_constant_instance
void code_2d_array_constant_instance(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, char* arrayname, int size1, int size2, Instanceptr values)
{
 /*!Last Changed 09.06.2006*/
 int i;
 Instanceptr tmp = values;
 code_2d_array_start(testcodefile, language, arrayname, size1, size2);
 i = 0;
 while (tmp)
  {
   if (size2 == d->featurecount)   
     code_constant_instance(testcodefile, language, d, tmp, i);
   else
     if (size2 == d->multifeaturecount - 1)
       code_constant_instance_realized(testcodefile, language, d, tmp, i);
   i++;
   tmp = tmp->next;
  }
 code_2d_array_end(testcodefile, language); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq 0x40(%rsp), %r12
movq %rcx, %rdx
movl %r8d, %ecx
movl %r9d, %r8d
callq 0x7d134
testq %r12, %r12
je 0x7d290
xorl %r13d, %r13d
cmpl %ebx, 0x1bc(%r14)
jne 0x7d263
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %r12, %rcx
movl %r13d, %r8d
callq 0x7b797
jmp 0x7d283
movl 0x1c0(%r14), %eax
decl %eax
cmpl %ebx, %eax
jne 0x7d283
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %r12, %rcx
movl %r13d, %r8d
callq 0x7b94c
incl %r13d
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x7d245
movq %r15, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7d183
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_constant_sv
void code_2d_array_constant_sv(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2, Svm_nodeptr* values)
{
 /*!Last Changed 24.06.2006*/
 int i;
 code_2d_array_start(testcodefile, language, arrayname, size1, size2);
	for (i = 0; i < size1; i++)
   code_constant_sv(testcodefile, language, values[i], i);
 code_2d_array_end(testcodefile, language); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movl %ecx, %r15d
movl %esi, %ebp
movq %rdi, %r14
callq 0x7d134
testl %r15d, %r15d
jle 0x7d2e4
movl %r15d, %r12d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdx
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %ecx
callq 0x7b8c6
incq %r15
cmpq %r15, %r12
jne 0x7d2cb
movq %r14, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7d183
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_3d_array_constant_matrix
void code_3d_array_constant_matrix(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2, int size3, matrixptr matrixarray)
{
 /*!Last Changed 08.08.2007*/
 int i, j;
 code_3d_array_start(testcodefile, language, arrayname, size1, size2, size3);
 for (i = 0; i < size1; i++)
  {
   code_1d_array_start(testcodefile, language, i);
   for (j = 0; j < size2; j++)
     code_constant_subarray(testcodefile, language, size2, matrixarray[i].values[j], j);
   code_1d_array_end(testcodefile, language, i);
  }
 code_3d_array_end(testcodefile, language); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r12d
movl %esi, %ebp
movq %rdi, %r14
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
callq 0x7d3ae
testl %r12d, %r12d
jle 0x7d396
movl 0x4(%rsp), %r15d
movl %r12d, %eax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x7b5da
cmpl $0x0, 0x4(%rsp)
jle 0x7d37f
movq %r12, %rax
shlq $0x4, %rax
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax), %rbx
addq $0x8, %rbx
xorl %r13d, %r13d
movq (%rbx), %rax
movq (%rax,%r13,8), %rcx
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
movl %r13d, %r8d
callq 0x7b706
incq %r13
cmpq %r13, %r15
jne 0x7d360
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x7b681
incq %r12
cmpq 0x10(%rsp), %r12
jne 0x7d335
movq %r14, %rdi
movl %ebp, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7d183
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_3d_array_start
void code_3d_array_start(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2, int size3)
{
 /*!Last Changed 19.10.2007 updated C, C++, Java*/
 /*!Last Changed 08.08.2007*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :fprintf(testcodefile, "const double %s[%d][%d][%d] = {", arrayname, size1, size2, size3);
                         break;
   case JAVA_LANGUAGE   :fprintf(testcodefile, "const double [][][] %s = {", arrayname);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "%s: array[1..%d][1..%d][1..%d] of real = (", arrayname, size1, size2, size3);
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "%s = [", arrayname);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "real %s(%d, %d, %d) = (", arrayname, size1, size2, size3);
                         break;
 };  
}

// Assembly:
cmpl $0x5, %esi
ja 0x7d3ee
movl %esi, %eax
leaq 0x2fb50(%rip), %rsi     # 0xacf0c
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
leaq 0x303a2(%rip), %rsi     # 0xad76e
jmp 0x7d3e7
leaq 0x303b9(%rip), %rsi     # 0xad78e
jmp 0x7d3f6
leaq 0x303cb(%rip), %rsi     # 0xad7a9
jmp 0x7d3e7
leaq 0x303ed(%rip), %rsi     # 0xad7d4
xorl %eax, %eax
jmp 0x42e0
retq
leaq 0x302c5(%rip), %rsi     # 0xad6bb
xorl %eax, %eax
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_array_initialize
void code_array_initialize(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size, char* value)
{
 /*!Last Changed 13.06.2006*/
 char st[MAXLENGTH];
 code_for(testcodefile, language, "i", 0, size - 1, 1);   
 code_array_index_variable(st, language, arrayname, "i");  
 code_set_variable(testcodefile, language, st, value);
 code_endfor(testcodefile, language, "i");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %r8, %r14
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r12
leal -0x1(%rcx), %r8d
leaq 0x307f8(%rip), %r13     # 0xadc21
movq %r13, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x7ca9f
movq %rsp, %rbp
movq %rbp, %rdi
movl %ebx, %esi
movq %r15, %rdx
movq %r13, %rcx
callq 0x7c24c
movq %r12, %rdi
movl %ebx, %esi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x7ba46
movq %r12, %rdi
movl %ebx, %esi
callq 0x7cd49
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_rule
void code_rule(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, char* algorithm, Decisionruleptr rule)
{
 /*!Last Changed 15.06.2006*/
 char st[MAXLENGTH], st2[MAXLENGTH];
 Decisionconditionptr condition;
 condition = rule->start;
 code_condition(language, d, condition, st);
 condition = condition->next;
 strcpy(st2, st);
 while (condition)
  {
   code_condition(language, d, condition, st);
   switch (language){
     case C_LANGUAGE      :
     case CPP_LANGUAGE    :
     case JAVA_LANGUAGE   :sprintf(st2, "%s && %s", st2, st);
                           break;
     case PASCAL_LANGUAGE :sprintf(st2, "%s and %s", st2, st);
                           break;
     case FORTRAN_LANGUAGE:sprintf(st2, "%s .AND. %s", st2, st);
                           break;
     case MATLAB_LANGUAGE :sprintf(st2, "%s & %s", st2, st);
                           break;
   }
   condition = condition->next;
  }
 code_if_core(testcodefile, language, st2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf4258, %rsp          # imm = 0xF4258
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, 0x8(%rsp)
movq 0x18(%r8), %r12
leaq 0x7a130(%rsp), %r13
movl %esi, %edi
movq %rdx, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7df83
movq 0x48(%r12), %r12
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x4270
testq %r12, %r12
je 0x7e23a
movl %ebx, %r14d
shlq $0x2, %r14
leaq 0x7a130(%rsp), %r13
leaq 0x10(%rsp), %rbp
movl %ebx, %edi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7df83
cmpl $0x5, %ebx
ja 0x7e230
leaq 0x2ee2b(%rip), %rax     # 0xad044
movslq (%r14,%rax), %rsi
addq %rax, %rsi
movq %rbp, %rdi
movq %rbp, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x41b0
movq 0x48(%r12), %r12
testq %r12, %r12
jne 0x7e1fd
leaq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
movl %ebx, %esi
callq 0x7c75c
addq $0xf4258, %rsp          # imm = 0xF4258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_dimension_reduce
void code_dimension_reduce(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, int newdimension)
{
 /*!Last Changed 16.06.2006*/
 char st[MAXLENGTH], st2[MAXLENGTH], st3[MAXLENGTH];
 code_array_initialize(testcodefile, language, "testdatareduced", newdimension, "0.0");
 code_for(testcodefile, language, "i", 0, d->multifeaturecount - 2, 1);   
 code_array_index_variable(st, language, "testdataconverted", "i"); 
 code_set_variable(testcodefile, language, "x_i", st);
 code_for(testcodefile, language, "j", 0, newdimension - 1, 1);
 code_array_index_variable(st2, language, "testdatareduced", "j"); 
 code_2d_array_index_variable(st, language, "eigenvectors", "i", "j");
 code_set_variable(testcodefile, language, "eigenvectors_ij", st);
 sprintf(st3, "%s + eigenvectors_ij * x_i", st2);
 code_set_variable(testcodefile, language, st2, st3);
 code_endfor(testcodefile, language, "j");
 code_endfor(testcodefile, language, "i");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x16e368, %rsp         # imm = 0x16E368
movl %ecx, %ebp
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
leaq 0x2f617(%rip), %rdx     # 0xad896
leaq 0x2f8f7(%rip), %r8      # 0xadb7d
callq 0x7d402
movl 0x1c0(%r12), %r8d
addl $-0x2, %r8d
leaq 0x2f983(%rip), %r12     # 0xadc21
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x7ca9f
leaq 0x2f532(%rip), %rdx     # 0xad7ec
leaq 0xf4240(%rsp), %r13
movq %r13, %rdi
movl %ebx, %esi
movq %r12, %rcx
callq 0x7c24c
leaq 0x2f7cd(%rip), %rdx     # 0xadaa3
movq %r14, %rdi
movl %ebx, %esi
movq %r13, %rcx
callq 0x7ba46
decl %ebp
leaq 0x2f630(%rip), %r15     # 0xad91c
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
movl $0x1, %r9d
callq 0x7ca9f
leaq 0x7a120(%rsp), %rbp
movq %rbp, %rdi
movl %ebx, %esi
leaq 0x2f57e(%rip), %rdx     # 0xad896
movq %r15, %rcx
callq 0x7c24c
leaq 0x2f57f(%rip), %rdx     # 0xad8a6
movq %r13, %rdi
movl %ebx, %esi
movq %r12, %rcx
movq %r15, %r8
callq 0x7c269
leaq 0x2f575(%rip), %rdx     # 0xad8b3
movq %r14, %rdi
movl %ebx, %esi
movq %r13, %rcx
callq 0x7ba46
leaq 0x2f571(%rip), %rsi     # 0xad8c3
movq %rsp, %r15
movq %r15, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x41b0
movq %r14, %rdi
movl %ebx, %esi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x7ba46
movq %r14, %rdi
movl %ebx, %esi
callq 0x7cd49
movq %r14, %rdi
movl %ebx, %esi
callq 0x7cd49
addq $0x16e368, %rsp         # imm = 0x16E368
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_forward_propagation
void code_forward_propagation(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, int row, int col, char* weightname, char* inputname, char* outputname, int sigmoid)
{
 /*!Last Changed 16.06.2006*/
 char st[MAXLENGTH];
 code_for(testcodefile, language, "i", 0, row - 1, 1);     
 code_2d_array_index_variable(st, language, weightname, "i", "0");
 code_set_variable(testcodefile, language, "sum", st);   
 code_for(testcodefile, language, "j", 1, col - 1, 1);
 code_2d_array_index_variable(st, language, weightname, "i", "j");
 code_set_variable(testcodefile, language, "weights_ij", 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_ij * x_j");        
 code_endfor(testcodefile, language, "j");
 code_array_index_variable(st, language, outputname, "i");            
 if (sigmoid)
  {
   code_set_variable(testcodefile, language, "sigmoid", "1 / (1 + exp(-sum))");
   code_set_variable(testcodefile, language, st, "sigmoid");
  }
 else
   code_set_variable(testcodefile, language, st, "sum");
 code_endfor(testcodefile, language, "i");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movq %r9, 0x8(%rsp)
movq %r8, %r15
movl %ecx, %r13d
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rdx), %r8d
leaq 0x2f85d(%rip), %r12     # 0xadc21
movq %r12, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x7ca9f
leaq 0x24dce(%rip), %r8      # 0xa31a9
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movl %ebx, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x7c269
leaq 0x2f81e(%rip), %r12     # 0xadc15
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x7ba46
decl %r13d
leaq 0x2f50b(%rip), %rdx     # 0xad91c
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %ecx
movl %r13d, %r8d
movl $0x1, %r9d
callq 0x7ca9f
movq %rbp, %rdi
movl %ebx, %esi
movq %r15, %rdx
leaq 0x2f7e9(%rip), %r15     # 0xadc21
movq %r15, %rcx
leaq 0x2f4da(%rip), %r8      # 0xad91c
callq 0x7c269
leaq 0x2f490(%rip), %rdx     # 0xad8de
movq %r14, %rdi
movl %ebx, %esi
movq %rbp, %rcx
callq 0x7ba46
leaq 0x2f8a2(%rip), %rcx     # 0xadd04
movq %rbp, %rdi
movl %ebx, %esi
movq 0x8(%rsp), %rdx
callq 0x7c24c
leaq 0x2f4b8(%rip), %rdx     # 0xad930
movq %r14, %rdi
movl %ebx, %esi
movq %rbp, %rcx
callq 0x7ba46
leaq 0x2f45d(%rip), %rcx     # 0xad8e9
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x7ba46
movq %r14, %rdi
movl %ebx, %esi
callq 0x7cd49
movq %rbp, %rdi
movl %ebx, %esi
movq 0x7a170(%rsp), %rdx
movq %r15, %rcx
callq 0x7c24c
cmpl $0x0, 0x7a178(%rsp)
je 0x7e4dd
leaq 0x2970b(%rip), %r12     # 0xa7bd4
leaq 0x2f430(%rip), %rcx     # 0xad900
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x7ba46
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rcx
callq 0x7ba46
movq %r14, %rdi
movl %ebx, %esi
callq 0x7cd49
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x8(%rsp)
movq %r8, (%rsp)
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
leaq 0x24c72(%rip), %rcx     # 0xa31a9
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x7c24c
leaq 0x2f6c7(%rip), %rdx     # 0xadc15
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rcx
callq 0x7ba46
decl %r15d
leaq 0x2f3b7(%rip), %r13     # 0xad91c
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl $0x1, %ecx
movl %r15d, %r8d
movl $0x1, %r9d
callq 0x7ca9f
movq %r12, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x7c24c
leaq 0x2f37d(%rip), %rdx     # 0xad914
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rcx
callq 0x7ba46
leaq 0x2f759(%rip), %rcx     # 0xadd04
movq %r12, %rdi
movl %ebp, %esi
movq (%rsp), %rdx
callq 0x7c24c
leaq 0x2f370(%rip), %rdx     # 0xad930
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rcx
callq 0x7ba46
leaq 0x2f34a(%rip), %rcx     # 0xad91e
movq %r14, %rdi
movl %ebp, %esi
leaq 0x2f635(%rip), %rbx     # 0xadc15
movq %rbx, %rdx
callq 0x7ba46
movq %r14, %rdi
movl %ebp, %esi
callq 0x7cd49
movq %r14, %rdi
movl %ebp, %esi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x7ba46
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7c601
movq %r14, %rdi
movl %ebx, %esi
movq %rbp, %rdx
callq 0x7c75c
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7ba46
leaq 0x2f5b2(%rip), %rcx     # 0xadc21
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x7ba46
movq %r14, %rdi
movl %ebx, %esi
callq 0x7c903
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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, %ebp
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movq %r9, %rdx
movq %r8, %rcx
callq 0x7ba46
decl %ebp
leaq 0x2f557(%rip), %r13     # 0xadc21
movq %r14, %rdi
movl %ebx, %esi
movq %r13, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
movl $0x1, %r9d
callq 0x7ca9f
movq %rsp, %rbp
movq %rbp, %rdi
movl %ebx, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7c24c
movq %r14, %rdi
movl %ebx, %esi
movq 0x7a168(%rsp), %rdx
movq %rbp, %rcx
movq %r15, %r8
movq 0x7a160(%rsp), %r9
callq 0x7e616
movq %r14, %rdi
movl %ebx, %esi
callq 0x7cd49
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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
leaq 0x7a120(%rsp), %r15
movq %r15, %rdi
callq 0x7c24c
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4270
leaq 0x2f1cb(%rip), %rsi     # 0xad934
movq %r12, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x41b0
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x7ba46
addq $0xf4248, %rsp          # imm = 0xF4248
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x2edd9(%rip), %rdx     # 0xadc15
leaq 0x2ed3a(%rip), %rcx     # 0xadb7d
callq 0x7ba46
movl 0x1c0(%r15), %r8d
addl $-0x2, %r8d
leaq 0x2eac2(%rip), %r15     # 0xad91c
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x7ca9f
leaq 0x2e976(%rip), %rdx     # 0xad7ec
movq %rsp, %r12
movq %r12, %rdi
movl %ebx, %esi
movq %r15, %rcx
callq 0x7c24c
leaq 0x2eaa3(%rip), %rdx     # 0xad930
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rcx
callq 0x7ba46
leaq 0x2ee08(%rip), %rdx     # 0xadca9
leaq 0x2ed79(%rip), %rcx     # 0xadc21
movq %r12, %rdi
movl %ebx, %esi
movq %r15, %r8
callq 0x7c269
leaq 0x2ead8(%rip), %rdx     # 0xad994
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rcx
callq 0x7ba46
movl 0x7a154(%rsp), %r15d
cmpq $0x3, %r15
ja 0x7eef6
leaq 0x2e17e(%rip), %rax     # 0xad05c
movslq (%rax,%r15,4), %rcx
addq %rax, %rcx
leaq 0x2ed29(%rip), %rdx     # 0xadc15
movq %r14, %rdi
movl %ebx, %esi
callq 0x7ba46
movq %r14, %rdi
movl %ebx, %esi
callq 0x7cd49
decl %r15d
cmpl $0x2, %r15d
ja 0x7ef2b
movl %r15d, %eax
leaq 0x2e159(%rip), %rdx     # 0xad06c
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
leaq 0x2ecf4(%rip), %rdx     # 0xadc15
movq %r14, %rdi
movl %ebx, %esi
callq 0x7ba46
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x27d0a(%rip), %rsi     # 0xa6c5e
movl %ebx, %ecx
callq 0x7b551
cmpl $0x2, %ebx
jne 0x7ef79
leaq 0x2e111(%rip), %rdi     # 0xad078
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
incl 0x330269(%rip)          # 0x3af1e8
movl (%r15), %ecx
leaq 0x27cd5(%rip), %rsi     # 0xa6c5e
movq %r14, %rdi
movl %ebx, %edx
callq 0x7bf18
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x7c1ca
// File: /workspace/github_c_makefile_star2_O1/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 0x27df3(%rip), %rsi     # 0xa6dbb
movl %ebx, %ecx
callq 0x7b551
cmpl $0x2, %ebx
jne 0x7efed
leaq 0x2e09d(%rip), %rdi     # 0xad078
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
incl 0x3301f5(%rip)          # 0x3af1e8
movl (%r15), %ecx
leaq 0x2e869(%rip), %rdx     # 0xad866
leaq 0x7a120(%rsp), %r12
movq %r12, %rdi
movl %ebx, %esi
callq 0x7c219
movsd 0x8(%r15), %xmm0
leaq 0x2e196(%rip), %rsi     # 0xad1b2
movq %rsp, %r13
movq %r13, %rdi
movb $0x1, %al
callq 0x41b0
leaq 0x26ec2(%rip), %rsi     # 0xa5ef2
leaq 0xf4240(%rsp), %rbp
movl %ebx, %edi
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
callq 0x7c601
movq %r14, %rdi
movl %ebx, %esi
movq %rbp, %rdx
callq 0x7c75c
movsd 0x10(%r15), %xmm0
leaq 0x27d59(%rip), %r12     # 0xa6dbb
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x7c0de
movq %r14, %rdi
movl %ebx, %esi
callq 0x7c8ac
movsd 0x18(%r15), %xmm0
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x7c0de
movq %r14, %rdi
movl %ebx, %esi
callq 0x7c903
movq %r14, %rdi
movl %ebx, %esi
callq 0x7c1ca
addq $0x16e368, %rsp         # imm = 0x16E368
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x27d11(%rip), %rsi     # 0xa6ddd
movl %ebx, %ecx
callq 0x7b551
cmpl $0x2, %ebx
jne 0x7f0f1
leaq 0x2df99(%rip), %rdi     # 0xad078
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
incl 0x3300f1(%rip)          # 0x3af1e8
movsd (%r15), %xmm0
leaq 0x27cda(%rip), %rsi     # 0xa6ddd
movq %r14, %rdi
movl %ebx, %edx
callq 0x7c0de
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x7c1ca
// File: /workspace/github_c_makefile_star2_O1/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 0x26383(%rip), %rsi     # 0xa6caa
movl %ebx, %ecx
callq 0x7b551
cmpl $0x2, %ebx
jne 0x8094c
leaq 0x2c73e(%rip), %rdi     # 0xad078
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
incl 0x32e896(%rip)          # 0x3af1e8
movl $0x0, (%rsp)
leaq 0x2634a(%rip), %rdx     # 0xa6caa
leaq 0x2ceff(%rip), %rcx     # 0xad866
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %r8
movq %r15, %r9
callq 0x7db83
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7c1ca
// File: /workspace/github_c_makefile_star2_O1/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 0x21d77(%rip), %rsi     # 0xa2723
movl %ebx, %ecx
callq 0x7b551
cmpl $0x2, %ebx
jne 0x80a32
leaq 0x2c846(%rip), %rdi     # 0xad205
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
movl 0x1bc(%r12), %r8d
leaq 0x2de1b(%rip), %rcx     # 0xae7fb
leaq 0x32e5c1(%rip), %r9     # 0x3aefa8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x7cde7
movl 0x1bc(%r12), %r8d
leaq 0x22a21(%rip), %rcx     # 0xa3424
leaq 0x32e5ce(%rip), %r9     # 0x3aefd8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x7cde7
leaq 0x2c84a(%rip), %rdi     # 0xad268
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
jmp 0x80a78
movl 0x1bc(%r12), %r8d
leaq 0x2ddba(%rip), %rcx     # 0xae7fb
leaq 0x32e560(%rip), %r9     # 0x3aefa8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x7cde7
movl 0x1bc(%r12), %r8d
leaq 0x229c0(%rip), %rcx     # 0xa3424
leaq 0x32e56d(%rip), %r9     # 0x3aefd8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x7cde7
leaq 0x2d1a2(%rip), %r8      # 0xadc21
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x7bd1c
movl 0x1bc(%r12), %r9d
leaq 0x2cd4b(%rip), %r8      # 0xad7ec
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x7bab4
cmpl $0x2, %ebx
jne 0x80ad5
leaq 0x2c5b5(%rip), %rdi     # 0xad078
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
incl 0x32e70d(%rip)          # 0x3af1e8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x7ec45
movl $0x0, (%rsp)
leaq 0x21c2d(%rip), %rdx     # 0xa2723
leaq 0x2ccef(%rip), %rcx     # 0xad7ec
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %r8
movq %r15, %r9
callq 0x7db83
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7c1ca
// File: /workspace/github_c_makefile_star2_O1/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 0x26157(%rip), %rsi     # 0xa6e2f
movl %ebx, %ecx
callq 0x7b551
cmpl $0x2, %ebx
jne 0x80cfd
leaq 0x2c51a(%rip), %rdi     # 0xad205
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
movl 0x1c0(%r12), %r8d
decl %r8d
leaq 0x2daec(%rip), %rcx     # 0xae7fb
leaq 0x32e292(%rip), %r9     # 0x3aefa8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x7cde7
movl 0x1c0(%r12), %r8d
decl %r8d
leaq 0x226ef(%rip), %rcx     # 0xa3424
leaq 0x32e29c(%rip), %r9     # 0x3aefd8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x7cde7
cmpl $0x2, %ebx
jne 0x80de2
leaq 0x2c50f(%rip), %rdi     # 0xad268
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
leaq 0x240d6(%rip), %r10     # 0xa4e48
leaq 0x2cf71(%rip), %r11     # 0xadcea
leaq 0x2cea1(%rip), %r8      # 0xadc21
leaq 0x2cb95(%rip), %r9      # 0xad91c
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movl $0x4, %ecx
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x7bd1c
addq $0x10, %rsp
movl 0x1c0(%r12), %r9d
leaq 0x2ca3b(%rip), %r8      # 0xad7ec
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x7bab4
leaq 0x2c2aa(%rip), %rdi     # 0xad078
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
jmp 0x80e3e
leaq 0x2405f(%rip), %r10     # 0xa4e48
leaq 0x2cefa(%rip), %r11     # 0xadcea
leaq 0x2ce2a(%rip), %r8      # 0xadc21
leaq 0x2cb1e(%rip), %r9      # 0xad91c
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
movl $0x4, %ecx
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x7bd1c
addq $0x10, %rsp
movl 0x1c0(%r12), %r9d
leaq 0x2c9c4(%rip), %r8      # 0xad7ec
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x7bab4
incl 0x32e3a4(%rip)          # 0x3af1e8
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
movl $0x1, %ecx
callq 0x7e795
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x7d866
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7c1ca
// File: /workspace/github_c_makefile_star2_O1/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 0x7b551
cmpl $0x2, %ebp
jne 0x80ec5
leaq 0x2c1c5(%rip), %rdi     # 0xad078
movl $0x6, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
incl 0x32e31d(%rip)          # 0x3af1e8
movq (%rbx), %r13
testq %r13, %r13
je 0x80f04
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r13, %r8
callq 0x7e19b
movl (%r13), %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x7bf18
movq %r14, %rdi
movl %ebp, %esi
callq 0x7c8ac
movq 0x30(%r13), %r13
jmp 0x80ece
movl 0x14(%rbx), %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x7bf18
cmpl $0x0, 0x10(%rbx)
jle 0x80f30
xorl %r15d, %r15d
movq %r14, %rdi
movl %ebp, %esi
callq 0x7c903
incl %r15d
cmpl 0x10(%rbx), %r15d
jl 0x80f1d
movq %r14, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7c1ca
// File: /workspace/github_c_makefile_star2_O1/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 0x2088c(%rip), %rdx     # 0xa568d
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x39529
testl %r14d, %r14d
jle 0x84e6b
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 0x84e54
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 0x84e35
movl $0xa, %edi
movq %r15, %rsi
callq 0x4150
incq %rbp
cmpq 0x8(%rsp), %rbp
jne 0x84e2d
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_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 0x207f0(%rip), %rdx     # 0xa568d
movq %rsp, %rdi
xorl %esi, %esi
callq 0x39529
testl %ebp, %ebp
jle 0x84ecf
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 0x84eb4
movl $0xa, %edi
movq %rbx, %rsi
callq 0x4150
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_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 0x84f27
movq %rsi, %r14
movl %edx, %r12d
leaq 0x27da2(%rip), %r15     # 0xaccad
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 0x84f0e
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4150
// File: /workspace/github_c_makefile_star2_O1/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 0x2072c(%rip), %rdx     # 0xa568d
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x39529
testl %ebp, %ebp
jle 0x84fc3
movl %ebp, %eax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %ebp
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
cmpl $0x0, 0x4(%rsp)
jle 0x84fac
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 0x84f8d
movl $0xa, %edi
movq %r15, %rsi
callq 0x4150
incq %rbx
cmpq 0x8(%rsp), %rbx
jne 0x84f83
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savemodel.c
// Function: save_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 0x2069d(%rip), %rdx     # 0xa568d
movq %rsp, %rdi
xorl %esi, %esi
callq 0x39529
movl (%r14), %edx
cmpl $-0x1, %edx
je 0x85039
leaq 0x27ca4(%rip), %r15     # 0xaccad
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 0x8500c
leaq 0x27c6d(%rip), %rsi     # 0xaccad
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