LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %r12d
movq %rdi, %r15
movl %esi, (%rsp)
movl %r8d, 0x4(%rsp)
movl %r8d, %edx
callq 0x7ceaa
movl %eax, %r13d
movsd (%r14), %xmm0
leaq 0x3323b(%rip), %rsi     # 0xb024a
movq %r15, %rdi
movb $0x1, %al
callq 0x42e0
cmpl $0x2, %r12d
jl 0x7d050
movzbl %r13b, %r13d
movl %r12d, %ebx
movl $0x1, %ebp
leaq 0x33216(%rip), %r12     # 0xb0248
movsd (%r14,%rbp,8), %xmm0
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
movb $0x1, %al
callq 0x42e0
incq %rbp
cmpq %rbp, %rbx
jne 0x7d032
movq %r15, %rdi
movl (%rsp), %esi
movl 0x4(%rsp), %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7cf51
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_constant_instance
void code_constant_instance(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 09.06.2006*/
 int i;
 char ch;
 ch = code_1d_array_start(testcodefile, language, index);
 switch (d->features[0].type){
   case REAL    :
			case REGDEF  :fprintf(testcodefile, "%.6f", tmp->values[0].floatvalue);
                 break;
   case INTEGER :fprintf(testcodefile, "%d", tmp->values[0].intvalue);
                 break;
   case CLASSDEF:fprintf(testcodefile, "%d", tmp->values[0].stringindex);
                 break;
 }   
 for (i = 1; i < d->featurecount; i++)
   switch (d->features[i].type){
     case REAL    :
					case REGDEF  :fprintf(testcodefile, "%c%.6f", ch, tmp->values[i].floatvalue);
                   break;
     case INTEGER :fprintf(testcodefile, "%c%d", ch, tmp->values[i].intvalue);
                   break;
     case CLASSDEF:fprintf(testcodefile, "%c%d", ch, tmp->values[i].stringindex);
                   break;
   }      
	code_1d_array_end(testcodefile, language, index);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rdi, %r12
movl %esi, 0x10(%rsp)
movl %r8d, 0x14(%rsp)
movl %r8d, %edx
callq 0x7ceaa
movl %eax, %ebx
movl 0x30f08(%r15), %eax
cmpq $0x4, %rax
ja 0x7d0f0
leaq 0x32dd7(%rip), %rcx     # 0xafe84
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl (%rax), %edx
leaq 0x33b2e(%rip), %rsi     # 0xb0bf5
movq %r12, %rdi
xorl %eax, %eax
callq 0x42e0
jmp 0x7d0f0
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
leaq 0x33164(%rip), %rsi     # 0xb024a
movq %r12, %rdi
movb $0x1, %al
callq 0x42e0
cmpl $0x2, 0x1bc(%r15)
jl 0x7d17e
movzbl %bl, %r13d
leaq 0x31248(%r15), %rbx
movl $0x1, %ebp
leaq 0x32d83(%rip), %r14     # 0xafe98
movl (%rbx), %eax
cmpq $0x4, %rax
ja 0x7d168
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl (%rax,%rbp,8), %ecx
movq %r12, %rdi
leaq 0x33114(%rip), %rsi     # 0xb024f
movl %r13d, %edx
xorl %eax, %eax
callq 0x42e0
jmp 0x7d168
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r12, %rdi
leaq 0x330ea(%rip), %rsi     # 0xb0248
movl %r13d, %edx
movb $0x1, %al
callq 0x42e0
incq %rbp
movslq 0x1bc(%r15), %rax
addq $0x340, %rbx            # imm = 0x340
cmpq %rax, %rbp
jl 0x7d115
movq %r12, %rdi
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7cf51
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movl %ecx, %edx
callq 0x7ceaa
movl %eax, %r12d
movsd 0x8(%r15), %xmm0
leaq 0x33082(%rip), %rsi     # 0xb024a
movq %r14, %rdi
movb $0x1, %al
callq 0x42e0
cmpl $-0x1, 0x10(%r15)
je 0x7d208
movzbl %r12b, %r12d
addq $0x20, %r15
leaq 0x33060(%rip), %r13     # 0xb0248
movsd -0x8(%r15), %xmm0
movq %r14, %rdi
movq %r13, %rsi
movl %r12d, %edx
movb $0x1, %al
callq 0x42e0
cmpl $-0x1, (%r15)
leaq 0x10(%r15), %r15
jne 0x7d1e8
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7cf51
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movl %esi, (%rsp)
movl %r8d, 0x4(%rsp)
movl %r8d, %edx
callq 0x7ceaa
movl %eax, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2ed6a
leaq 0x32ff1(%rip), %rsi     # 0xb024a
movq %r12, %rdi
movb $0x1, %al
callq 0x42e0
cmpl $0x3, 0x1c0(%r15)
jl 0x7d2a6
movzbl %bl, %r13d
movl $0x1, %ebx
leaq 0x32fcb(%rip), %rbp     # 0xb0248
movq %r14, %rdi
movl %ebx, %esi
callq 0x2ed6a
movq %r12, %rdi
movq %rbp, %rsi
movl %r13d, %edx
movb $0x1, %al
callq 0x42e0
incl %ebx
movl 0x1c0(%r15), %eax
decl %eax
cmpl %eax, %ebx
jl 0x7d27d
movq %r12, %rdi
movl (%rsp), %esi
movl 0x4(%rsp), %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7cf51
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
cmpl $0x0, 0x334eb8(%rip)    # 0x3b21e8
jle 0x7d34e
xorl %r12d, %r12d
movl $0x20, %edi
movq %r15, %rsi
callq 0x4150
incl %r12d
cmpl 0x334e9c(%rip), %r12d   # 0x3b21e8
jl 0x7d335
cmpl $0x5, %ebp
ja 0x7d37b
movl %ebp, %eax
leaq 0x32d18(%rip), %rcx     # 0xb0074
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x42e0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x3349bb(%rip)    # 0x3b21e8
jle 0x7d84b
xorl %r12d, %r12d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r12d
cmpl 0x33499f(%rip), %r12d   # 0x3b21e8
jl 0x7d832
cmpl $0x5, %r15d
ja 0x7d8ee
movl %r15d, %eax
leaq 0x3264d(%rip), %rcx     # 0xafeac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x32a96(%rip), %rsi     # 0xb0305
jmp 0x7d8fe
leaq 0x32a96(%rip), %rsi     # 0xb0311
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x42e0
leaq 0x329fb(%rip), %rsi     # 0xb0294
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x334936(%rip)    # 0x3b21e8
jle 0x7d8cd
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r15d
cmpl 0x33491d(%rip), %r15d   # 0x3b21e8
jl 0x7d8b4
leaq 0x32a56(%rip), %rdi     # 0xb032a
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x42c0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x32a1e(%rip), %rsi     # 0xb031c
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x0, 0x3348bc(%rip)    # 0x3b21e8
jle 0x7d94a
xorl %r12d, %r12d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r12d
cmpl 0x3348a0(%rip), %r12d   # 0x3b21e8
jl 0x7d931
cmpl $0x5, %ebp
ja 0x7d9ea
movl %ebp, %eax
leaq 0x32568(%rip), %rcx     # 0xafec4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x329c6(%rip), %rsi     # 0xb0332
jmp 0x7d9fa
leaq 0x3293f(%rip), %rsi     # 0xb02b7
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x42e0
leaq 0x32917(%rip), %rsi     # 0xb02ae
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x42e0
cmpl $0x0, 0x334838(%rip)    # 0x3b21e8
jle 0x7d9c9
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %ebp
cmpl 0x334821(%rip), %ebp    # 0x3b21e8
jl 0x7d9b2
leaq 0x3295a(%rip), %rdi     # 0xb032a
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x42c0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x32944(%rip), %rsi     # 0xb033e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x3347be(%rip)    # 0x3b21e8
jle 0x7da48
xorl %r15d, %r15d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r15d
cmpl 0x3347a2(%rip), %r15d   # 0x3b21e8
jl 0x7da2f
cmpl $0x5, %ebp
ja 0x7daf0
movl %ebp, %eax
leaq 0x32482(%rip), %rcx     # 0xafedc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x328e2(%rip), %rsi     # 0xb034c
jmp 0x7db02
leaq 0x328e4(%rip), %rsi     # 0xb035a
movq %rbx, %rdi
movq %r14, %rdx
movsd (%rsp), %xmm0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x42e0
leaq 0x327d5(%rip), %rsi     # 0xb026e
movq %rbx, %rdi
movq %r14, %rdx
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x42e0
cmpl $0x0, 0x334736(%rip)    # 0x3b21e8
jle 0x7dacd
xorl %ebp, %ebp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %ebp
cmpl 0x33471d(%rip), %ebp    # 0x3b21e8
jl 0x7dab6
leaq 0x32856(%rip), %rdi     # 0xb032a
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x42c0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x32865(%rip), %rsi     # 0xb0367
movq %rbx, %rdi
movsd (%rsp), %xmm0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x5, %esi
ja 0x7db69
movq %rdi, %rcx
movl $0xb, %eax
btl %esi, %eax
jae 0x7db3b
leaq 0x31660(%rip), %rdi     # 0xaf194
movl $0x2, %esi
jmp 0x7db5f
movl $0x30, %eax
btl %esi, %eax
jae 0x7db53
leaq 0x2ea44(%rip), %rdi     # 0xac590
movl $0x4, %esi
jmp 0x7db5f
leaq 0x3281d(%rip), %rdi     # 0xb0377
movl $0x5, %esi
movl $0x1, %edx
jmp 0x42c0
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x0, 0x334390(%rip)    # 0x3b21e8
jle 0x7de76
xorl %r15d, %r15d
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %r15d
cmpl 0x334374(%rip), %r15d   # 0x3b21e8
jl 0x7de5d
cmpl $0x5, %ebp
ja 0x7de98
movl %ebp, %eax
leaq 0x32208(%rip), %rcx     # 0xb008c
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x42e0
addl $0x2, 0x334349(%rip)    # 0x3b21e8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl 0x33432f(%rip), %eax    # 0x3b21e8
leal -0x2(%rax), %ecx
movl %ecx, 0x334326(%rip)    # 0x3b21e8
cmpl $0x3, %eax
jl 0x7dee3
xorl %r14d, %r14d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r14d
cmpl 0x334307(%rip), %r14d   # 0x3b21e8
jl 0x7deca
cmpl $0x5, %ebp
ja 0x7df24
movl %ebp, %eax
leaq 0x3201b(%rip), %rcx     # 0xaff0c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x31293(%rip), %rdi     # 0xaf194
movl $0x2, %esi
jmp 0x7df35
leaq 0x32468(%rip), %rdi     # 0xb0377
movl $0x5, %esi
jmp 0x7df35
leaq 0x3255b(%rip), %rdi     # 0xb0478
movl $0xb, %esi
jmp 0x7df35
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2e660(%rip), %rdi     # 0xac590
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x42c0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, 0x33413f(%rip)    # 0x3b21e8
jle 0x7e0c4
xorl %ebp, %ebp
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %ebp
cmpl 0x334126(%rip), %ebp    # 0x3b21e8
jl 0x7e0ad
cmpl $0x5, %ebx
ja 0x7e0e6
movl %ebx, %eax
leaq 0x31fd2(%rip), %rcx     # 0xb00a4
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x42e0
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7cca3
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, 0x334097(%rip)    # 0x3b21e8
jle 0x7e16c
xorl %ebp, %ebp
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %ebp
cmpl 0x33407e(%rip), %ebp    # 0x3b21e8
jl 0x7e155
cmpl $0x5, %ebx
ja 0x7e18e
movl %ebx, %eax
leaq 0x31f42(%rip), %rcx     # 0xb00bc
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x42e0
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7cca3
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x7cd3a
cmpl $0x0, 0x333ff0(%rip)    # 0x3b21e8
jle 0x7e213
xorl %ebp, %ebp
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %ebp
cmpl 0x333fd7(%rip), %ebp    # 0x3b21e8
jl 0x7e1fc
leaq 0x322e4(%rip), %rdi     # 0xb04fe
movl $0x5, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x7cca3
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
decl 0x333f9f(%rip)          # 0x3b21e8
movl %esi, %edi
movl $0x2, %esi
movl $0x4, %edx
movl $0x5, %ecx
xorl %eax, %eax
callq 0x3aa8c
movl 0x333f81(%rip), %ecx    # 0x3b21e8
testl %eax, %eax
je 0x7e273
decl %ecx
movl %ecx, 0x333f75(%rip)    # 0x3b21e8
testl %ecx, %ecx
jle 0x7e290
xorl %ebp, %ebp
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %ebp
cmpl 0x333f5a(%rip), %ebp    # 0x3b21e8
jl 0x7e279
cmpl $0x5, %ebx
ja 0x7e2ea
movl %ebx, %eax
leaq 0x31c86(%rip), %rcx     # 0xaff24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x30ee6(%rip), %rdi     # 0xaf194
movl $0x2, %esi
jmp 0x7e2dd
leaq 0x320bb(%rip), %rdi     # 0xb0377
movl $0x5, %esi
jmp 0x7e2dd
leaq 0x3223a(%rip), %rdi     # 0xb0504
movl $0x6, %esi
jmp 0x7e2dd
leaq 0x2e2b8(%rip), %rdi     # 0xac590
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
movl %ebx, %edi
movl $0x2, %esi
movl $0x4, %edx
movl $0x5, %ecx
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
jne 0x7e30c
decl 0x333edc(%rip)          # 0x3b21e8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
decl 0x333ec8(%rip)          # 0x3b21e8
movl %esi, %edi
movl $0x2, %esi
movl $0x4, %edx
movl $0x5, %ecx
xorl %eax, %eax
callq 0x3aa8c
movl 0x333eaa(%rip), %ecx    # 0x3b21e8
testl %eax, %eax
je 0x7e34a
decl %ecx
movl %ecx, 0x333e9e(%rip)    # 0x3b21e8
testl %ecx, %ecx
jle 0x7e367
xorl %ebp, %ebp
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %ebp
cmpl 0x333e83(%rip), %ebp    # 0x3b21e8
jl 0x7e350
cmpl $0x5, %ebx
ja 0x7e3b5
movl $0xb, %eax
btl %ebx, %eax
jae 0x7e384
leaq 0x30e17(%rip), %rdi     # 0xaf194
movl $0x2, %esi
jmp 0x7e3a8
movl $0x30, %eax
btl %ebx, %eax
jae 0x7e39c
leaq 0x2e1fb(%rip), %rdi     # 0xac590
movl $0x4, %esi
jmp 0x7e3a8
leaq 0x31fd4(%rip), %rdi     # 0xb0377
movl $0x5, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
movl %ebx, %edi
movl $0x2, %esi
movl $0x4, %edx
movl $0x5, %ecx
xorl %eax, %eax
callq 0x3aa8c
testl %eax, %eax
jne 0x7e3d7
decl 0x333e11(%rip)          # 0x3b21e8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbp
movq %r8, (%rsp)
movq %rcx, %r13
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, 0x333c98(%rip)    # 0x3b21e8
jle 0x7e56e
xorl %r15d, %r15d
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %r15d
cmpl 0x333c7c(%rip), %r15d   # 0x3b21e8
jl 0x7e555
cmpl $0x5, %ebx
ja 0x7e619
movl %ebx, %eax
leaq 0x319d4(%rip), %rcx     # 0xaff54
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x32055(%rip), %rsi     # 0xb05e5
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %r12, %r8
movq (%rsp), %r9
xorl %eax, %eax
pushq %rbp
pushq %r12
callq 0x42e0
addq $0x10, %rsp
jmp 0x7e619
movq %rbp, %rdi
callq 0x4200
testl %eax, %eax
jle 0x7e5fe
leaq 0x32045(%rip), %rsi     # 0xb0608
jmp 0x7e605
leaq 0x32082(%rip), %rsi     # 0xb064e
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq (%rsp), %r8
movq %rbp, %r9
jmp 0x7e5f5
leaq 0x32055(%rip), %rsi     # 0xb063a
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
movq (%rsp), %r9
xorl %eax, %eax
callq 0x42e0
jmp 0x7e619
leaq 0x3201a(%rip), %rsi     # 0xb061f
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x42e0
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7cca3
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_break
void code_break(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 13.06.2006*/
 code_indentation(testcodefile);
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :
   case PASCAL_LANGUAGE :
   case MATLAB_LANGUAGE :
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "break;\n");
                         break;
 };  
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x0, 0x333ba7(%rip)    # 0x3b21e8
jle 0x7e65f
xorl %r14d, %r14d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r14d
cmpl 0x333b8b(%rip), %r14d   # 0x3b21e8
jl 0x7e646
cmpl $0x5, %ebp
ja 0x7e681
leaq 0x31dce(%rip), %rdi     # 0xb0439
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x42c0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl 0x333b53(%rip), %eax    # 0x3b21e8
leal -0x1(%rax), %ecx
movl %ecx, 0x333b4a(%rip)    # 0x3b21e8
cmpl $0x2, %eax
jl 0x7e6bf
xorl %r14d, %r14d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r14d
cmpl 0x333b2b(%rip), %r14d   # 0x3b21e8
jl 0x7e6a6
cmpl $0x5, %ebp
ja 0x7e719
movl %ebp, %eax
leaq 0x3189f(%rip), %rcx     # 0xaff6c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x30ab7(%rip), %rdi     # 0xaf194
movl $0x2, %esi
jmp 0x7e70c
leaq 0x31c8c(%rip), %rdi     # 0xb0377
movl $0x5, %esi
jmp 0x7e70c
leaq 0x31f69(%rip), %rdi     # 0xb0662
movl $0x6, %esi
jmp 0x7e70c
leaq 0x2de89(%rip), %rdi     # 0xac590
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
decl 0x333ac9(%rip)          # 0x3b21e8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_1d_array_constant_instance
void code_1d_array_constant_instance(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, char* arrayname, int size, Instanceptr values)
{
 /*!Last Changed 19.10.2007 updated Java*/
	/*!Last Changed 27.06.2006*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :fprintf(testcodefile, "const double %s[%d] = ", arrayname, size);
                         break;
   case JAVA_LANGUAGE   :fprintf(testcodefile, "final double[] %s = ", arrayname);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "%s: array[1..%d] of real = ", arrayname, size);
																									break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "%s = ", arrayname);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "real %s(%d) = ", arrayname, size);
																									break;
 };  
 if (size == d->featurecount)   
   code_constant_instance(testcodefile, language, d, values, -1);
 else
   if (size == d->multifeaturecount - 1)
     code_constant_instance_realized(testcodefile, language, d, values, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movl %r8d, %r12d
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
cmpl $0x5, %esi
ja 0x7e799
movl %ebp, %eax
leaq 0x3183c(%rip), %rdx     # 0xaff84
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq 0x31f11(%rip), %rsi     # 0xb0669
jmp 0x7e773
leaq 0x31f1f(%rip), %rsi     # 0xb0680
jmp 0x7e78c
leaq 0x31f2b(%rip), %rsi     # 0xb0695
jmp 0x7e773
leaq 0x31f3e(%rip), %rsi     # 0xb06b1
movq %r15, %rdi
movq %rcx, %rdx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x42e0
jmp 0x7e799
leaq 0x31f03(%rip), %rsi     # 0xb068f
movq %r15, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x42e0
cmpl %r12d, 0x1bc(%r14)
jne 0x7e7c0
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7d06d
movl 0x1c0(%r14), %eax
decl %eax
cmpl %r12d, %eax
jne 0x7e7ec
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7d222
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_constant
void code_2d_array_constant(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2, double** values)
{
 /*!Last Changed 12.06.2006*/
 int i;
 code_2d_array_start(testcodefile, language, arrayname, size1, size2);
 for (i = 0; i < size1; i++)
   code_constant_subarray(testcodefile, language, size2, values[i], i);
 code_2d_array_end(testcodefile, language); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movl %r8d, %r15d
movl %ecx, %r12d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x7eac9
testl %r12d, %r12d
jle 0x7ea88
movl %r12d, %r13d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rcx
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
movl %r12d, %r8d
callq 0x7cfdc
incq %r12
cmpq %r12, %r13
jne 0x7ea6c
cmpl $0x5, %ebp
ja 0x7eaba
movl %ebp, %eax
leaq 0x551ca(%rip), %rcx     # 0xd3c60
movq (%rcx,%rax,8), %rdi
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_start
void code_2d_array_start(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2)
{
 /*!Last Changed 19.10.2007 updated Java, C, C++*/
 /*!Last Changed 05.06.2006*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :fprintf(testcodefile, "const double %s[%d][%d] = {", arrayname, size1, size2);
                         break;
   case JAVA_LANGUAGE   :fprintf(testcodefile, "final double[][] %s = {", arrayname);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "%s: array[1..%d][1..%d] of real = (", arrayname, size1, size2);
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "%s = [", arrayname);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "real %s(%d, %d) = (", arrayname, size1, size2);
                         break;
 };  
}

// Assembly:
cmpl $0x5, %esi
ja 0x7eb09
movl %esi, %eax
leaq 0x314f5(%rip), %rsi     # 0xaffcc
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
leaq 0x31cb3(%rip), %rsi     # 0xb079a
jmp 0x7eb02
leaq 0x31cc6(%rip), %rsi     # 0xb07b6
jmp 0x7eb11
leaq 0x31cd5(%rip), %rsi     # 0xb07ce
jmp 0x7eb02
leaq 0x31cf0(%rip), %rsi     # 0xb07f2
xorl %eax, %eax
jmp 0x42e0
retq
leaq 0x31c42(%rip), %rsi     # 0xb0753
xorl %eax, %eax
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_constant_matrix
void code_2d_array_constant_matrix(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2, matrixptr matrixarray)
{
 /*!Last Changed 08.08.2007*/
 int i;
 code_2d_array_start(testcodefile, language, arrayname, size1, size2);
 for (i = 0; i < size1; i++)
   code_constant_subarray(testcodefile, language, size2, matrixarray[i].values[0], i);
 code_2d_array_end(testcodefile, language); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movl %r8d, %r15d
movl %ecx, %r12d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x7eac9
testl %r12d, %r12d
jle 0x7eb8c
movl %r12d, %r13d
addq $0x8, %r14
xorl %r12d, %r12d
movq (%r14), %rax
movq (%rax), %rcx
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
movl %r12d, %r8d
callq 0x7cfdc
incq %r12
addq $0x10, %r14
cmpq %r12, %r13
jne 0x7eb6a
cmpl $0x5, %ebp
ja 0x7ebbe
movl %ebp, %eax
leaq 0x550c6(%rip), %rcx     # 0xd3c60
movq (%rcx,%rax,8), %rdi
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_constant_instance
void code_2d_array_constant_instance(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, char* arrayname, int size1, int size2, Instanceptr values)
{
 /*!Last Changed 09.06.2006*/
 int i;
 Instanceptr tmp = values;
 code_2d_array_start(testcodefile, language, arrayname, size1, size2);
 i = 0;
 while (tmp)
  {
   if (size2 == d->featurecount)   
     code_constant_instance(testcodefile, language, d, tmp, i);
   else
     if (size2 == d->multifeaturecount - 1)
       code_constant_instance_realized(testcodefile, language, d, tmp, i);
   i++;
   tmp = tmp->next;
  }
 code_2d_array_end(testcodefile, language); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r14d
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq 0x40(%rsp), %r12
movq %rcx, %rdx
movl %r8d, %ecx
movl %r9d, %r8d
callq 0x7eac9
testq %r12, %r12
je 0x7ec4a
xorl %r13d, %r13d
cmpl %r14d, 0x1bc(%r15)
jne 0x7ec1c
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r12, %rcx
movl %r13d, %r8d
callq 0x7d06d
jmp 0x7ec3d
movl 0x1c0(%r15), %eax
decl %eax
cmpl %r14d, %eax
jne 0x7ec3d
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r12, %rcx
movl %r13d, %r8d
callq 0x7d222
incl %r13d
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x7ebfe
cmpl $0x5, %ebp
ja 0x7ec7c
movl %ebp, %eax
leaq 0x55008(%rip), %rcx     # 0xd3c60
movq (%rcx,%rax,8), %rdi
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_constant_sv
void code_2d_array_constant_sv(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2, Svm_nodeptr* values)
{
 /*!Last Changed 24.06.2006*/
 int i;
 code_2d_array_start(testcodefile, language, arrayname, size1, size2);
	for (i = 0; i < size1; i++)
   code_constant_sv(testcodefile, language, values[i], i);
 code_2d_array_end(testcodefile, language); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r14
movl %ecx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x7eac9
testl %r15d, %r15d
jle 0x7ecc7
movl %r15d, %r12d
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdx
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %ecx
callq 0x7d19c
incq %r15
cmpq %r15, %r12
jne 0x7ecae
cmpl $0x5, %ebp
ja 0x7ecf3
movl %ebp, %eax
leaq 0x54f8b(%rip), %rcx     # 0xd3c60
movq (%rcx,%rax,8), %rdi
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x42c0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_3d_array_constant_matrix
void code_3d_array_constant_matrix(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2, int size3, matrixptr matrixarray)
{
 /*!Last Changed 08.08.2007*/
 int i, j;
 code_3d_array_start(testcodefile, language, arrayname, size1, size2, size3);
 for (i = 0; i < size1; i++)
  {
   code_1d_array_start(testcodefile, language, i);
   for (j = 0; j < size2; j++)
     code_constant_subarray(testcodefile, language, size2, matrixarray[i].values[j], j);
   code_1d_array_end(testcodefile, language, i);
  }
 code_3d_array_end(testcodefile, language); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r12d
movl %esi, %ebp
movq %rdi, %rbx
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
callq 0x7eddd
testl %r12d, %r12d
jle 0x7ed9c
movl 0x4(%rsp), %r15d
movl %r12d, %eax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x7ceaa
cmpl $0x0, 0x4(%rsp)
jle 0x7ed85
movq %r12, %rax
shlq $0x4, %rax
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax), %r14
addq $0x8, %r14
xorl %r13d, %r13d
movq (%r14), %rax
movq (%rax,%r13,8), %rcx
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
movl %r13d, %r8d
callq 0x7cfdc
incq %r13
cmpq %r13, %r15
jne 0x7ed66
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x7cf51
incq %r12
cmpq 0x10(%rsp), %r12
jne 0x7ed3b
cmpl $0x5, %ebp
ja 0x7edce
movl %ebp, %eax
leaq 0x54eb6(%rip), %rcx     # 0xd3c60
movq (%rcx,%rax,8), %rdi
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_3d_array_start
void code_3d_array_start(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2, int size3)
{
 /*!Last Changed 19.10.2007 updated C, C++, Java*/
 /*!Last Changed 08.08.2007*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :fprintf(testcodefile, "const double %s[%d][%d][%d] = {", arrayname, size1, size2, size3);
                         break;
   case JAVA_LANGUAGE   :fprintf(testcodefile, "const double [][][] %s = {", arrayname);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "%s: array[1..%d][1..%d][1..%d] of real = (", arrayname, size1, size2, size3);
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "%s = [", arrayname);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "real %s(%d, %d, %d) = (", arrayname, size1, size2, size3);
                         break;
 };  
}

// Assembly:
cmpl $0x5, %esi
ja 0x7ee1d
movl %esi, %eax
leaq 0x311f9(%rip), %rsi     # 0xaffe4
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
leaq 0x31a0b(%rip), %rsi     # 0xb0806
jmp 0x7ee16
leaq 0x31a22(%rip), %rsi     # 0xb0826
jmp 0x7ee25
leaq 0x31a34(%rip), %rsi     # 0xb0841
jmp 0x7ee16
leaq 0x31a56(%rip), %rsi     # 0xb086c
xorl %eax, %eax
jmp 0x42e0
retq
leaq 0x3192e(%rip), %rsi     # 0xb0753
xorl %eax, %eax
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %r8, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rcx), %r8d
leaq 0x31e44(%rip), %rdx     # 0xb0cb9
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x7e3dc
cmpl $0x5, %ebx
ja 0x7eea8
movl %ebx, %eax
leaq 0x54ef0(%rip), %rcx     # 0xd3d80
movq (%rcx,%rax,8), %rsi
leaq 0x31e1e(%rip), %rcx     # 0xb0cb9
movq %rsp, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x41b0
movq %rsp, %rdx
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rcx
callq 0x7d316
movq %r14, %rdi
movl %ebx, %esi
callq 0x7e686
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/savecode.c
// Function: code_rule
void code_rule(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, char* algorithm, Decisionruleptr rule)
{
 /*!Last Changed 15.06.2006*/
 char st[MAXLENGTH], st2[MAXLENGTH];
 Decisionconditionptr condition;
 condition = rule->start;
 code_condition(language, d, condition, st);
 condition = condition->next;
 strcpy(st2, st);
 while (condition)
  {
   code_condition(language, d, condition, st);
   switch (language){
     case C_LANGUAGE      :
     case CPP_LANGUAGE    :
     case JAVA_LANGUAGE   :sprintf(st2, "%s && %s", st2, st);
                           break;
     case PASCAL_LANGUAGE :sprintf(st2, "%s and %s", st2, st);
                           break;
     case FORTRAN_LANGUAGE:sprintf(st2, "%s .AND. %s", st2, st);
                           break;
     case MATLAB_LANGUAGE :sprintf(st2, "%s & %s", st2, st);
                           break;
   }
   condition = condition->next;
  }
 code_if_core(testcodefile, language, st2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf4258, %rsp          # imm = 0xF4258
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, 0x8(%rsp)
movq 0x18(%r8), %r12
leaq 0x7a130(%rsp), %r13
movl %esi, %edi
movq %rdx, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7fba8
movq 0x48(%r12), %r12
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x4270
testq %r12, %r12
je 0x7fe87
movl %ebx, %r14d
shlq $0x2, %r14
leaq 0x7a130(%rsp), %r13
leaq 0x10(%rsp), %rbp
movl %ebx, %edi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7fba8
cmpl $0x5, %ebx
ja 0x7fe7d
leaq 0x3026e(%rip), %rax     # 0xb00d4
movslq (%r14,%rax), %rsi
addq %rax, %rsi
movq %rbp, %rdi
movq %rbp, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x41b0
movq 0x48(%r12), %r12
testq %r12, %r12
jne 0x7fe4a
leaq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
movl %ebx, %esi
callq 0x7e093
addq $0xf4258, %rsp          # imm = 0xF4258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq