LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_function_header
void code_function_header(FILE* testcodefile, char* functionname, int featurecount, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 18.05.2006*/
 switch (language){
   case C_LANGUAGE      :fprintf(testcodefile, "double %s(double* testdata){\n", functionname);
                         break;
   case CPP_LANGUAGE    :fprintf(testcodefile, "double test::%s(double* testdata){\n", functionname);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "function %s(real testdata[1..%d]):real;\n", functionname, featurecount);
                         break;
   case JAVA_LANGUAGE   :fprintf(testcodefile, "public static double %s(double[] testdata){\n", functionname);
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "function result = %s(testdata)\n", functionname);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "real function %s(testdata)\nreal testdata(%d)\n", functionname, featurecount);
                         break;
 };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0xaf2af
movq -0x20(%rbp), %rax
leaq 0x3d352(%rip), %rcx     # 0xec564
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3d5a5(%rip), %rsi     # 0xec7cf
movb $0x0, %al
callq 0x4280
jmp 0xaf2af
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3d5ab(%rip), %rsi     # 0xec7ed
movb $0x0, %al
callq 0x4280
jmp 0xaf2af
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq 0x3d5b4(%rip), %rsi     # 0xec811
movb $0x0, %al
callq 0x4280
jmp 0xaf2af
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3d5c5(%rip), %rsi     # 0xec83a
movb $0x0, %al
callq 0x4280
jmp 0xaf2af
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3d5da(%rip), %rsi     # 0xec867
movb $0x0, %al
callq 0x4280
jmp 0xaf2af
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq 0x3d5df(%rip), %rsi     # 0xec887
movb $0x0, %al
callq 0x4280
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_start
void code_start(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 05.06.2006*/
 switch (language){   
   case PASCAL_LANGUAGE :fprintf(testcodefile, "begin\n");
                         break;
   default              :break;
 };
 indentation++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0x2, %eax
jne 0xaf2ed
jmp 0xaf2d9
movq -0x8(%rbp), %rdi
leaq 0x3d49c(%rip), %rsi     # 0xec780
movb $0x0, %al
callq 0x4280
jmp 0xaf2ef
jmp 0xaf2ef
movl 0x332ec3(%rip), %eax    # 0x3e21b8
addl $0x1, %eax
movl %eax, 0x332eba(%rip)    # 0x3e21b8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_1d_array_start
char code_1d_array_start(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, int index)
{
 /*!Last Changed 24.06.2006*/
 char ch = ',';
 if (index != 0 && index != -1)
  {
   switch (language){
     case C_LANGUAGE      :
     case CPP_LANGUAGE    :
     case JAVA_LANGUAGE   :
     case PASCAL_LANGUAGE :
     case FORTRAN_LANGUAGE:fprintf(testcodefile, ",");
                           break;
     case MATLAB_LANGUAGE :fprintf(testcodefile, "\n");
                           break;
   }
  }
 switch (language){
   case MATLAB_LANGUAGE:ch = ' ';
                        break;
   default             :break;
 }  
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "{");
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "(");
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "(/");
                         break;
			case MATLAB_LANGUAGE :if (index == - 1)
																										 fprintf(testcodefile, "[");
																									break;
 }
	return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb $0x2c, -0x11(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0xaf37b
cmpl $-0x1, -0x10(%rbp)
je 0xaf37b
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x4, %eax
jb 0xaf353
jmp 0xaf33f
movl -0x18(%rbp), %eax
subl $0x4, %eax
je 0xaf367
jmp 0xaf349
movl -0x18(%rbp), %eax
subl $0x5, %eax
jne 0xaf379
jmp 0xaf353
movq -0x8(%rbp), %rdi
leaq 0x362bc(%rip), %rsi     # 0xe561a
movb $0x0, %al
callq 0x4280
jmp 0xaf379
movq -0x8(%rbp), %rdi
leaq 0x369c9(%rip), %rsi     # 0xe5d3b
movb $0x0, %al
callq 0x4280
jmp 0xaf37b
movl -0xc(%rbp), %eax
subl $0x4, %eax
jne 0xaf38b
jmp 0xaf385
movb $0x20, -0x11(%rbp)
jmp 0xaf38d
jmp 0xaf38d
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0xaf404
movq -0x20(%rbp), %rax
leaq 0x3d1d7(%rip), %rcx     # 0xec57c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0x3dadb(%rip), %rsi     # 0xece94
movb $0x0, %al
callq 0x4280
jmp 0xaf404
movq -0x8(%rbp), %rdi
leaq 0x3db25(%rip), %rsi     # 0xecef2
movb $0x0, %al
callq 0x4280
jmp 0xaf404
movq -0x8(%rbp), %rdi
leaq 0x3d9f7(%rip), %rsi     # 0xecdd8
movb $0x0, %al
callq 0x4280
jmp 0xaf404
cmpl $-0x1, -0x10(%rbp)
jne 0xaf402
movq -0x8(%rbp), %rdi
leaq 0x3d9cd(%rip), %rsi     # 0xecdc8
movb $0x0, %al
callq 0x4280
jmp 0xaf404
movb -0x11(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_1d_array_end
void code_1d_array_end(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, int index)
{
 /*!Last Changed 24.06.2006*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "}");  
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, ")");
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "/)");
                         break;
			case MATLAB_LANGUAGE :if (index == - 1)
																										 fprintf(testcodefile, "]");
																									break;
 }
	if (index == -1)
		 fprintf(testcodefile, ";\n");  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0xaf499
movq -0x18(%rbp), %rax
leaq 0x3d15a(%rip), %rcx     # 0xec594
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0x3991e(%rip), %rsi     # 0xe8d6c
movb $0x0, %al
callq 0x4280
jmp 0xaf499
movq -0x8(%rbp), %rdi
leaq 0x3df05(%rip), %rsi     # 0xed367
movb $0x0, %al
callq 0x4280
jmp 0xaf499
movq -0x8(%rbp), %rdi
leaq 0x3d43f(%rip), %rsi     # 0xec8b5
movb $0x0, %al
callq 0x4280
jmp 0xaf499
cmpl $-0x1, -0x10(%rbp)
jne 0xaf497
movq -0x8(%rbp), %rdi
leaq 0x3d5da(%rip), %rsi     # 0xeca6a
movb $0x0, %al
callq 0x4280
jmp 0xaf499
cmpl $-0x1, -0x10(%rbp)
jne 0xaf4b1
movq -0x8(%rbp), %rdi
leaq 0x37000(%rip), %rsi     # 0xe64aa
movb $0x0, %al
callq 0x4280
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_constant_subarray
void code_constant_subarray(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, int size, double* values, int index)
{
 /*!Last Changed 24.06.2006 added code_1d_array_start and code_1d_array_end*/
 /*!Last Changed 12.06.2006*/
 int i;
 char ch;
 ch = code_1d_array_start(testcodefile, language, index);
 fprintf(testcodefile, "%.6f", values[0]);
 for (i = 1; i < size; i++)
   fprintf(testcodefile, "%c%.6f", ch, values[i]);
	code_1d_array_end(testcodefile, language, index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0xaf310
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
leaq 0x3d3bb(%rip), %rsi     # 0xec8ba
movb $0x1, %al
callq 0x4280
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xaf543
movq -0x8(%rbp), %rdi
movsbl -0x21(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x3d387(%rip), %rsi     # 0xec8b8
movb $0x1, %al
callq 0x4280
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xaf50d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0xaf410
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_constant_sv
void code_constant_sv(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Svm_nodeptr tmp, int index)
{
 /*!Last Changed 24.06.2006*/
 char ch;
 Svm_nodeptr x = tmp;
 ch = code_1d_array_start(testcodefile, language, index);
	fprintf(testcodefile, "%.6f", x->value);
	x++;
	while (x->index != -1)
	 {
		 fprintf(testcodefile, "%c%.6f", ch, x->value);
		 x++;
	 }
	code_1d_array_end(testcodefile, language, index);
}

// 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)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0xaf310
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x3d176(%rip), %rsi     # 0xec8ba
movb $0x1, %al
callq 0x4280
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $-0x1, (%rax)
je 0xaf78d
movq -0x8(%rbp), %rdi
movsbl -0x1d(%rbp), %edx
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x3d140(%rip), %rsi     # 0xec8b8
movb $0x1, %al
callq 0x4280
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
jmp 0xaf757
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0xaf410
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_constant_instance_realized
void code_constant_instance_realized(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, Instanceptr tmp, int index)
{
 /*!Last Changed 24.06.2006 added code_1d_array_start and code_1d_array_end*/
 /*!Last Changed 05.06.2006*/
 int i;
 char ch;
 ch = code_1d_array_start(testcodefile, language, index);
 fprintf(testcodefile, "%.6f", real_feature(tmp, 0));
 for (i = 1; i < d->multifeaturecount - 1; i++)
   fprintf(testcodefile, "%c%.6f", ch, real_feature(tmp, i));
	code_1d_array_end(testcodefile, language, index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0xaf310
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x42c40
movq -0x38(%rbp), %rdi
leaq 0x3d0bf(%rip), %rsi     # 0xec8ba
movb $0x1, %al
callq 0x4280
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0x1c0(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xaf858
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movsbl -0x29(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x42c40
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %edx
leaq 0x3d072(%rip), %rsi     # 0xec8b8
movb $0x1, %al
callq 0x4280
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xaf809
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0xaf410
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_constant_real
void code_constant_real(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* constname, double constvalue)
{
 /*!Last Changed 12.06.2006*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "const %s = %.6f;\n", constname, constvalue);
                         break;
   case PASCAL_LANGUAGE :
   case MATLAB_LANGUAGE :fprintf(testcodefile, "%s = %.6f;\n", constname, constvalue);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "REAL :: %s = %.6f\n", constname, constvalue);
                         break;
 };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
jb 0xaf8bd
jmp 0xaf895
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0xaf8da
jmp 0xaf89f
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0xaf8bd
jmp 0xaf8a9
movl -0x24(%rbp), %eax
subl $0x4, %eax
je 0xaf8da
jmp 0xaf8b3
movl -0x24(%rbp), %eax
subl $0x5, %eax
je 0xaf8f7
jmp 0xaf912
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
leaq 0x3cff3(%rip), %rsi     # 0xec8c4
movb $0x1, %al
callq 0x4280
jmp 0xaf912
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
leaq 0x3cfdc(%rip), %rsi     # 0xec8ca
movb $0x1, %al
callq 0x4280
jmp 0xaf912
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
leaq 0x3cfcb(%rip), %rsi     # 0xec8d6
movb $0x1, %al
callq 0x4280
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_constant_integer
void code_constant_integer(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* constname, int constvalue)
{
 /*!Last Changed 13.06.2006*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "const %s = %d;\n", constname, constvalue);
                         break;
   case PASCAL_LANGUAGE :
   case MATLAB_LANGUAGE :fprintf(testcodefile, "%s = %d;\n", constname, constvalue);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "INTEGER :: %s = %d\n", constname, constvalue);
                         break;
 };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x2, %eax
jb 0xaf96b
jmp 0xaf943
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0xaf986
jmp 0xaf94d
movl -0x20(%rbp), %eax
subl $0x3, %eax
je 0xaf96b
jmp 0xaf957
movl -0x20(%rbp), %eax
subl $0x4, %eax
je 0xaf986
jmp 0xaf961
movl -0x20(%rbp), %eax
subl $0x5, %eax
je 0xaf9a1
jmp 0xaf9ba
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x3cf6c(%rip), %rsi     # 0xec8e9
movb $0x0, %al
callq 0x4280
jmp 0xaf9ba
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x3cf57(%rip), %rsi     # 0xec8ef
movb $0x0, %al
callq 0x4280
jmp 0xaf9ba
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x3cf46(%rip), %rsi     # 0xec8f9
movb $0x0, %al
callq 0x4280
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_constant_start
void code_constant_start(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 05.06.2006*/
 switch (language){
   case PASCAL_LANGUAGE :fprintf(testcodefile, "const\n");
                         break;
   default              :break;
 };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0x2, %eax
jne 0xaf9ed
jmp 0xaf9d9
movq -0x8(%rbp), %rdi
leaq 0x3cf29(%rip), %rsi     # 0xec90d
movb $0x0, %al
callq 0x4280
jmp 0xaf9ef
jmp 0xaf9ef
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_set_variable
void code_set_variable(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* varname, char* expression)
{
 /*!Last Changed 05.06.2006*/
 code_indentation(testcodefile);
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :
   case MATLAB_LANGUAGE :fprintf(testcodefile, "%s = %s;\n", varname, expression);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "%s = %s\n", varname, expression);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "%s := %s;\n", varname, expression);
                         break;
 };
}

// 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
callq 0xaef10
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
jb 0xafa4e
jmp 0xafa2d
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0xafa86
jmp 0xafa37
movl -0x24(%rbp), %eax
addl $-0x3, %eax
subl $0x2, %eax
jb 0xafa4e
jmp 0xafa44
movl -0x24(%rbp), %eax
subl $0x5, %eax
je 0xafa6a
jmp 0xafaa0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x3ceb3(%rip), %rsi     # 0xec914
movb $0x0, %al
callq 0x4280
jmp 0xafaa0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x3cea1(%rip), %rsi     # 0xec91e
movb $0x0, %al
callq 0x4280
jmp 0xafaa0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x3ce8e(%rip), %rsi     # 0xec927
movb $0x0, %al
callq 0x4280
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_variable_start
void code_variable_start(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 05.06.2006*/
 switch (language){
   case PASCAL_LANGUAGE :fprintf(testcodefile, "var\n");
                         break;
   default              :break;
 };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0x2, %eax
jne 0xb010d
jmp 0xb00f9
movq -0x8(%rbp), %rdi
leaq 0x3c86c(%rip), %rsi     # 0xec970
movb $0x0, %al
callq 0x4280
jmp 0xb010f
jmp 0xb010f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_function_return_classification
void code_function_return_classification(FILE* testcodefile, char* functionname, PROGRAMMING_LANGUAGE_TYPE language, int returnvalue)
{
 /*!Last Changed 18.05.2006*/
 code_indentation(testcodefile);
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "return %d;\n", returnvalue);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "%s := %d;\n", functionname, returnvalue);
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "result = %d;\n", returnvalue);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "%s = %d\n", functionname, returnvalue);
                         break;
 };
if (language == FORTRAN_LANGUAGE)
 {
  code_indentation(testcodefile);
  fprintf(testcodefile, "return\n");
 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaef10
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0xb01c2
movq -0x20(%rbp), %rax
leaq 0x3c47d(%rip), %rcx     # 0xec5d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x3c807(%rip), %rsi     # 0xec975
movb $0x0, %al
callq 0x4280
jmp 0xb01c2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x18(%rbp), %ecx
leaq 0x3c7f8(%rip), %rsi     # 0xec981
movb $0x0, %al
callq 0x4280
jmp 0xb01c2
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x3c7ec(%rip), %rsi     # 0xec98c
movb $0x0, %al
callq 0x4280
jmp 0xb01c2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x18(%rbp), %ecx
leaq 0x3c749(%rip), %rsi     # 0xec904
movb $0x0, %al
callq 0x4280
cmpl $0x5, -0x14(%rbp)
jne 0xb01e3
movq -0x8(%rbp), %rdi
callq 0xaef10
movq -0x8(%rbp), %rdi
leaq 0x3c7be(%rip), %rsi     # 0xec99a
movb $0x0, %al
callq 0x4280
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_function_return_string
void code_function_return_string(FILE* testcodefile, char* functionname, PROGRAMMING_LANGUAGE_TYPE language, char* returnvalue)
{
 /*!Last Changed 07.06.2006*/
 code_indentation(testcodefile);
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "return %s;\n", returnvalue);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "%s := %s;\n", functionname, returnvalue);
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "result = %s;\n", returnvalue);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "%s = %s\n", functionname, returnvalue);
                         break;
 };
if (language == FORTRAN_LANGUAGE)
 {
  code_indentation(testcodefile);
  fprintf(testcodefile, "return\n");
 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaef10
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x5, %rax
ja 0xb0297
movq -0x28(%rbp), %rax
leaq 0x3c3c4(%rip), %rcx     # 0xec5ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x3c762(%rip), %rsi     # 0xec9a2
movb $0x0, %al
callq 0x4280
jmp 0xb0297
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x3c6cb(%rip), %rsi     # 0xec927
movb $0x0, %al
callq 0x4280
jmp 0xb0297
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x3c73a(%rip), %rsi     # 0xec9ae
movb $0x0, %al
callq 0x4280
jmp 0xb0297
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x3c68e(%rip), %rsi     # 0xec91e
movb $0x0, %al
callq 0x4280
cmpl $0x5, -0x14(%rbp)
jne 0xb02b8
movq -0x8(%rbp), %rdi
callq 0xaef10
movq -0x8(%rbp), %rdi
leaq 0x3c6e9(%rip), %rsi     # 0xec99a
movb $0x0, %al
callq 0x4280
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_function_return_regression
void code_function_return_regression(FILE* testcodefile, char* functionname, PROGRAMMING_LANGUAGE_TYPE language, double returnvalue)
{
 /*!Last Changed 29.05.2006*/
 code_indentation(testcodefile);
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "return %.6f;\n", returnvalue);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "%s := %.6f;\n", functionname, returnvalue);
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "result = %.6f;\n", returnvalue);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "%s = %.6f\n", functionname, returnvalue);
                         break;
 };
if (language == FORTRAN_LANGUAGE)
 {
  code_indentation(testcodefile);
  fprintf(testcodefile, "return\n");
 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaef10
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x5, %rax
ja 0xb036c
movq -0x28(%rbp), %rax
leaq 0x3c30b(%rip), %rcx     # 0xec604
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
leaq 0x3c6aa(%rip), %rsi     # 0xec9bc
movb $0x1, %al
callq 0x4280
jmp 0xb036c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
leaq 0x3c69b(%rip), %rsi     # 0xec9ca
movb $0x1, %al
callq 0x4280
jmp 0xb036c
movq -0x8(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
leaq 0x3c68f(%rip), %rsi     # 0xec9d7
movb $0x1, %al
callq 0x4280
jmp 0xb036c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
leaq 0x3c579(%rip), %rsi     # 0xec8de
movb $0x1, %al
callq 0x4280
cmpl $0x5, -0x14(%rbp)
jne 0xb038d
movq -0x8(%rbp), %rdi
callq 0xaef10
movq -0x8(%rbp), %rdi
leaq 0x3c614(%rip), %rsi     # 0xec99a
movb $0x0, %al
callq 0x4280
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_function_end
void code_function_end(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 18.05.2006*/
 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 :
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "end\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 0xb03dd
jmp 0xb03bc
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0xb03f1
jmp 0xb03c6
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0xb03dd
jmp 0xb03d0
movl -0x10(%rbp), %eax
addl $-0x4, %eax
subl $0x2, %eax
jb 0xb0405
jmp 0xb0417
movq -0x8(%rbp), %rdi
leaq 0x3b4bc(%rip), %rsi     # 0xeb8a4
movb $0x0, %al
callq 0x4280
jmp 0xb0417
movq -0x8(%rbp), %rdi
leaq 0x3c5eb(%rip), %rsi     # 0xec9e7
movb $0x0, %al
callq 0x4280
jmp 0xb0417
movq -0x8(%rbp), %rdi
leaq 0x38ced(%rip), %rsi     # 0xe90fd
movb $0x0, %al
callq 0x4280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_array_index
void code_array_index(char* st, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int index)
{
 /*!Last Changed 18.05.2006*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :sprintf(st, "%s[%d]", arrayname, index);
                         break;
   case PASCAL_LANGUAGE :sprintf(st, "%s[%d]", arrayname, index + 1);
                         break;
   case MATLAB_LANGUAGE :
   case FORTRAN_LANGUAGE:sprintf(st, "%s(%d)", arrayname, index + 1);
                         break;
 } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x2, %eax
jb 0xb0464
jmp 0xb0443
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0xb047f
jmp 0xb044d
movl -0x20(%rbp), %eax
subl $0x3, %eax
je 0xb0464
jmp 0xb0457
movl -0x20(%rbp), %eax
addl $-0x4, %eax
subl $0x2, %eax
jb 0xb049d
jmp 0xb04b9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x395a8(%rip), %rsi     # 0xe9a1e
movb $0x0, %al
callq 0x4170
jmp 0xb04b9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
leaq 0x3958a(%rip), %rsi     # 0xe9a1e
movb $0x0, %al
callq 0x4170
jmp 0xb04b9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
leaq 0x3c53b(%rip), %rsi     # 0xec9ed
movb $0x0, %al
callq 0x4170
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_array_index_variable
void code_array_index_variable(char* st, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, char* index)
{
 /*!Last Changed 07.06.2006*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :sprintf(st, "%s[%s]", arrayname, index);
                         break;
   case PASCAL_LANGUAGE :sprintf(st, "%s[%s + 1]", arrayname, index);
                         break;
   case MATLAB_LANGUAGE :
   case FORTRAN_LANGUAGE:sprintf(st, "%s(%s + 1)", arrayname, index);
                         break;
 } 
}

// 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)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
jb 0xb0505
jmp 0xb04e4
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0xb0521
jmp 0xb04ee
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0xb0505
jmp 0xb04f8
movl -0x24(%rbp), %eax
addl $-0x4, %eax
subl $0x2, %eax
jb 0xb053d
jmp 0xb0557
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x3c4dc(%rip), %rsi     # 0xec9f4
movb $0x0, %al
callq 0x4170
jmp 0xb0557
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x3c4c7(%rip), %rsi     # 0xec9fb
movb $0x0, %al
callq 0x4170
jmp 0xb0557
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x3c4b6(%rip), %rsi     # 0xeca06
movb $0x0, %al
callq 0x4170
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_index_variable
void code_2d_array_index_variable(char* st, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, char* index1, char* index2)
{
 /*!Last Changed 07.06.2006*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :sprintf(st, "%s[%s][%s]", arrayname, index1, index2);
                         break;
   case PASCAL_LANGUAGE :sprintf(st, "%s[%s + 1, %s + 1]", arrayname, index1, index2);
                         break;
   case MATLAB_LANGUAGE :
   case FORTRAN_LANGUAGE:sprintf(st, "%s(%s + 1, %s + 1)", arrayname, index1, index2);
                         break;
 } 
}

// 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)
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x2, %eax
jb 0xb05a9
jmp 0xb0588
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0xb05c9
jmp 0xb0592
movl -0x2c(%rbp), %eax
subl $0x3, %eax
je 0xb05a9
jmp 0xb059c
movl -0x2c(%rbp), %eax
addl $-0x4, %eax
subl $0x2, %eax
jb 0xb05e9
jmp 0xb0607
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x3c451(%rip), %rsi     # 0xeca11
movb $0x0, %al
callq 0x4170
jmp 0xb0607
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x3c43c(%rip), %rsi     # 0xeca1c
movb $0x0, %al
callq 0x4170
jmp 0xb0607
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x3c42f(%rip), %rsi     # 0xeca2f
movb $0x0, %al
callq 0x4170
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_3d_array_index_variable
void code_3d_array_index_variable(char* st, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, char* index1, char* index2, char* index3)
{
 /*!Last Changed 08.08.2007*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :sprintf(st, "%s[%s][%s][%s]", arrayname, index1, index2, index3);
                         break;
   case PASCAL_LANGUAGE :sprintf(st, "%s[%s + 1, %s + 1, %s + 1]", arrayname, index1, index2, index3);
                         break;
   case MATLAB_LANGUAGE :
   case FORTRAN_LANGUAGE:sprintf(st, "%s(%s + 1, %s + 1, %s + 1)", arrayname, index1, index2, index3);
                         break;
 } 
}

// 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 %r9, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x2, %eax
jb 0xb065d
jmp 0xb063c
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0xb0681
jmp 0xb0646
movl -0x34(%rbp), %eax
subl $0x3, %eax
je 0xb065d
jmp 0xb0650
movl -0x34(%rbp), %eax
addl $-0x4, %eax
subl $0x2, %eax
jb 0xb06a5
jmp 0xb06c7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq 0x3c3ca(%rip), %rsi     # 0xeca42
movb $0x0, %al
callq 0x4170
jmp 0xb06c7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq 0x3c3b5(%rip), %rsi     # 0xeca51
movb $0x0, %al
callq 0x4170
jmp 0xb06c7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq 0x3c3ac(%rip), %rsi     # 0xeca6c
movb $0x0, %al
callq 0x4170
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_endcase
void code_endcase(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 12.06.2006*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "break;\n");
                         break;
   default              :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 0xb0906
jmp 0xb08fc
movl -0x10(%rbp), %eax
subl $0x3, %eax
jne 0xb091a
jmp 0xb0906
movq -0x8(%rbp), %rdi
leaq 0x3c198(%rip), %rsi     # 0xecaa9
movb $0x0, %al
callq 0x4280
jmp 0xb091c
jmp 0xb091c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_switch
void code_switch(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* expression)
{
 /*!Last Changed 09.06.2006*/
 code_indentation(testcodefile);
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "switch (%s){\n", expression);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "case %s of\n", expression);
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "switch %s\n", expression);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "select case (%s)\n", expression);
                         break;
 }  
 indentation += 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaef10
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0xb09cb
movq -0x20(%rbp), %rax
leaq 0x3bcd0(%rip), %rcx     # 0xec634
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3c135(%rip), %rsi     # 0xecab1
movb $0x0, %al
callq 0x4280
jmp 0xb09cb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3c12b(%rip), %rsi     # 0xecabf
movb $0x0, %al
callq 0x4280
jmp 0xb09cb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3c11f(%rip), %rsi     # 0xecacb
movb $0x0, %al
callq 0x4280
jmp 0xb09cb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3c112(%rip), %rsi     # 0xecad6
movb $0x0, %al
callq 0x4280
movl 0x3317e7(%rip), %eax    # 0x3e21b8
addl $0x2, %eax
movl %eax, 0x3317de(%rip)    # 0x3e21b8
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_endswitch
void code_endswitch(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 09.06.2006*/
 indentation -= 2;
 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, "end select\n");
                         break;
 }  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x3317c3(%rip), %eax    # 0x3e21b8
addl $-0x2, %eax
movl %eax, 0x3317ba(%rip)    # 0x3e21b8
movq -0x8(%rbp), %rdi
callq 0xaef10
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0xb0a76
movq -0x18(%rbp), %rax
leaq 0x3bc2d(%rip), %rcx     # 0xec64c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0x3ae71(%rip), %rsi     # 0xeb8a4
movb $0x0, %al
callq 0x4280
jmp 0xb0a76
movq -0x8(%rbp), %rdi
leaq 0x3bfa0(%rip), %rsi     # 0xec9e7
movb $0x0, %al
callq 0x4280
jmp 0xb0a76
movq -0x8(%rbp), %rdi
leaq 0x386a2(%rip), %rsi     # 0xe90fd
movb $0x0, %al
callq 0x4280
jmp 0xb0a76
movq -0x8(%rbp), %rdi
leaq 0x3c079(%rip), %rsi     # 0xecae8
movb $0x0, %al
callq 0x4280
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_if_core
void code_if_core(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* st)
{
 /*!Last Changed 15.06.2006*/
 code_indentation(testcodefile);
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "if (%s)\n", st);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "if %s then\n", st);
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "if %s,\n", st);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "if (%s) then\n", st);
                         break;
 };
 code_start_block(testcodefile, language);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaef10
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0xb0ceb
movq -0x20(%rbp), %rax
leaq 0x3b9e0(%rip), %rcx     # 0xec664
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3be7f(%rip), %rsi     # 0xecb1b
movb $0x0, %al
callq 0x4280
jmp 0xb0ceb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3be70(%rip), %rsi     # 0xecb24
movb $0x0, %al
callq 0x4280
jmp 0xb0ceb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3be64(%rip), %rsi     # 0xecb30
movb $0x0, %al
callq 0x4280
jmp 0xb0ceb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3be54(%rip), %rsi     # 0xecb38
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaef60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_while_core
void code_while_core(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* st)
{
 /*!Last Changed 15.06.2006*/
 code_indentation(testcodefile);
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :
   case MATLAB_LANGUAGE :fprintf(testcodefile, "while (%s)\n", st);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "while %s do\n", st);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "while (%s) do\n", st);
                         break;
 };
 code_start_block(testcodefile, language);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaef10
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x2, %eax
jb 0xb0daa
jmp 0xb0d89
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xb0dc2
jmp 0xb0d93
movl -0x1c(%rbp), %eax
addl $-0x3, %eax
subl $0x2, %eax
jb 0xb0daa
jmp 0xb0da0
movl -0x1c(%rbp), %eax
subl $0x5, %eax
je 0xb0dda
jmp 0xb0df0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3bd8d(%rip), %rsi     # 0xecb46
movb $0x0, %al
callq 0x4280
jmp 0xb0df0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3bd81(%rip), %rsi     # 0xecb52
movb $0x0, %al
callq 0x4280
jmp 0xb0df0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3bd76(%rip), %rsi     # 0xecb5f
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaef60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_else
void code_else(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 02.06.2006*/
 code_end_block(testcodefile, language);
 code_indentation(testcodefile);
 fprintf(testcodefile, "else\n");
 code_start_block(testcodefile, language);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaf020
movq -0x8(%rbp), %rdi
callq 0xaef10
movq -0x8(%rbp), %rdi
leaq 0x3bccf(%rip), %rsi     # 0xecb6e
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaef60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_endif
void code_endif(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 02.06.2006*/
 indentation--;
 if (in_list(language, 2, MATLAB_LANGUAGE, FORTRAN_LANGUAGE))
   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, "endif\n");
                         break;
 }; 
 if (!in_list(language, 2, MATLAB_LANGUAGE, FORTRAN_LANGUAGE))
   indentation--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x3312e3(%rip), %eax    # 0x3e21b8
addl $-0x1, %eax
movl %eax, 0x3312da(%rip)    # 0x3e21b8
movl -0xc(%rbp), %edi
movl $0x2, %esi
movl $0x4, %edx
movl $0x5, %ecx
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0xb0f0b
movl 0x3312b6(%rip), %eax    # 0x3e21b8
addl $-0x1, %eax
movl %eax, 0x3312ad(%rip)    # 0x3e21b8
movq -0x8(%rbp), %rdi
callq 0xaef10
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0xb0f83
movq -0x18(%rbp), %rax
leaq 0x3b750(%rip), %rcx     # 0xec67c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0x3a964(%rip), %rsi     # 0xeb8a4
movb $0x0, %al
callq 0x4280
jmp 0xb0f83
movq -0x8(%rbp), %rdi
leaq 0x3ba93(%rip), %rsi     # 0xec9e7
movb $0x0, %al
callq 0x4280
jmp 0xb0f83
movq -0x8(%rbp), %rdi
leaq 0x38195(%rip), %rsi     # 0xe90fd
movb $0x0, %al
callq 0x4280
jmp 0xb0f83
movq -0x8(%rbp), %rdi
leaq 0x3bbf8(%rip), %rsi     # 0xecb74
movb $0x0, %al
callq 0x4280
movl -0xc(%rbp), %edi
movl $0x2, %esi
movl $0x4, %edx
movl $0x5, %ecx
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
jne 0xb0fb0
movl 0x331211(%rip), %eax    # 0x3e21b8
addl $-0x1, %eax
movl %eax, 0x331208(%rip)    # 0x3e21b8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_endwhile
void code_endwhile(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 15.06.2006*/
 indentation--;
 if (in_list(language, 2, MATLAB_LANGUAGE, FORTRAN_LANGUAGE))
   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 :
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "end\n");
                         break;
 }; 
 if (!in_list(language, 2, MATLAB_LANGUAGE, FORTRAN_LANGUAGE))
   indentation--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x3311e3(%rip), %eax    # 0x3e21b8
addl $-0x1, %eax
movl %eax, 0x3311da(%rip)    # 0x3e21b8
movl -0xc(%rbp), %edi
movl $0x2, %esi
movl $0x4, %edx
movl $0x5, %ecx
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0xb100b
movl 0x3311b6(%rip), %eax    # 0x3e21b8
addl $-0x1, %eax
movl %eax, 0x3311ad(%rip)    # 0x3e21b8
movq -0x8(%rbp), %rdi
callq 0xaef10
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x2, %eax
jb 0xb1042
jmp 0xb1021
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0xb1056
jmp 0xb102b
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0xb1042
jmp 0xb1035
movl -0x10(%rbp), %eax
addl $-0x4, %eax
subl $0x2, %eax
jb 0xb106a
jmp 0xb107c
movq -0x8(%rbp), %rdi
leaq 0x3a857(%rip), %rsi     # 0xeb8a4
movb $0x0, %al
callq 0x4280
jmp 0xb107c
movq -0x8(%rbp), %rdi
leaq 0x3b986(%rip), %rsi     # 0xec9e7
movb $0x0, %al
callq 0x4280
jmp 0xb107c
movq -0x8(%rbp), %rdi
leaq 0x38088(%rip), %rsi     # 0xe90fd
movb $0x0, %al
callq 0x4280
movl -0xc(%rbp), %edi
movl $0x2, %esi
movl $0x4, %edx
movl $0x5, %ecx
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
jne 0xb10a9
movl 0x331118(%rip), %eax    # 0x3e21b8
addl $-0x1, %eax
movl %eax, 0x33110f(%rip)    # 0x3e21b8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/savecode.c
// Function: code_for_with_string
void code_for_with_string(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* variable, char* start, char* end, char* difference)
{
 /*!Last Changed 25.06.2006*/
 code_indentation(testcodefile);
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "for (%s = %s; %s <= %s; %s += %s)\n", variable, start, variable, end, variable, difference);                             
                         break;
   case PASCAL_LANGUAGE :if (atoi(difference) > 0)
                           fprintf(testcodefile, "for %s := %s to %s do\n", variable, start, end);
                         else
                           fprintf(testcodefile, "for %s := %s downto %s do\n", variable, start, end);
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "for %s = %s:%s:%s,\n", variable, start, difference, end);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "do %s = %s, %s, %s\n", variable, start, end, difference);
                         break;
 };  
 code_start_block(testcodefile, language);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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
callq 0xaef10
movl -0xc(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x5, %rax
ja 0xb1399
movq -0x38(%rbp), %rax
leaq 0x3b3e8(%rip), %rcx     # 0xec6ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x18(%rbp), %r10
movq -0x30(%rbp), %rax
leaq 0x3b965(%rip), %rsi     # 0xecc55
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x4280
jmp 0xb1399
movq -0x30(%rbp), %rdi
callq 0x41c0
cmpl $0x0, %eax
jle 0xb1333
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x3b94e(%rip), %rsi     # 0xecc78
movb $0x0, %al
callq 0x4280
jmp 0xb1351
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x3b945(%rip), %rsi     # 0xecc8f
movb $0x0, %al
callq 0x4280
jmp 0xb1399
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x28(%rbp), %r9
leaq 0x3b93c(%rip), %rsi     # 0xeccaa
movb $0x0, %al
callq 0x4280
jmp 0xb1399
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq 0x3b92c(%rip), %rsi     # 0xeccbe
movb $0x0, %al
callq 0x4280
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xaef60
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)