LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x726f9
movl %eax, %ebx
movl 0x30f08(%r15), %eax
cmpq $0x4, %rax
ja 0x7291a
leaq 0x2d4e1(%rip), %rcx     # 0x9fdb8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl (%rax), %edx
leaq 0x2e268(%rip), %rsi     # 0xa0b59
movq %r12, %rdi
xorl %eax, %eax
callq 0x42e0
jmp 0x7291a
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
leaq 0x2d89e(%rip), %rsi     # 0xa01ae
movq %r12, %rdi
movb $0x1, %al
callq 0x42e0
movzbl %bl, %r13d
leaq 0x31248(%r15), %rbx
pushq $0x1
popq %rbp
leaq 0x2d49d(%rip), %r14     # 0x9fdcc
movslq 0x1bc(%r15), %rax
cmpq %rax, %rbp
jge 0x7299a
movl (%rbx), %eax
cmpq $0x4, %rax
ja 0x7298e
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 0x2d852(%rip), %rsi     # 0xa01b3
movl %r13d, %edx
xorl %eax, %eax
callq 0x42e0
jmp 0x7298e
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r12, %rdi
leaq 0x2d828(%rip), %rsi     # 0xa01ac
movl %r13d, %edx
movb $0x1, %al
callq 0x42e0
incq %rbp
addq $0x340, %rbx            # imm = 0x340
jmp 0x7292f
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 0x72790
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movl %esi, %ebp
movq %rdi, %r15
movl %ecx, %edx
callq 0x726f9
movl %eax, %r12d
movsd 0x8(%r14), %xmm0
leaq 0x2d7ca(%rip), %rsi     # 0xa01ae
movq %r15, %rdi
movb $0x1, %al
callq 0x42e0
movzbl %r12b, %r12d
addq $0x18, %r14
leaq 0x2d7af(%rip), %r13     # 0xa01ac
cmpl $-0x1, -0x8(%r14)
je 0x72a1f
movsd (%r14), %xmm0
movq %r15, %rdi
movq %r13, %rsi
movl %r12d, %edx
movb $0x1, %al
callq 0x42e0
addq $0x10, %r14
jmp 0x729fd
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x72790
// File: /workspace/github_c_makefile_star2_O2/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 0x726f9
movl %eax, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2aea2
leaq 0x2d73e(%rip), %rsi     # 0xa01ae
movq %r12, %rdi
movb $0x1, %al
callq 0x42e0
movzbl %bl, %r13d
pushq $0x1
popq %rbx
leaq 0x2d724(%rip), %rbp     # 0xa01ac
movl 0x1c0(%r15), %eax
decl %eax
cmpl %eax, %ebx
jge 0x72ab3
movq %r14, %rdi
movl %ebx, %esi
callq 0x2aea2
movq %r12, %rdi
movq %rbp, %rsi
movl %r13d, %edx
movb $0x1, %al
callq 0x42e0
incl %ebx
jmp 0x72a88
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 0x72790
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x72524
cmpl $0x5, %r15d
ja 0x73064
movl %r15d, %eax
leaq 0x2cdeb(%rip), %rcx     # 0x9fde0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2d264(%rip), %rsi     # 0xa0269
jmp 0x73076
leaq 0x2d267(%rip), %rsi     # 0xa0275
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x42e0
leaq 0x2d1ca(%rip), %rsi     # 0xa01f8
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x42e0
movq %rbx, %rdi
callq 0x72524
leaq 0x2d242(%rip), %rdi     # 0xa028e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
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 0x2d20a(%rip), %rsi     # 0xa0280
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x72524
cmpl $0x5, %ebp
ja 0x73122
movl %ebp, %eax
leaq 0x2cd47(%rip), %rcx     # 0x9fdf8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2d1d5(%rip), %rsi     # 0xa0296
jmp 0x73134
leaq 0x2d151(%rip), %rsi     # 0xa021b
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x42e0
leaq 0x2d127(%rip), %rsi     # 0xa0212
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x42e0
movq %rbx, %rdi
callq 0x72524
leaq 0x2d184(%rip), %rdi     # 0xa028e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
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 0x2d16e(%rip), %rsi     # 0xa02a2
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x72524
cmpl $0x5, %ebp
ja 0x731e7
movl %ebp, %eax
leaq 0x2cc9c(%rip), %rcx     # 0x9fe10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2d12c(%rip), %rsi     # 0xa02b0
jmp 0x731f7
leaq 0x2d131(%rip), %rsi     # 0xa02be
movq %rbx, %rdi
movq %r14, %rdx
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x42e0
leaq 0x2d023(%rip), %rsi     # 0xa01d2
movq %rbx, %rdi
movq %r14, %rdx
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x42e0
movq %rbx, %rdi
callq 0x72524
leaq 0x2d0bd(%rip), %rdi     # 0xa028e
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x42c0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2d0d4(%rip), %rsi     # 0xa02cb
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O2/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 0x7324f
movq %rdi, %rcx
pushq $0xb
popq %rax
btl %esi, %eax
jae 0x7322a
leaq 0x2be8e(%rip), %rdi     # 0x9f0b4
pushq $0x2
jmp 0x73246
pushq $0x30
popq %rax
btl %esi, %eax
jae 0x7323d
leaq 0x2927b(%rip), %rdi     # 0x9c4b4
pushq $0x4
jmp 0x73246
leaq 0x2d097(%rip), %rdi     # 0xa02db
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
jmp 0x42c0
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
addl $-0x2, 0x336cdb(%rip)   # 0x3aa1e8
callq 0x72524
cmpl $0x5, %ebp
ja 0x7354a
movl %ebp, %eax
leaq 0x2c920(%rip), %rcx     # 0x9fe40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2bb84(%rip), %rdi     # 0x9f0b4
pushq $0x2
jmp 0x7355a
leaq 0x2cda0(%rip), %rdi     # 0xa02db
pushq $0x5
jmp 0x7355a
leaq 0x2ce96(%rip), %rdi     # 0xa03dc
pushq $0xb
jmp 0x7355a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x28f5c(%rip), %rdi     # 0x9c4b4
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x42c0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x725ba
movq %r14, %rdi
callq 0x72524
leaq 0x2cc84(%rip), %rdi     # 0xa0462
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x42c0
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7254e
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
decl 0x3369dc(%rip)          # 0x3aa1e8
pushq $0x2
popq %rsi
pushq $0x4
popq %rdx
pushq $0x5
popq %rcx
movl %ebx, %edi
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x73828
decl 0x3369c0(%rip)          # 0x3aa1e8
movq %r14, %rdi
callq 0x72524
cmpl $0x5, %ebx
ja 0x7387d
movl %ebx, %eax
leaq 0x2c61a(%rip), %rcx     # 0x9fe58
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2b866(%rip), %rdi     # 0x9f0b4
pushq $0x2
jmp 0x73871
leaq 0x2ca82(%rip), %rdi     # 0xa02db
pushq $0x5
jmp 0x73871
leaq 0x2cc04(%rip), %rdi     # 0xa0468
pushq $0x6
jmp 0x73871
leaq 0x28c45(%rip), %rdi     # 0x9c4b4
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x42c0
pushq $0x2
popq %rsi
pushq $0x4
popq %rdx
pushq $0x5
popq %rcx
movl %ebx, %edi
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
jne 0x73899
decl 0x33694f(%rip)          # 0x3aa1e8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
decl 0x336938(%rip)          # 0x3aa1e8
pushq $0x2
popq %rsi
pushq $0x4
popq %rdx
pushq $0x5
popq %rcx
movl %ebx, %edi
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
je 0x738cc
decl 0x33691c(%rip)          # 0x3aa1e8
movq %r14, %rdi
callq 0x72524
cmpl $0x5, %ebx
ja 0x73914
pushq $0xb
popq %rax
btl %ebx, %eax
jae 0x738ec
leaq 0x2b7cc(%rip), %rdi     # 0x9f0b4
pushq $0x2
jmp 0x73908
pushq $0x30
popq %rax
btl %ebx, %eax
jae 0x738ff
leaq 0x28bb9(%rip), %rdi     # 0x9c4b4
pushq $0x4
jmp 0x73908
leaq 0x2c9d5(%rip), %rdi     # 0xa02db
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x42c0
pushq $0x2
popq %rsi
pushq $0x4
popq %rdx
pushq $0x5
popq %rcx
movl %ebx, %edi
xorl %eax, %eax
callq 0x35812
testl %eax, %eax
jne 0x73930
decl 0x3368b8(%rip)          # 0x3aa1e8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rcx, %r13
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
callq 0x72524
cmpl $0x5, %ebx
ja 0x73b26
movl %ebx, %eax
leaq 0x2c3f5(%rip), %rcx     # 0x9fe88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2caa6(%rip), %rsi     # 0xa0549
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %r12, %r8
movq %r15, %r9
xorl %eax, %eax
pushq %rbp
pushq %r12
callq 0x42e0
popq %rcx
popq %rdx
jmp 0x73b26
movq %rbp, %rdi
callq 0x4200
testl %eax, %eax
jle 0x73b0c
leaq 0x2ca99(%rip), %rsi     # 0xa056c
jmp 0x73b13
leaq 0x2cad6(%rip), %rsi     # 0xa05b2
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %r15, %r8
movq %rbp, %r9
jmp 0x73b03
leaq 0x2caaa(%rip), %rsi     # 0xa059e
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x42e0
jmp 0x73b26
leaq 0x2ca70(%rip), %rsi     # 0xa0583
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %r15, %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 0x7254e
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
decl 0x336668(%rip)          # 0x3aa1e8
callq 0x72524
cmpl $0x5, %ebp
ja 0x73bd2
movl %ebp, %eax
leaq 0x2c30d(%rip), %rcx     # 0x9fea0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2b511(%rip), %rdi     # 0x9f0b4
pushq $0x2
jmp 0x73bc6
leaq 0x2c72d(%rip), %rdi     # 0xa02db
pushq $0x5
jmp 0x73bc6
leaq 0x2ca0d(%rip), %rdi     # 0xa05c6
pushq $0x6
jmp 0x73bc6
leaq 0x288f0(%rip), %rdi     # 0x9c4b4
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x42c0
decl 0x336610(%rip)          # 0x3aa1e8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x73c54
movl %ebp, %eax
leaq 0x2c2b5(%rip), %rdx     # 0x9feb8
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq 0x2c9ba(%rip), %rsi     # 0xa05cd
jmp 0x73c2e
leaq 0x2c9c8(%rip), %rsi     # 0xa05e4
jmp 0x73c47
leaq 0x2c9d4(%rip), %rsi     # 0xa05f9
jmp 0x73c2e
leaq 0x2c9e7(%rip), %rsi     # 0xa0615
movq %r15, %rdi
movq %rcx, %rdx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x42e0
jmp 0x73c54
leaq 0x2c9ac(%rip), %rsi     # 0xa05f3
movq %r15, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x42e0
cmpl %r12d, 0x1bc(%r14)
jne 0x73c79
pushq $-0x1
popq %r8
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x72897
movl 0x1c0(%r14), %eax
decl %eax
cmpl %r12d, %eax
jne 0x73ca3
pushq $-0x1
popq %r8
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x72a39
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_constant
void code_2d_array_constant(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2, double** values)
{
 /*!Last Changed 12.06.2006*/
 int i;
 code_2d_array_start(testcodefile, language, arrayname, size1, size2);
 for (i = 0; i < size1; i++)
   code_constant_subarray(testcodefile, language, size2, values[i], i);
 code_2d_array_end(testcodefile, language); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r15d
movl %esi, %r14d
movq %rdi, %r12
callq 0x73f26
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r13, %r15
je 0x73f0d
movq (%rbx,%r13,8), %rcx
movq %r12, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %r13d, %r8d
callq 0x7280c
incq %r13
jmp 0x73eef
movq %r12, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x73f75
// File: /workspace/github_c_makefile_star2_O2/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 0x73f66
movl %esi, %eax
leaq 0x2bfcc(%rip), %rsi     # 0x9ff00
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
leaq 0x2c7ba(%rip), %rsi     # 0xa06fe
jmp 0x73f5f
leaq 0x2c7cd(%rip), %rsi     # 0xa071a
jmp 0x73f6e
leaq 0x2c7dc(%rip), %rsi     # 0xa0732
jmp 0x73f5f
leaq 0x2c7f7(%rip), %rsi     # 0xa0756
xorl %eax, %eax
jmp 0x42e0
retq
leaq 0x2c749(%rip), %rsi     # 0xa06b7
xorl %eax, %eax
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: code_2d_array_constant_matrix
void code_2d_array_constant_matrix(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size1, int size2, matrixptr matrixarray)
{
 /*!Last Changed 08.08.2007*/
 int i;
 code_2d_array_start(testcodefile, language, arrayname, size1, size2);
 for (i = 0; i < size1; i++)
   code_constant_subarray(testcodefile, language, size2, matrixarray[i].values[0], i);
 code_2d_array_end(testcodefile, language); 
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movl %ecx, %r14d
movl %esi, %ebp
movq %rdi, %r15
callq 0x73f26
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
cmpq %r12, %r14
je 0x740d1
movq (%rbx,%r12,8), %rdx
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %ecx
callq 0x729b8
incq %r12
jmp 0x740b6
movq %r15, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x73f75
// File: /workspace/github_c_makefile_star2_O2/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 %r8d, %ebx
movl %ecx, %r12d
movl %esi, %ebp
movq %rdi, %r15
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
callq 0x741a1
xorl %r13d, %r13d
testl %ebx, %ebx
movl $0x0, %r14d
cmovgl %ebx, %r14d
testl %r12d, %r12d
cmovlel %r13d, %r12d
movq %r12, 0x8(%rsp)
cmpq 0x8(%rsp), %r13
je 0x74189
movq %r15, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x726f9
movq %r13, 0x10(%rsp)
shlq $0x4, %r13
movq (%rsp), %rcx
leaq (%rcx,%r13), %r12
addq $0x8, %r12
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x74172
movq (%r12), %rax
movq (%rax,%r13,8), %rcx
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
movl %r13d, %r8d
callq 0x7280c
incq %r13
jmp 0x74151
movq %r15, %rdi
movl %ebp, %esi
movq 0x10(%rsp), %r13
movl %r13d, %edx
callq 0x72790
incq %r13
jmp 0x74125
movq %r15, %rdi
movl %ebp, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x73f75
// File: /workspace/github_c_makefile_star2_O2/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 0x741e1
movl %esi, %eax
leaq 0x2bd69(%rip), %rsi     # 0x9ff18
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
leaq 0x2c5ab(%rip), %rsi     # 0xa076a
jmp 0x741da
leaq 0x2c5c2(%rip), %rsi     # 0xa078a
jmp 0x741e9
leaq 0x2c5d4(%rip), %rsi     # 0xa07a5
jmp 0x741da
leaq 0x2c5f6(%rip), %rsi     # 0xa07d0
xorl %eax, %eax
jmp 0x42e0
retq
leaq 0x2c4ce(%rip), %rsi     # 0xa06b7
xorl %eax, %eax
jmp 0x42e0
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: code_array_initialize
void code_array_initialize(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, int size, char* value)
{
 /*!Last Changed 13.06.2006*/
 char st[MAXLENGTH];
 code_for(testcodefile, language, "i", 0, size - 1, 1);   
 code_array_index_variable(st, language, arrayname, "i");  
 code_set_variable(testcodefile, language, st, value);
 code_endfor(testcodefile, language, "i");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %r8, %r14
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r12
leal -0x1(%rcx), %r8d
leaq 0x2ca01(%rip), %r13     # 0xa0c1d
pushq $0x1
popq %r9
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x73938
movq %rsp, %rbp
movq %rbp, %rdi
movl %ebx, %esi
movq %r15, %rdx
movq %r13, %rcx
callq 0x7327f
movq %r12, %rdi
movl %ebx, %esi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x72b25
movq %r12, %rdi
movl %ebx, %esi
callq 0x73b72
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r13
leaq 0x7a130(%rsp), %r12
movl %esi, %edi
movq %rdx, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x74c76
movq 0x48(%r13), %r13
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x4270
movl %ebx, %r14d
shlq $0x2, %r14
leaq 0x2b1ab(%rip), %rbp     # 0xa0050
testq %r13, %r13
je 0x74ede
movl %ebx, %edi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x74c76
cmpl $0x5, %ebx
ja 0x74ed8
movslq (%r14,%rbp), %rsi
addq %rbp, %rsi
leaq 0x10(%rsp), %rdi
movq %rdi, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x41b0
movq 0x48(%r13), %r13
jmp 0x74ea5
leaq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
movl %ebx, %esi
callq 0x736b9
addq $0xf4258, %rsp          # imm = 0xF4258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: code_dimension_reduce
void code_dimension_reduce(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, Datasetptr d, int newdimension)
{
 /*!Last Changed 16.06.2006*/
 char st[MAXLENGTH], st2[MAXLENGTH], st3[MAXLENGTH];
 code_array_initialize(testcodefile, language, "testdatareduced", newdimension, "0.0");
 code_for(testcodefile, language, "i", 0, d->multifeaturecount - 2, 1);   
 code_array_index_variable(st, language, "testdataconverted", "i"); 
 code_set_variable(testcodefile, language, "x_i", st);
 code_for(testcodefile, language, "j", 0, newdimension - 1, 1);
 code_array_index_variable(st2, language, "testdatareduced", "j"); 
 code_2d_array_index_variable(st, language, "eigenvectors", "i", "j");
 code_set_variable(testcodefile, language, "eigenvectors_ij", st);
 sprintf(st3, "%s + eigenvectors_ij * x_i", st2);
 code_set_variable(testcodefile, language, st2, st3);
 code_endfor(testcodefile, language, "j");
 code_endfor(testcodefile, language, "i");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x16e368, %rsp         # imm = 0x16E368
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x2b96f(%rip), %rdx     # 0xa0892
leaq 0x2bc4f(%rip), %r8      # 0xa0b79
callq 0x741f5
movl 0x1c0(%r15), %r8d
addl $-0x2, %r8d
leaq 0x2bcdc(%rip), %r12     # 0xa0c1d
pushq $0x1
popq %r9
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x73938
leaq 0x2b88d(%rip), %rdx     # 0xa07e8
leaq 0xf4240(%rsp), %r13
movq %r13, %rdi
movl %ebx, %esi
movq %r12, %rcx
callq 0x7327f
leaq 0x2bb28(%rip), %rdx     # 0xa0a9f
movq %r14, %rdi
movl %ebx, %esi
movq %r13, %rcx
callq 0x72b25
decl %ebp
leaq 0x2b98b(%rip), %r15     # 0xa0918
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
pushq $0x1
popq %r9
callq 0x73938
leaq 0x7a120(%rsp), %rbp
movq %rbp, %rdi
movl %ebx, %esi
leaq 0x2b8db(%rip), %rdx     # 0xa0892
movq %r15, %rcx
callq 0x7327f
leaq 0x2b8dc(%rip), %rdx     # 0xa08a2
movq %r13, %rdi
movl %ebx, %esi
movq %r12, %rcx
movq %r15, %r8
callq 0x7329c
leaq 0x2b8d2(%rip), %rdx     # 0xa08af
movq %r14, %rdi
movl %ebx, %esi
movq %r13, %rcx
callq 0x72b25
leaq 0x2b8ce(%rip), %rsi     # 0xa08bf
movq %rsp, %r15
movq %r15, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x41b0
movq %r14, %rdi
movl %ebx, %esi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x72b25
movq %r14, %rdi
movl %ebx, %esi
callq 0x73b72
movq %r14, %rdi
movl %ebx, %esi
callq 0x73b72
addq $0x16e368, %rsp         # imm = 0x16E368
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: code_forward_propagation
void code_forward_propagation(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, int row, int col, char* weightname, char* inputname, char* outputname, int sigmoid)
{
 /*!Last Changed 16.06.2006*/
 char st[MAXLENGTH];
 code_for(testcodefile, language, "i", 0, row - 1, 1);     
 code_2d_array_index_variable(st, language, weightname, "i", "0");
 code_set_variable(testcodefile, language, "sum", st);   
 code_for(testcodefile, language, "j", 1, col - 1, 1);
 code_2d_array_index_variable(st, language, weightname, "i", "j");
 code_set_variable(testcodefile, language, "weights_ij", st);        
 code_array_index_variable(st, language, inputname, "j - 1");            
 code_set_variable(testcodefile, language, "x_j", st);        
 code_set_variable(testcodefile, language, "sum", "sum + weights_ij * x_j");        
 code_endfor(testcodefile, language, "j");
 code_array_index_variable(st, language, outputname, "i");            
 if (sigmoid)
  {
   code_set_variable(testcodefile, language, "sigmoid", "1 / (1 + exp(-sum))");
   code_set_variable(testcodefile, language, st, "sigmoid");
  }
 else
   code_set_variable(testcodefile, language, st, "sum");
 code_endfor(testcodefile, language, "i");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movq %r9, 0x8(%rsp)
movq %r8, %r15
movl %ecx, %r13d
movl %esi, %ebx
movq %rdi, %r14
leal -0x1(%rdx), %r8d
leaq 0x2bbba(%rip), %r12     # 0xa0c1d
pushq $0x1
popq %r9
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x73938
leaq 0x21139(%rip), %r8      # 0x961b1
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movl %ebx, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x7329c
leaq 0x2bb7d(%rip), %r12     # 0xa0c11
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x72b25
decl %r13d
leaq 0x2b86a(%rip), %rdx     # 0xa0918
movq %r14, %rdi
movl %ebx, %esi
pushq $0x1
popq %rcx
movl %r13d, %r8d
movl %ecx, %r9d
callq 0x73938
movq %rbp, %rdi
movl %ebx, %esi
movq %r15, %rdx
leaq 0x2bb4d(%rip), %r15     # 0xa0c1d
movq %r15, %rcx
leaq 0x2b83e(%rip), %r8      # 0xa0918
callq 0x7329c
leaq 0x2b7f4(%rip), %rdx     # 0xa08da
movq %r14, %rdi
movl %ebx, %esi
movq %rbp, %rcx
callq 0x72b25
leaq 0x2bc06(%rip), %rcx     # 0xa0d00
movq %rbp, %rdi
movl %ebx, %esi
movq 0x8(%rsp), %rdx
callq 0x7327f
leaq 0x2b81c(%rip), %rdx     # 0xa092c
movq %r14, %rdi
movl %ebx, %esi
movq %rbp, %rcx
callq 0x72b25
leaq 0x2b7c1(%rip), %rcx     # 0xa08e5
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x72b25
movq %r14, %rdi
movl %ebx, %esi
callq 0x73b72
movq %rbp, %rdi
movl %ebx, %esi
movq 0x7a170(%rsp), %rdx
movq %r15, %rcx
callq 0x7327f
cmpl $0x0, 0x7a178(%rsp)
je 0x75175
leaq 0x25a53(%rip), %r12     # 0x9abb4
leaq 0x2b794(%rip), %rcx     # 0xa08fc
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x72b25
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rcx
callq 0x72b25
movq %r14, %rdi
movl %ebx, %esi
callq 0x73b72
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: code_forward_propagation_regression_output
void code_forward_propagation_regression_output(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, int col, char* weightname, char* inputname, char* outputname)
{
 /*!Last Changed 24.06.2006*/
 char st[MAXLENGTH];
 code_array_index_variable(st, language, weightname, "0");
 code_set_variable(testcodefile, language, "sum", st);   
 code_for(testcodefile, language, "j", 1, col - 1, 1);
 code_array_index_variable(st, language, weightname, "j");
 code_set_variable(testcodefile, language, "weights_j", st);        
 code_array_index_variable(st, language, inputname, "j - 1");            
 code_set_variable(testcodefile, language, "x_j", st);        
 code_set_variable(testcodefile, language, "sum", "sum + weights_j * x_j");        
 code_endfor(testcodefile, language, "j");
 code_set_variable(testcodefile, language, outputname, "sum");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a138, %rsp          # imm = 0x7A138
movq %r9, 0x8(%rsp)
movq %r8, (%rsp)
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
leaq 0x20fe2(%rip), %rcx     # 0x961b1
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x7327f
leaq 0x2ba2b(%rip), %rdx     # 0xa0c11
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rcx
callq 0x72b25
decl %r15d
leaq 0x2b71b(%rip), %r13     # 0xa0918
pushq $0x1
popq %rcx
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %r15d, %r8d
movl %ecx, %r9d
callq 0x73938
movq %r12, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x7327f
leaq 0x2b6e6(%rip), %rdx     # 0xa0910
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rcx
callq 0x72b25
leaq 0x2bac2(%rip), %rcx     # 0xa0d00
movq %r12, %rdi
movl %ebp, %esi
movq (%rsp), %rdx
callq 0x7327f
leaq 0x2b6d9(%rip), %rdx     # 0xa092c
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rcx
callq 0x72b25
leaq 0x2b6b3(%rip), %rcx     # 0xa091a
movq %r14, %rdi
movl %ebp, %esi
leaq 0x2b99e(%rip), %rbx     # 0xa0c11
movq %rbx, %rdx
callq 0x72b25
movq %r14, %rdi
movl %ebp, %esi
callq 0x73b72
movq %r14, %rdi
movl %ebp, %esi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x72b25
addq $0x7a138, %rsp          # imm = 0x7A138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: code_compare_and_set_bound
void code_compare_and_set_bound(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* comparison, char* value, char* bestbound, char* index)
{
 /*!Last Changed 16.06.2006*/
 code_if(testcodefile, language, comparison, value, bestbound);
 code_set_variable(testcodefile, language, bestbound, value);
 code_set_variable(testcodefile, language, index, "i"); 
 code_endif(testcodefile, language);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %esi, %ebp
movq %rdi, %r12
callq 0x736fc
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x72b25
leaq 0x2b942(%rip), %rcx     # 0xa0c1d
movq %r12, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x72b25
movq %r12, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x737fd
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: code_find_bound_of_list
void code_find_bound_of_list(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* listname, int list_length, char* initialbound, char* bestbound, char* index, char* comparison)
{
 /*!Last Changed 16.06.2006*/
 char st[MAXLENGTH];
 code_set_variable(testcodefile, language, bestbound, initialbound);
 code_for(testcodefile, language, "i", 0, list_length - 1, 1);   
 code_array_index_variable(st, language, listname, "i");  
 code_compare_and_set_bound(testcodefile, language, comparison, st, bestbound, index);
 code_endfor(testcodefile, language, "i");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %r9, %r15
movl %ecx, %ebp
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movq %r9, %rdx
movq %r8, %rcx
callq 0x72b25
decl %ebp
leaq 0x2b8f1(%rip), %r13     # 0xa0c1d
pushq $0x1
popq %r9
movq %r14, %rdi
movl %ebx, %esi
movq %r13, %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x73938
movq %rsp, %rbp
movq %rbp, %rdi
movl %ebx, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7327f
movq %r14, %rdi
movl %ebx, %esi
movq 0x7a168(%rsp), %rdx
movq %rbp, %rcx
movq %r15, %r8
movq 0x7a160(%rsp), %r9
callq 0x752a9
movq %r14, %rdi
movl %ebx, %esi
callq 0x73b72
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/savecode.c
// Function: code_increment
void code_increment(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, char* arrayname, char* index)
{
 /*!Last Changed 25.06.2006*/
 char st[MAXLENGTH], st2[MAXLENGTH];
 code_array_index_variable(st, language, arrayname, index);  
 strcpy(st2, st);
 sprintf(st2, "%s + 1", st2);
 code_set_variable(testcodefile, language, st, st2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf4248, %rsp          # imm = 0xF4248
movl %esi, %ebx
movq %rdi, %r14
leaq 0x7a120(%rsp), %r15
movq %r15, %rdi
callq 0x7327f
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4270
leaq 0x2b567(%rip), %rsi     # 0xa0930
movq %r12, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x41b0
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x72b25
addq $0xf4248, %rsp          # imm = 0xF4248
popq %rbx
popq %r12
popq %r14
popq %r15
retq