LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_endfor
void code_endfor(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* forvariable)
{
 /*!Last Changed 07.06.2006*/
 indentation--;
 code_indentation(testcodefile);
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "}\n");
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "end;\n");
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "end\n");
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "enddo\n");
                         break;
 };  
 indentation--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl 0x330daf(%rip), %eax    # 0x3e21b8
decl %eax
movl %eax, 0x330da7(%rip)    # 0x3e21b8
movq -0x8(%rbp), %rdi
callq 0xaef10
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0xb1489
movq -0x20(%rbp), %rax
leaq 0x3b292(%rip), %rcx     # 0xec6c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0x3a45e(%rip), %rsi     # 0xeb8a4
movb $0x0, %al
callq 0x4280
jmp 0xb1489
movq -0x8(%rbp), %rdi
leaq 0x3b58d(%rip), %rsi     # 0xec9e7
movb $0x0, %al
callq 0x4280
jmp 0xb1489
movq -0x8(%rbp), %rdi
leaq 0x37c8f(%rip), %rsi     # 0xe90fd
movb $0x0, %al
callq 0x4280
jmp 0xb1489
movq -0x8(%rbp), %rdi
leaq 0x3b850(%rip), %rsi     # 0xeccd2
movb $0x0, %al
callq 0x4280
movl 0x330d29(%rip), %eax    # 0x3e21b8
addl $-0x1, %eax
movl %eax, 0x330d20(%rip)    # 0x3e21b8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x5, %rax
ja 0xb1563
movq -0x38(%rbp), %rax
leaq 0x3b201(%rip), %rcx     # 0xec6dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq 0x3b7e3(%rip), %rsi     # 0xeccd9
movb $0x0, %al
callq 0x4280
jmp 0xb1563
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x3b7e2(%rip), %rsi     # 0xeccf0
movb $0x0, %al
callq 0x4280
jmp 0xb1563
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq 0x3b7dc(%rip), %rsi     # 0xecd05
movb $0x0, %al
callq 0x4280
jmp 0xb1563
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x3b7be(%rip), %rsi     # 0xeccff
movb $0x0, %al
callq 0x4280
jmp 0xb1563
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq 0x3b7c5(%rip), %rsi     # 0xecd21
movb $0x0, %al
callq 0x4280
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1bc(%rcx), %eax
jne 0xb158e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0xaf560
jmp 0xb15be
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0x1c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xb15bc
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0xaf7b0
jmp 0xb15be
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
callq 0xb1940
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xb192e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x20(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movl -0x2c(%rbp), %r8d
callq 0xaf4c0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb18fc
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb1a10
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x5, %rax
ja 0xb1a0a
movq -0x28(%rbp), %rax
leaq 0x3adae(%rip), %rcx     # 0xec724
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
leaq 0x3b475(%rip), %rsi     # 0xece0a
movb $0x0, %al
callq 0x4280
jmp 0xb1a0a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3b479(%rip), %rsi     # 0xece26
movb $0x0, %al
callq 0x4280
jmp 0xb1a0a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
leaq 0x3b472(%rip), %rsi     # 0xece3e
movb $0x0, %al
callq 0x4280
jmp 0xb1a0a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3b3df(%rip), %rsi     # 0xecdc3
movb $0x0, %al
callq 0x4280
jmp 0xb1a0a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
leaq 0x3b45f(%rip), %rsi     # 0xece62
movb $0x0, %al
callq 0x4280
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_end
void code_2d_array_end(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 05.06.2006*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "};\n");
                         break;
   case PASCAL_LANGUAGE :
   case FORTRAN_LANGUAGE:fprintf(testcodefile, ");\n");
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "];\n");
                         break;
 };  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x2, %eax
jb 0xb1a54
jmp 0xb1a2c
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0xb1a68
jmp 0xb1a36
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0xb1a54
jmp 0xb1a40
movl -0x10(%rbp), %eax
subl $0x4, %eax
je 0xb1a7c
jmp 0xb1a4a
movl -0x10(%rbp), %eax
subl $0x5, %eax
je 0xb1a68
jmp 0xb1a8e
movq -0x8(%rbp), %rdi
leaq 0x3b39e(%rip), %rsi     # 0xecdfd
movb $0x0, %al
callq 0x4280
jmp 0xb1a8e
movq -0x8(%rbp), %rdi
leaq 0x3b393(%rip), %rsi     # 0xece06
movb $0x0, %al
callq 0x4280
jmp 0xb1a8e
movq -0x8(%rbp), %rdi
leaq 0x3b37a(%rip), %rsi     # 0xece01
movb $0x0, %al
callq 0x4280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
callq 0xb1940
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xb1b18
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x20(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movl -0x2c(%rbp), %r8d
callq 0xaf4c0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb1adc
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb1a10
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
callq 0xb1940
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xb1bee
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1bc(%rcx), %eax
jne 0xb1ba9
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0xaf560
jmp 0xb1bd7
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0x1c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xb1bd5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0xaf7b0
jmp 0xb1bd7
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xb1b79
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb1a10
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
callq 0xb1940
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xb1c6a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl -0x2c(%rbp), %ecx
callq 0xaf700
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb1c3c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb1a10
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0xb1d50
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xb1d3d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0xaf310
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xb1d23
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x20(%rbp), %edx
movq 0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movl -0x2c(%rbp), %r8d
callq 0xaf4c0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb1ce2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0xaf410
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xb1cc4
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb1e30
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x5, %rax
ja 0xb1e2a
movq -0x30(%rbp), %rax
leaq 0x3a9b2(%rip), %rcx     # 0xec73c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
leaq 0x3b0c9(%rip), %rsi     # 0xece76
movb $0x0, %al
callq 0x4280
jmp 0xb1e2a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3b0d1(%rip), %rsi     # 0xece96
movb $0x0, %al
callq 0x4280
jmp 0xb1e2a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
leaq 0x3b0c9(%rip), %rsi     # 0xeceb1
movb $0x0, %al
callq 0x4280
jmp 0xb1e2a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3afc3(%rip), %rsi     # 0xecdc3
movb $0x0, %al
callq 0x4280
jmp 0xb1e2a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
leaq 0x3b0b9(%rip), %rsi     # 0xecedc
movb $0x0, %al
callq 0x4280
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x7a150, %rsp          # imm = 0x7A150
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %r8d
subl $0x1, %r8d
leaq 0x3b496(%rip), %rdx     # 0xed329
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0xb10b0
leaq -0x7a150(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0x3b474(%rip), %rcx     # 0xed329
callq 0xb04c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x7a150(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xafa00
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x3b44a(%rip), %rdx     # 0xed329
callq 0xb13f0
addq $0x7a150, %rsp          # imm = 0x7A150
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xf4280, %rsp          # imm = 0xF4280
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xf4278(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0xf4278(%rbp), %rdx
leaq -0x7a150(%rbp), %rcx
callq 0xb2b20
movq -0xf4278(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0xf4278(%rbp)
leaq -0xf4270(%rbp), %rdi
leaq -0x7a150(%rbp), %rsi
callq 0x4220
cmpq $0x0, -0xf4278(%rbp)
je 0xb2f08
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0xf4278(%rbp), %rdx
leaq -0x7a150(%rbp), %rcx
callq 0xb2b20
movl -0xc(%rbp), %eax
movq %rax, -0xf4280(%rbp)
subq $0x5, %rax
ja 0xb2ef1
movq -0xf4280(%rbp), %rax
leaq 0x398fe(%rip), %rcx     # 0xec754
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0xf4270(%rbp), %rdi
leaq -0xf4270(%rbp), %rdx
leaq -0x7a150(%rbp), %rcx
leaq 0x3a0fc(%rip), %rsi     # 0xecf77
movb $0x0, %al
callq 0x4170
jmp 0xb2ef1
leaq -0xf4270(%rbp), %rdi
leaq -0xf4270(%rbp), %rdx
leaq -0x7a150(%rbp), %rcx
leaq 0x3a0e0(%rip), %rsi     # 0xecf80
movb $0x0, %al
callq 0x4170
jmp 0xb2ef1
leaq -0xf4270(%rbp), %rdi
leaq -0xf4270(%rbp), %rdx
leaq -0x7a150(%rbp), %rcx
leaq 0x3a0c5(%rip), %rsi     # 0xecf8a
movb $0x0, %al
callq 0x4170
jmp 0xb2ef1
leaq -0xf4270(%rbp), %rdi
leaq -0xf4270(%rbp), %rdx
leaq -0x7a150(%rbp), %rcx
leaq 0x3a0ac(%rip), %rsi     # 0xecf96
movb $0x0, %al
callq 0x4170
movq -0xf4278(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0xf4278(%rbp)
jmp 0xb2e0c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0xf4270(%rbp), %rdx
callq 0xb0c50
addq $0xf4280, %rsp          # imm = 0xF4280
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x16e380, %rsp         # imm = 0x16E380
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %ecx
leaq 0x3a044(%rip), %rdx     # 0xecf9e
leaq 0x3a324(%rip), %r8      # 0xed285
callq 0xb1e60
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movl 0x1c0(%rax), %r8d
subl $0x2, %r8d
leaq 0x3a3a6(%rip), %rdx     # 0xed329
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0xb10b0
leaq -0x7a140(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x39f53(%rip), %rdx     # 0xecef4
leaq 0x3a381(%rip), %rcx     # 0xed329
callq 0xb04c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x7a140(%rbp), %rcx
leaq 0x3a1e9(%rip), %rdx     # 0xed1ab
callq 0xafa00
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %r8d
subl $0x1, %r8d
leaq 0x3a047(%rip), %rdx     # 0xed024
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0xb10b0
leaq -0xf4260(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x39fa3(%rip), %rdx     # 0xecf9e
leaq 0x3a022(%rip), %rcx     # 0xed024
callq 0xb04c0
leaq -0x7a140(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x39f96(%rip), %rdx     # 0xecfae
leaq 0x3a30a(%rip), %rcx     # 0xed329
leaq 0x39ffe(%rip), %r8      # 0xed024
callq 0xb0560
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x7a140(%rbp), %rcx
leaq 0x39f7b(%rip), %rdx     # 0xecfbb
callq 0xafa00
leaq -0x16e380(%rbp), %rdi
leaq -0xf4260(%rbp), %rdx
leaq 0x39f71(%rip), %rsi     # 0xecfcb
movb $0x0, %al
callq 0x4170
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0xf4260(%rbp), %rdx
leaq -0x16e380(%rbp), %rcx
callq 0xafa00
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x39f9b(%rip), %rdx     # 0xed024
callq 0xb13f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x3a28d(%rip), %rdx     # 0xed329
callq 0xb13f0
addq $0x16e380, %rsp         # imm = 0x16E380
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x7a150, %rsp          # imm = 0x7A150
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
leaq -0x7a150(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0x39fc1(%rip), %rcx     # 0xed287
callq 0xb04c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x7a150(%rbp), %rcx
leaq 0x3a03d(%rip), %rdx     # 0xed31d
callq 0xafa00
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %r8d
subl $0x1, %r8d
leaq 0x39d29(%rip), %rdx     # 0xed024
movl $0x1, %r9d
movl %r9d, %ecx
callq 0xb10b0
leaq -0x7a150(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0x39d06(%rip), %rcx     # 0xed024
callq 0xb04c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x7a150(%rbp), %rcx
leaq 0x39ce4(%rip), %rdx     # 0xed01c
callq 0xafa00
leaq -0x7a150(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq 0x3a0ba(%rip), %rcx     # 0xed40c
callq 0xb04c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x7a150(%rbp), %rcx
leaq 0x39ccc(%rip), %rdx     # 0xed038
callq 0xafa00
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x39f9e(%rip), %rdx     # 0xed31d
leaq 0x39ca0(%rip), %rcx     # 0xed026
callq 0xafa00
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x39c8b(%rip), %rdx     # 0xed024
callq 0xb13f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
leaq 0x39f6d(%rip), %rcx     # 0xed31d
callq 0xafa00
addq $0x7a150, %rsp          # imm = 0x7A150
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0xb0d00
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xafa00
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x30(%rbp), %rdx
leaq 0x39f0c(%rip), %rcx     # 0xed329
callq 0xafa00
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb0ec0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x7a150, %rsp          # imm = 0x7A150
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xafa00
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %r8d
subl $0x1, %r8d
leaq 0x39e96(%rip), %rdx     # 0xed329
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0xb10b0
leaq -0x7a150(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0x39e74(%rip), %rcx     # 0xed329
callq 0xb04c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq 0x18(%rbp), %rdx
leaq -0x7a150(%rbp), %rcx
movq -0x30(%rbp), %r8
movq 0x10(%rbp), %r9
callq 0xb33c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x39e42(%rip), %rdx     # 0xed329
callq 0xb13f0
addq $0x7a150, %rsp          # imm = 0x7A150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xf4260, %rsp          # imm = 0xF4260
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x7a140(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xb04c0
leaq -0xf4260(%rbp), %rdi
leaq -0x7a140(%rbp), %rsi
callq 0x4220
leaq -0xf4260(%rbp), %rdi
leaq -0xf4260(%rbp), %rdx
leaq 0x39ae3(%rip), %rsi     # 0xed03c
movb $0x0, %al
callq 0x4170
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x7a140(%rbp), %rdx
leaq -0xf4260(%rbp), %rcx
callq 0xafa00
addq $0xf4260, %rsp          # imm = 0xF4260
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: generate_test_code_selectmax
void generate_test_code_selectmax(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, Model_selectmaxptr m)
{
 /*!Last Changed 17.05.2006*/
 code_function_header(testcodefile, "selectmax", d->featurecount, language);
 code_start(testcodefile, language);
 code_function_return_classification(testcodefile, "selectmax", language, m->classno);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x1bc(%rax), %edx
movl -0xc(%rbp), %ecx
leaq 0x329c7(%rip), %rsi     # 0xe6816
callq 0xaf1e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaf2c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
leaq 0x329a2(%rip), %rsi     # 0xe6816
callq 0xb0120
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb03a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xf4260, %rsp          # imm = 0xF4260
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x1bc(%rax), %edx
movl -0xc(%rbp), %ecx
leaq 0x32ab1(%rip), %rsi     # 0xe6973
callq 0xaf1e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaf2c0
leaq -0x7a140(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rax
movl (%rax), %ecx
leaq 0x39084(%rip), %rdx     # 0xecf6e
callq 0xb0420
leaq -0xf4260(%rbp), %rdi
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x389b4(%rip), %rsi     # 0xec8ba
movb $0x1, %al
callq 0x4170
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x7a140(%rbp), %rcx
leaq -0xf4260(%rbp), %r8
leaq 0x31b99(%rip), %rdx     # 0xe5ac2
callq 0xb0d00
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
leaq 0x32a2e(%rip), %rsi     # 0xe6973
callq 0xb02c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb0e70
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x20(%rbp), %rax
movsd 0x18(%rax), %xmm0
leaq 0x32a06(%rip), %rsi     # 0xe6973
callq 0xb02c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb0ec0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb03a0
addq $0xf4260, %rsp          # imm = 0xF4260
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: generate_test_code_selectaverage
void generate_test_code_selectaverage(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, double* m)
{
 /*!Last Changed 02.06.2006*/
 code_function_header(testcodefile, "selectaverage", d->featurecount, language);
 code_start(testcodefile, language);
 code_function_return_regression(testcodefile, "selectaverage", language, *m);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x1bc(%rax), %edx
movl -0xc(%rbp), %ecx
leaq 0x329c6(%rip), %rsi     # 0xe6995
callq 0xaf1e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaf2c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
leaq 0x3299f(%rip), %rsi     # 0xe6995
callq 0xb02c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb03a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: generate_test_code_c45
void generate_test_code_c45(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, Decisionnodeptr m)
{
 /*!Last Changed 14.06.2006*/
 code_function_header(testcodefile, "c45", d->featurecount, language);
 code_start(testcodefile, language);  
 code_decisionnode(testcodefile, language, "c45", "testdata", d, m, 0);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x1bc(%rax), %edx
movl -0xc(%rbp), %ecx
leaq 0x31263(%rip), %rsi     # 0xe6862
callq 0xaf1e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaf2c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x3123c(%rip), %rdx     # 0xe6862
leaq 0x37941(%rip), %rcx     # 0xecf6e
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0xb2720
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb03a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: generate_test_code_ldt
void generate_test_code_ldt(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, Decisionnodeptr m)
{
 /*!Last Changed 14.06.2006*/
 code_function_header(testcodefile, "ldt", d->featurecount, language);
 code_constant_start(testcodefile, language);
	code_1d_array_constant_instance(testcodefile, language, d, "mean", d->featurecount, &mean);
	code_1d_array_constant_instance(testcodefile, language, d, "variance", d->featurecount, &variance);
	code_variable_start(testcodefile, language);
 code_add_variable(testcodefile, language, INTEGER_VARIABLE, 1, "i");
 code_add_array_variable(testcodefile, language, 1, REAL_VARIABLE, "testdataconverted", d->featurecount);
 code_start(testcodefile, language);  
 code_normalize(testcodefile, language, d);
 code_decisionnode(testcodefile, language, "ldt", "testdataconverted", d, m, 0);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x1bc(%rax), %edx
movl -0xc(%rbp), %ecx
leaq 0x2cd0b(%rip), %rsi     # 0xe238a
callq 0xaf1e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaf9c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x1bc(%rax), %r8d
leaq 0x2d9ed(%rip), %rcx     # 0xe309a
leaq 0x32c8c4(%rip), %r9     # 0x3e1f78
callq 0xb14a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x1bc(%rax), %r8d
leaq 0x2d9ce(%rip), %rcx     # 0xe30a4
leaq 0x32c8cb(%rip), %r9     # 0x3e1fa8
callq 0xb14a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb00e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
movl $0x1, %ecx
leaq 0x37c26(%rip), %r8      # 0xed329
movb $0x0, %al
callq 0xafe40
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movl 0x1bc(%rax), %r9d
movl $0x1, %ecx
leaq 0x377cc(%rip), %r8      # 0xecef4
movl %ecx, %edx
movb $0x0, %al
callq 0xafab0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaf2c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xb3a50
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x2cc27(%rip), %rdx     # 0xe238a
leaq 0x3778a(%rip), %rcx     # 0xecef4
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0xb2720
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb03a0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: generate_test_code_regtree
void generate_test_code_regtree(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, Regressionnodeptr m)
{
 /*!Last Changed 14.06.2006*/
 code_function_header(testcodefile, "regtree", d->featurecount, language);
 code_constant_start(testcodefile, language);
	code_1d_array_constant_instance(testcodefile, language, d, "mean", d->multifeaturecount - 1, &mean);
	code_1d_array_constant_instance(testcodefile, language, d, "variance", d->multifeaturecount - 1, &variance);
	code_variable_start(testcodefile, language);
 code_add_variable(testcodefile, language, INTEGER_VARIABLE, 4, "i", "j", "k", "a");
 code_add_array_variable(testcodefile, language, 1, REAL_VARIABLE, "testdataconverted", d->multifeaturecount);
 code_start(testcodefile, language);
	code_realize(testcodefile, language, d, YES);
 code_regressionnode(testcodefile, language, d, m, 0);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x1bc(%rax), %edx
movl -0xc(%rbp), %ecx
leaq 0x310e8(%rip), %rsi     # 0xe69e7
callq 0xaf1e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaf9c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x1c0(%rax), %r8d
subl $0x1, %r8d
leaq 0x2d769(%rip), %rcx     # 0xe309a
leaq 0x32c640(%rip), %r9     # 0x3e1f78
callq 0xb14a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x1c0(%rax), %r8d
subl $0x1, %r8d
leaq 0x2d746(%rip), %rcx     # 0xe30a4
leaq 0x32c643(%rip), %r9     # 0x3e1fa8
callq 0xb14a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb00e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
movl $0x4, %ecx
leaq 0x3799e(%rip), %r8      # 0xed329
leaq 0x37692(%rip), %r9      # 0xed024
leaq 0x37a59(%rip), %r10     # 0xed3f2
leaq 0x2f048(%rip), %rax     # 0xe49e8
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0xafe40
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movl 0x1c0(%rax), %r9d
movl $0x1, %ecx
leaq 0x37526(%rip), %r8      # 0xecef4
movl %ecx, %edx
movb $0x0, %al
callq 0xafab0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaf2c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0xb3590
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %r8d, %r8d
callq 0xb2370
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb03a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x1bc(%rax), %edx
movl -0xc(%rbp), %ecx
callq 0xaf1e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaf2c0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xb5acb
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0xb2da0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0xc(%rbp), %edx
movq -0x38(%rbp), %rax
movl (%rax), %ecx
callq 0xb0120
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb0e70
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xb5a7c
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0xc(%rbp), %edx
movq -0x28(%rbp), %rax
movl 0x14(%rax), %ecx
callq 0xb0120
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0xb5b0c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb0ec0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb5ae9
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb03a0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: generate_test_code_multildt
void generate_test_code_multildt(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, Decisionnodeptr m, char* algorithmname)
{
 /*!Last Changed 24.06.2006*/
 code_function_header(testcodefile, algorithmname, d->featurecount, language);
 code_constant_start(testcodefile, language);
	code_1d_array_constant_instance(testcodefile, language, d, "mean", d->multifeaturecount - 1, &mean);
	code_1d_array_constant_instance(testcodefile, language, d, "variance", d->multifeaturecount - 1, &variance);
	code_variable_start(testcodefile, language);
 code_add_variable(testcodefile, language, INTEGER_VARIABLE, 4, "i", "j", "k", "a");
 code_add_array_variable(testcodefile, language, 1, REAL_VARIABLE, "testdataconverted", d->multifeaturecount);
 code_start(testcodefile, language);  
	code_realize(testcodefile, language, d, YES);
 code_decisionnode(testcodefile, language, algorithmname, "testdataconverted", d, m, 0);
 code_function_end(testcodefile, language);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x1bc(%rax), %edx
movl -0xc(%rbp), %ecx
callq 0xaf1e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaf9c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x1c0(%rax), %r8d
subl $0x1, %r8d
leaq 0x2a5b8(%rip), %rcx     # 0xe309a
leaq 0x32948f(%rip), %r9     # 0x3e1f78
callq 0xb14a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x1c0(%rax), %r8d
subl $0x1, %r8d
leaq 0x2a595(%rip), %rcx     # 0xe30a4
leaq 0x329492(%rip), %r9     # 0x3e1fa8
callq 0xb14a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb00e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
movl $0x4, %ecx
leaq 0x347ed(%rip), %r8      # 0xed329
leaq 0x344e1(%rip), %r9      # 0xed024
leaq 0x348a8(%rip), %r10     # 0xed3f2
leaq 0x2be97(%rip), %rax     # 0xe49e8
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0xafe40
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movl 0x1c0(%rax), %r9d
movl $0x1, %ecx
leaq 0x34375(%rip), %r8      # 0xecef4
movl %ecx, %edx
movb $0x0, %al
callq 0xafab0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaf2c0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0xb3590
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x34331(%rip), %rcx     # 0xecef4
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0xb2720
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb03a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x7a140, %rsp          # imm = 0x7A140
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
leaq -0x7a140(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x2b78c(%rip), %rdx     # 0xe5285
callq 0x53310
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xb9b6b
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xb9b4e
movq -0x18(%rbp), %rdi
leaq -0x7a140(%rbp), %rsi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movb $0x1, %al
callq 0x4280
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb9b14
movq -0x18(%rbp), %rdi
leaq 0x2c1e2(%rip), %rsi     # 0xe5d3b
movb $0x0, %al
callq 0x4280
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb9b05
addq $0x7a140, %rsp          # imm = 0x7A140
popq %rbp
retq
nopw %cs:(%rax,%rax)