LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rule.c
// Function: remove_condition
void remove_condition(Decisionruleptr rule, Decisionconditionptr deleted)
{
	/*!Last Changed 19.12.2003*/
 Decisionconditionptr before = NULL, tmp;
	tmp = rule->start;
	while (tmp)
	 { 
		 if (tmp == deleted)
				 break;
			before = tmp;
			tmp = tmp->next;
	 }
	if (tmp)
	  remove_condition_after(rule, before, deleted);
}

// Assembly:
leaq 0x18(%rdi), %rax
xorl %edx, %edx
movq %rax, %r8
movq %rdx, %rcx
movq (%r8), %rdx
testq %rdx, %rdx
je 0x7aedf
leaq 0x48(%rdx), %r8
cmpq %rsi, %rdx
jne 0x7aecb
testq %rdx, %rdx
je 0x7af02
decl 0x28(%rdi)
movq 0x48(%rsi), %rdx
testq %rdx, %rdx
jne 0x7aef4
movq %rcx, 0x20(%rdi)
leaq 0x48(%rcx), %rsi
testq %rcx, %rcx
cmoveq %rax, %rsi
movq %rdx, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rule.c
// Function: remove_condition_after
void remove_condition_after(Decisionruleptr rule, Decisionconditionptr before, Decisionconditionptr deleted)
{
	/*!Last Changed 10.05.2003*/
	rule->decisioncount--;
	if (deleted->next == NULL)
		 rule->end = before;
	if (before == NULL)
		 rule->start = deleted->next;
	else
		 before->next = deleted->next;
}

// Assembly:
decl 0x28(%rdi)
movq 0x48(%rdx), %rax
testq %rax, %rax
jne 0x7af13
movq %rsi, 0x20(%rdi)
leaq 0x48(%rsi), %rcx
addq $0x18, %rdi
testq %rsi, %rsi
cmovneq %rcx, %rdi
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rule.c
// Function: test_rule
double test_rule(Decisionrule rule, Instanceptr instances)
{
	/*!Last Changed 10.05.2003*/
	int negative = 0, total = 0;
	Instanceptr tmp;
	tmp = instances;
	while (tmp)
	 {
			if (rule_cover_instance(tmp, rule))
			 {
			  total++;
		   if (give_classno(tmp) != rule.classno)
						 negative++;
			 }
			tmp = tmp->next;
	 }
	return negative/(total+0.0);
}

// Assembly:
testq %rdi, %rdi
je 0x7afa4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40(%rsp), %rax
movq 0x18(%rax), %r15
movl (%rax), %r12d
xorl %ebp, %ebp
xorl %r13d, %r13d
movq %r15, %r14
testq %r15, %r15
je 0x7af6a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x795f2
testl %eax, %eax
je 0x7af7f
movq 0x48(%r14), %r14
testq %r14, %r14
jne 0x7af52
incl %ebp
movq %rbx, %rdi
callq 0x2eaca
xorl %ecx, %ecx
cmpl %r12d, %eax
setne %cl
addl %ecx, %r13d
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x7af4a
cvtsi2sd %r13d, %xmm0
cvtsi2sd %ebp, %xmm1
divsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsd 0x27d64(%rip), %xmm0    # 0xa2d10
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rule.c
// Function: remove_rules_of_class
void remove_rules_of_class(Ruleset* set, int index)
{
 Decisionruleptr tmp, before = NULL, tmpnext;
 tmp = set->start;
 while (tmp)
  {
   tmpnext = tmp->next;
   if (tmp->classno == index)
    {
     if (before)
       before->next = tmp->next;
     else
       set->start = tmp->next;
     if (tmpnext == NULL)
       set->end = before;
     set->rulecount--;
     free_rule(*tmp);
     safe_free(tmp);
    }
   else
     before = tmp;
   tmp = tmpnext;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq (%rdi), %r15
testq %r15, %r15
je 0x7b0a4
xorl %ebp, %ebp
movl %esi, 0x7c(%rsp)
movq %rdi, 0x80(%rsp)
movq 0x30(%r15), %rbx
cmpl %esi, (%r15)
jne 0x7b099
leaq 0x30(%rbp), %rax
testq %rbp, %rbp
cmoveq %rdi, %rax
movq %rbx, (%rax)
testq %rbx, %rbx
jne 0x7b044
movq %rbp, 0x8(%rdi)
decl 0x10(%rdi)
movq 0x10(%r15), %r12
movq 0x18(%r15), %r13
testq %r13, %r13
je 0x7b07b
movq 0x48(%r13), %r14
movl $0xe, %ecx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x7a935
movq %r13, %rdi
callq 0x39194
movq %r14, %r13
testq %r14, %r14
jne 0x7b054
movq %r12, %rdi
callq 0x39194
movq %r15, %rdi
callq 0x39194
movl 0x7c(%rsp), %esi
movq 0x80(%rsp), %rdi
jmp 0x7b09c
movq %r15, %rbp
movq %rbx, %r15
testq %rbx, %rbx
jne 0x7b024
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rule.c
// Function: remove_rule
void remove_rule(Ruleset* set, Decisionruleptr rule)
{
	/*!Last Changed 16.06.2003*/
 Decisionruleptr before = NULL, tmp;
	tmp = set->start;
	while (tmp)
	 { 
		 if (tmp == rule)
				 break;
			before = tmp;
			tmp = tmp->next;
	 }
	if (tmp)
	  remove_rule_after(set, before, rule);
}

// Assembly:
xorl %ecx, %ecx
movq %rdi, %rdx
movq %rcx, %rax
movq (%rdx), %rcx
testq %rcx, %rcx
je 0x7b0cf
leaq 0x30(%rcx), %rdx
cmpq %rsi, %rcx
jne 0x7b0bb
testq %rcx, %rcx
je 0x7b0ef
decl 0x10(%rdi)
je 0x7b0f0
movq 0x30(%rsi), %rcx
testq %rcx, %rcx
jne 0x7b0e6
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x7b0f7
movq %rcx, 0x30(%rax)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
retq
movq %rcx, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rule.c
// Function: add_rule
void add_rule(Ruleset* set, Decisionruleptr rule)
{
	/*!Last Changed 04.11.2003 Added rule->next = NULL*/
	/*!Last Changed 13.05.2003*/
	if (set->rulecount == 0)
		 set->start = rule;
	else
		 set->end->next = rule;
	set->end = rule;
	rule->next = NULL;
	set->rulecount++;
}

// Assembly:
movl 0x10(%rdi), %eax
movq %rdi, %rcx
testl %eax, %eax
je 0x7b10d
movq 0x8(%rdi), %rcx
addq $0x30, %rcx
movq %rsi, (%rcx)
movq %rsi, 0x8(%rdi)
movq $0x0, 0x30(%rsi)
incl %eax
movl %eax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rule.c
// Function: update_counts
void update_counts(Decisionruleptr rule, Instanceptr list1, int initialize)
{
	/*!Last Changed 02.11.2003*/
 int classno;
	Instanceptr tmp;
	if (initialize)
	 {
		 rule->covered = 0;
			rule->falsepositives = 0;
	 }
	tmp = list1;
	while (tmp)
	 {
		 if (rule_cover_instance(tmp, *rule))
    {
     classno = give_classno(tmp);
				 if (classno != rule->classno)
						 rule->falsepositives++;
					else
						 rule->covered++;
    }
		 tmp = tmp->next;
	 }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x7b171
movq $0x0, 0x4(%r14)
jmp 0x7b171
movq 0x18(%r14), %r15
movq %rbx, %rdi
testq %r15, %r15
je 0x7b159
movq %r15, %rsi
callq 0x795f2
testl %eax, %eax
je 0x7b16d
movq 0x48(%r15), %r15
jmp 0x7b13f
callq 0x2eaca
cmpl (%r14), %eax
jne 0x7b169
incl 0x4(%r14)
jmp 0x7b16d
incl 0x8(%r14)
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x7b13b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rule.c
// Function: update_counts_ruleset
void update_counts_ruleset(Ruleset r, Instanceptr list)
{
	/*!Last Changed 18.03.2004*/
	int i;
 BOOLEAN covered;
	Decisionruleptr tmp;
	Instanceptr test = list;
 for (i = 0; i < current_dataset->classno; i++)
   r.counts[i] = 0;
	tmp = r.start;
	while (tmp)
	 {
		 tmp->covered = 0;
			tmp->falsepositives = 0;
   for (i = 0; i < current_dataset->classno; i++)
     tmp->counts[i] = 0;
		 tmp = tmp->next;
	 }
 while (test)
  {
   i = give_classno(test);
   covered = BOOLEAN_FALSE;
			tmp = r.start;
			while (tmp)
			 {
				 if (rule_cover_instance(test, *tmp))
					 {
       tmp->counts[i]++;
						 tmp->covered++;
       if (i != tmp->classno)
								 tmp->falsepositives++;
       covered = BOOLEAN_TRUE;
							break;
					 }
				 tmp = tmp->next;
			 }
   if (!covered)
     r.counts[i]++;
   test = test->next;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40(%rsp), %rax
leaq 0x576da(%rip), %rcx     # 0xd2870
movq (%rcx), %rcx
cmpl $0x0, 0x10(%rcx)
jle 0x7b1b8
movq 0x18(%rax), %rdx
xorl %esi, %esi
movl $0x0, (%rdx,%rsi,4)
incq %rsi
movslq 0x10(%rcx), %rdi
cmpq %rdi, %rsi
jl 0x7b1a5
movq (%rax), %rdx
testq %rdx, %rdx
je 0x7b1ed
movq $0x0, 0x4(%rdx)
cmpl $0x0, 0x10(%rcx)
jle 0x7b1e7
movq 0x10(%rdx), %rsi
xorl %edi, %edi
movl $0x0, (%rsi,%rdi,4)
incq %rdi
movslq 0x10(%rcx), %r8
cmpq %r8, %rdi
jl 0x7b1d4
movq 0x30(%rdx), %rdx
jmp 0x7b1bb
testq %rbx, %rbx
je 0x7b261
movq (%rax), %r12
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x2eaca
movslq %eax, %r13
testq %r12, %r12
je 0x7b239
movl %eax, %ebp
movq %r12, %r15
movq 0x18(%r15), %r14
testq %r14, %r14
je 0x7b243
movq %rbx, %rdi
movq %r14, %rsi
callq 0x795f2
testl %eax, %eax
je 0x7b230
movq 0x48(%r14), %r14
jmp 0x7b216
movq 0x30(%r15), %r15
testq %r15, %r15
jne 0x7b212
movq (%rsp), %rax
incl (%rax,%r13,4)
jmp 0x7b258
movq 0x10(%r15), %rax
incl (%rax,%r13,4)
incl 0x4(%r15)
cmpl (%r15), %ebp
je 0x7b258
incl 0x8(%r15)
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x7b1fd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/rule.c
// Function: print_counts
void print_counts(char* st,Instanceptr list)
{
	int* counts, i;
	counts = find_class_counts(list);
	printf("----------\n");
	printf("%s\n",st);
	printf("----------\n");
 for (i = 0; i < current_dataset->classno; i++)
		 printf(m1309, i, counts[i]);
	printf("----------\n");
	safe_free(counts);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, %rdi
callq 0x115e1
movq %rax, %rbx
leaq 0x28093(%rip), %r15     # 0xa3320
movq %r15, %rdi
callq 0x4090
movq %r14, %rdi
callq 0x4090
movq %r15, %rdi
callq 0x4090
leaq 0x575c4(%rip), %r12     # 0xd2870
movq (%r12), %rax
cmpl $0x0, 0x10(%rax)
jle 0x7b2e1
leaq 0x31a98(%rip), %r14     # 0xacd55
xorl %r15d, %r15d
movl (%rbx,%r15,4), %edx
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x4030
incq %r15
movq (%r12), %rax
movslq 0x10(%rax), %rax
cmpq %rax, %r15
jl 0x7b2c0
leaq 0x28038(%rip), %rdi     # 0xa3320
callq 0x4090
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_start_block
void code_start_block(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 14.06.2006*/
 indentation++;
 if (in_list(language, 4, C_LANGUAGE, CPP_LANGUAGE, JAVA_LANGUAGE, PASCAL_LANGUAGE))
   code_indentation(testcodefile);
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "{\n");
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "begin\n");
                         break;
   case MATLAB_LANGUAGE :
   case FORTRAN_LANGUAGE:break;
 };
 indentation++;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
incl 0x333e06(%rip)          # 0x3af1e8
movl %esi, %edi
movl $0x4, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x3, %r8d
movl $0x2, %r9d
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0x7b42c
cmpl $0x0, 0x333dda(%rip)    # 0x3af1e8
jle 0x7b42c
xorl %r14d, %r14d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r14d
cmpl 0x333dbe(%rip), %r14d   # 0x3af1e8
jl 0x7b413
cmpl $0x2, %ebp
jb 0x7b438
je 0x7b446
cmpl $0x3, %ebp
jne 0x7b45f
leaq 0x32dcf(%rip), %rdi     # 0xae20e
movl $0x2, %esi
jmp 0x7b452
leaq 0x31c2b(%rip), %rdi     # 0xad078
movl $0x6, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
incl 0x333d83(%rip)          # 0x3af1e8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_function_header
void code_function_header(FILE* testcodefile, char* functionname, int featurecount, PROGRAMMING_LANGUAGE_TYPE language)
{
 /*!Last Changed 18.05.2006*/
 switch (language){
   case C_LANGUAGE      :fprintf(testcodefile, "double %s(double* testdata){\n", functionname);
                         break;
   case CPP_LANGUAGE    :fprintf(testcodefile, "double test::%s(double* testdata){\n", functionname);
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "function %s(real testdata[1..%d]):real;\n", functionname, featurecount);
                         break;
   case JAVA_LANGUAGE   :fprintf(testcodefile, "public static double %s(double[] testdata){\n", functionname);
                         break;
   case MATLAB_LANGUAGE :fprintf(testcodefile, "function result = %s(testdata)\n", functionname);
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "real function %s(testdata)\nreal testdata(%d)\n", functionname, featurecount);
                         break;
 };
}

// Assembly:
cmpl $0x5, %ecx
ja 0x7b5af
movl %edx, %eax
movq %rsi, %rdx
movl %ecx, %ecx
leaq 0x31800(%rip), %rsi     # 0xacd64
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
leaq 0x31b53(%rip), %rsi     # 0xad0c7
jmp 0x7b598
leaq 0x31be2(%rip), %rsi     # 0xad15f
jmp 0x7b598
leaq 0x31b83(%rip), %rsi     # 0xad109
jmp 0x7b5a6
leaq 0x31ba3(%rip), %rsi     # 0xad132
jmp 0x7b598
leaq 0x31b4d(%rip), %rsi     # 0xad0e5
xorl %eax, %eax
jmp 0x42e0
leaq 0x31bd9(%rip), %rsi     # 0xad17f
movl %eax, %ecx
xorl %eax, %eax
jmp 0x42e0
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_1d_array_start
char code_1d_array_start(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, int index)
{
 /*!Last Changed 24.06.2006*/
 char ch = ',';
 if (index != 0 && index != -1)
  {
   switch (language){
     case C_LANGUAGE      :
     case CPP_LANGUAGE    :
     case JAVA_LANGUAGE   :
     case PASCAL_LANGUAGE :
     case FORTRAN_LANGUAGE:fprintf(testcodefile, ",");
                           break;
     case MATLAB_LANGUAGE :fprintf(testcodefile, "\n");
                           break;
   }
  }
 switch (language){
   case MATLAB_LANGUAGE:ch = ' ';
                        break;
   default             :break;
 }  
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "{");
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, "(");
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "(/");
                         break;
			case MATLAB_LANGUAGE :if (index == - 1)
																										 fprintf(testcodefile, "[");
																									break;
 }
	return ch;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
leal -0x1(%r14), %eax
movl %esi, %r12d
cmpl $-0x3, %eax
ja 0x7b613
movb $0x2c, %bpl
cmpl $0x5, %r15d
ja 0x7b624
leaq 0x31935(%rip), %rax     # 0xacf3c
movl (%rax,%r12,4), %edi
movq %rbx, %rsi
callq 0x4150
cmpl $0x4, %r15d
movl $0x20, %eax
movl $0x2c, %ebp
cmovel %eax, %ebp
cmpl $0x5, %r15d
ja 0x7b676
leaq 0x3174b(%rip), %rax     # 0xacd7c
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x7b, %edi
jmp 0x7b66e
movl $0x28, %edi
jmp 0x7b66e
leaq 0x32081(%rip), %rdi     # 0xad6d0
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
jmp 0x7b676
cmpl $-0x1, %r14d
jne 0x7b676
movl $0x5b, %edi
movq %rbx, %rsi
callq 0x4150
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/savecode.c
// Function: code_1d_array_end
void code_1d_array_end(FILE* testcodefile, PROGRAMMING_LANGUAGE_TYPE language, int index)
{
 /*!Last Changed 24.06.2006*/
 switch (language){
   case C_LANGUAGE      :
   case CPP_LANGUAGE    :
   case JAVA_LANGUAGE   :fprintf(testcodefile, "}");  
                         break;
   case PASCAL_LANGUAGE :fprintf(testcodefile, ")");
                         break;
   case FORTRAN_LANGUAGE:fprintf(testcodefile, "/)");
                         break;
			case MATLAB_LANGUAGE :if (index == - 1)
																										 fprintf(testcodefile, "]");
																									break;
 }
	if (index == -1)
		 fprintf(testcodefile, ";\n");  
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
cmpl $0x5, %esi
ja 0x7b6db
movl %esi, %eax
leaq 0x316fd(%rip), %rcx     # 0xacd94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x7d, %edi
jmp 0x7b6d3
movl $0x29, %edi
jmp 0x7b6d3
leaq 0x31af8(%rip), %rdi     # 0xad1ad
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
jmp 0x7b6db
cmpl $-0x1, %ebp
jne 0x7b6e0
movl $0x5d, %edi
movq %rbx, %rsi
callq 0x4150
cmpl $-0x1, %ebp
je 0x7b6e7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2b1cb(%rip), %rdi     # 0xa68b9
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x42c0
// File: /workspace/github_c_makefile_star2_O1/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 0x7b5da
movl %eax, %r13d
movsd (%r14), %xmm0
leaq 0x31a79(%rip), %rsi     # 0xad1b2
movq %r15, %rdi
movb $0x1, %al
callq 0x42e0
cmpl $0x2, %r12d
jl 0x7b77a
movzbl %r13b, %r13d
movl %r12d, %ebx
movl $0x1, %ebp
leaq 0x31a54(%rip), %r12     # 0xad1b0
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 0x7b75c
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 0x7b681
// File: /workspace/github_c_makefile_star2_O1/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 0x7b5da
movl %eax, %ebx
movl 0x30f08(%r15), %eax
cmpq $0x4, %rax
ja 0x7b81a
leaq 0x315d5(%rip), %rcx     # 0xacdac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl (%rax), %edx
leaq 0x3236c(%rip), %rsi     # 0xadb5d
movq %r12, %rdi
xorl %eax, %eax
callq 0x42e0
jmp 0x7b81a
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
leaq 0x319a2(%rip), %rsi     # 0xad1b2
movq %r12, %rdi
movb $0x1, %al
callq 0x42e0
cmpl $0x2, 0x1bc(%r15)
jl 0x7b8a8
movzbl %bl, %r13d
leaq 0x31248(%r15), %rbx
movl $0x1, %ebp
leaq 0x31581(%rip), %r14     # 0xacdc0
movl (%rbx), %eax
cmpq $0x4, %rax
ja 0x7b892
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 0x31952(%rip), %rsi     # 0xad1b7
movl %r13d, %edx
xorl %eax, %eax
callq 0x42e0
jmp 0x7b892
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd (%rax,%rbp,8), %xmm0
movq %r12, %rdi
leaq 0x31928(%rip), %rsi     # 0xad1b0
movl %r13d, %edx
movb $0x1, %al
callq 0x42e0
incq %rbp
movslq 0x1bc(%r15), %rax
addq $0x340, %rbx            # imm = 0x340
cmpq %rax, %rbp
jl 0x7b83f
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 0x7b681
// File: /workspace/github_c_makefile_star2_O1/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 0x7b5da
movl %eax, %r12d
movsd 0x8(%r15), %xmm0
leaq 0x318c0(%rip), %rsi     # 0xad1b2
movq %r14, %rdi
movb $0x1, %al
callq 0x42e0
cmpl $-0x1, 0x10(%r15)
je 0x7b932
movzbl %r12b, %r12d
addq $0x20, %r15
leaq 0x3189e(%rip), %r13     # 0xad1b0
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 0x7b912
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 0x7b681
// File: /workspace/github_c_makefile_star2_O1/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 0x7b5da
movl %eax, %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2e4b6
leaq 0x3182f(%rip), %rsi     # 0xad1b2
movq %r12, %rdi
movb $0x1, %al
callq 0x42e0
cmpl $0x3, 0x1c0(%r15)
jl 0x7b9d0
movzbl %bl, %r13d
movl $0x1, %ebx
leaq 0x31809(%rip), %rbp     # 0xad1b0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2e4b6
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 0x7b9a7
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 0x7b681
// File: /workspace/github_c_makefile_star2_O1/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, 0x333788(%rip)    # 0x3af1e8
jle 0x7ba7e
xorl %r12d, %r12d
movl $0x20, %edi
movq %r15, %rsi
callq 0x4150
incl %r12d
cmpl 0x33376c(%rip), %r12d   # 0x3af1e8
jl 0x7ba65
cmpl $0x5, %ebp
ja 0x7baab
movl %ebp, %eax
leaq 0x314f8(%rip), %rcx     # 0xacf84
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_O1/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, %r14d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x0, 0x3332b6(%rip)    # 0x3af1e8
jle 0x7bf50
xorl %r12d, %r12d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r12d
cmpl 0x33329a(%rip), %r12d   # 0x3af1e8
jl 0x7bf37
cmpl $0x5, %ebp
ja 0x7bff2
movl %ebp, %eax
leaq 0x30e72(%rip), %rcx     # 0xacdd4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x312fb(%rip), %rsi     # 0xad26d
jmp 0x7bf9d
leaq 0x312fe(%rip), %rsi     # 0xad279
jmp 0x7bf84
leaq 0x31278(%rip), %rsi     # 0xad1fc
movq %rbx, %rdi
movq %r15, %rdx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x42e0
jmp 0x7bfaa
leaq 0x312e7(%rip), %rsi     # 0xad284
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x42e0
cmpl $0x5, %ebp
jne 0x7bff2
cmpl $0x0, 0x333232(%rip)    # 0x3af1e8
jle 0x7bfd1
xorl %ebp, %ebp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %ebp
cmpl 0x333219(%rip), %ebp    # 0x3af1e8
jl 0x7bfba
leaq 0x312ba(%rip), %rdi     # 0xad292
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
// File: /workspace/github_c_makefile_star2_O1/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, 0x3331d3(%rip)    # 0x3af1e8
jle 0x7c033
xorl %r12d, %r12d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r12d
cmpl 0x3331b7(%rip), %r12d   # 0x3af1e8
jl 0x7c01a
cmpl $0x5, %ebp
ja 0x7c0d5
movl %ebp, %eax
leaq 0x30da7(%rip), %rcx     # 0xacdec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x31245(%rip), %rsi     # 0xad29a
jmp 0x7c080
leaq 0x311c1(%rip), %rsi     # 0xad21f
jmp 0x7c067
leaq 0x311af(%rip), %rsi     # 0xad216
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x42e0
jmp 0x7c08d
leaq 0x31226(%rip), %rsi     # 0xad2a6
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x42e0
cmpl $0x5, %ebp
jne 0x7c0d5
cmpl $0x0, 0x33314f(%rip)    # 0x3af1e8
jle 0x7c0b4
xorl %ebp, %ebp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %ebp
cmpl 0x333136(%rip), %ebp    # 0x3af1e8
jl 0x7c09d
leaq 0x311d7(%rip), %rdi     # 0xad292
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
// File: /workspace/github_c_makefile_star2_O1/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, 0x3330ef(%rip)    # 0x3af1e8
jle 0x7c117
xorl %r15d, %r15d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r15d
cmpl 0x3330d3(%rip), %r15d   # 0x3af1e8
jl 0x7c0fe
cmpl $0x5, %ebp
ja 0x7c1bf
movl %ebp, %eax
leaq 0x30cdb(%rip), %rcx     # 0xace04
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3117b(%rip), %rsi     # 0xad2b4
jmp 0x7c166
leaq 0x31180(%rip), %rsi     # 0xad2c2
jmp 0x7c14b
leaq 0x3108b(%rip), %rsi     # 0xad1d6
movq %rbx, %rdi
movq %r14, %rdx
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x42e0
jmp 0x7c175
leaq 0x31169(%rip), %rsi     # 0xad2cf
movq %rbx, %rdi
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x42e0
cmpl $0x5, %ebp
jne 0x7c1bf
cmpl $0x0, 0x333067(%rip)    # 0x3af1e8
jle 0x7c19c
xorl %ebp, %ebp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %ebp
cmpl 0x33304e(%rip), %ebp    # 0x3af1e8
jl 0x7c185
leaq 0x310ef(%rip), %rdi     # 0xad292
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
// File: /workspace/github_c_makefile_star2_O1/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 0x7c218
movq %rdi, %rcx
movl $0xb, %eax
btl %esi, %eax
jae 0x7c1ea
leaq 0x2fed9(%rip), %rdi     # 0xac0bc
movl $0x2, %esi
jmp 0x7c20e
movl $0x30, %eax
btl %esi, %eax
jae 0x7c202
leaq 0x2d2c9(%rip), %rdi     # 0xa94c4
movl $0x4, %esi
jmp 0x7c20e
leaq 0x310d6(%rip), %rdi     # 0xad2df
movl $0x5, %esi
movl $0x1, %edx
jmp 0x42c0
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x332cd5(%rip)    # 0x3af1e8
jle 0x7c531
xorl %r15d, %r15d
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %r15d
cmpl 0x332cb9(%rip), %r15d   # 0x3af1e8
jl 0x7c518
cmpl $0x5, %ebp
ja 0x7c553
movl %ebp, %eax
leaq 0x30aa5(%rip), %rcx     # 0xacfe4
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x42e0
addl $0x2, 0x332c8e(%rip)    # 0x3af1e8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x332c74(%rip), %eax    # 0x3af1e8
leal -0x2(%rax), %ecx
movl %ecx, 0x332c6b(%rip)    # 0x3af1e8
cmpl $0x3, %eax
jl 0x7c59e
xorl %r14d, %r14d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r14d
cmpl 0x332c4c(%rip), %r14d   # 0x3af1e8
jl 0x7c585
cmpl $0x5, %ebp
ja 0x7c5df
movl %ebp, %eax
leaq 0x30888(%rip), %rcx     # 0xace34
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2fb00(%rip), %rdi     # 0xac0bc
movl $0x2, %esi
jmp 0x7c5f0
leaq 0x30d15(%rip), %rdi     # 0xad2df
movl $0x5, %esi
jmp 0x7c5f0
leaq 0x30e08(%rip), %rdi     # 0xad3e0
movl $0xb, %esi
jmp 0x7c5f0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2ced9(%rip), %rdi     # 0xa94c4
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x42c0
// File: /workspace/github_c_makefile_star2_O1/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, 0x332a76(%rip)    # 0x3af1e8
jle 0x7c78d
xorl %ebp, %ebp
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %ebp
cmpl 0x332a5d(%rip), %ebp    # 0x3af1e8
jl 0x7c776
cmpl $0x5, %ebx
ja 0x7c7af
movl %ebx, %eax
leaq 0x30861(%rip), %rcx     # 0xacffc
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 0x7b3d3
// File: /workspace/github_c_makefile_star2_O1/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, 0x3329ce(%rip)    # 0x3af1e8
jle 0x7c835
xorl %ebp, %ebp
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %ebp
cmpl 0x3329b5(%rip), %ebp    # 0x3af1e8
jl 0x7c81e
cmpl $0x5, %ebx
ja 0x7c857
movl %ebx, %eax
leaq 0x307d1(%rip), %rcx     # 0xad014
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 0x7b3d3
// File: /workspace/github_c_makefile_star2_O1/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 0x7b46a
cmpl $0x0, 0x332927(%rip)    # 0x3af1e8
jle 0x7c8dc
xorl %ebp, %ebp
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %ebp
cmpl 0x33290e(%rip), %ebp    # 0x3af1e8
jl 0x7c8c5
leaq 0x30b83(%rip), %rdi     # 0xad466
movl $0x5, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x42c0
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x7b3d3
// File: /workspace/github_c_makefile_star2_O1/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 0x3328d6(%rip)          # 0x3af1e8
movl %esi, %edi
movl $0x2, %esi
movl $0x4, %edx
movl $0x5, %ecx
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0x7c934
decl 0x3328b4(%rip)          # 0x3af1e8
cmpl $0x0, 0x3328ad(%rip)    # 0x3af1e8
jle 0x7c956
xorl %ebp, %ebp
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %ebp
cmpl 0x332894(%rip), %ebp    # 0x3af1e8
jl 0x7c93f
cmpl $0x5, %ebx
ja 0x7c9b0
movl %ebx, %eax
leaq 0x304e8(%rip), %rcx     # 0xace4c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2f748(%rip), %rdi     # 0xac0bc
movl $0x2, %esi
jmp 0x7c9a3
leaq 0x3095d(%rip), %rdi     # 0xad2df
movl $0x5, %esi
jmp 0x7c9a3
leaq 0x30adc(%rip), %rdi     # 0xad46c
movl $0x6, %esi
jmp 0x7c9a3
leaq 0x2cb26(%rip), %rdi     # 0xa94c4
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 0x39a80
testl %eax, %eax
jne 0x7c9d2
decl 0x332816(%rip)          # 0x3af1e8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x332802(%rip)          # 0x3af1e8
movl %esi, %edi
movl $0x2, %esi
movl $0x4, %edx
movl $0x5, %ecx
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0x7ca08
decl 0x3327e0(%rip)          # 0x3af1e8
cmpl $0x0, 0x3327d9(%rip)    # 0x3af1e8
jle 0x7ca2a
xorl %ebp, %ebp
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %ebp
cmpl 0x3327c0(%rip), %ebp    # 0x3af1e8
jl 0x7ca13
cmpl $0x5, %ebx
ja 0x7ca78
movl $0xb, %eax
btl %ebx, %eax
jae 0x7ca47
leaq 0x2f67c(%rip), %rdi     # 0xac0bc
movl $0x2, %esi
jmp 0x7ca6b
movl $0x30, %eax
btl %ebx, %eax
jae 0x7ca5f
leaq 0x2ca6c(%rip), %rdi     # 0xa94c4
movl $0x4, %esi
jmp 0x7ca6b
leaq 0x30879(%rip), %rdi     # 0xad2df
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 0x39a80
testl %eax, %eax
jne 0x7ca9a
decl 0x33274e(%rip)          # 0x3af1e8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x3325d5(%rip)    # 0x3af1e8
jle 0x7cc31
xorl %r15d, %r15d
movl $0x20, %edi
movq %r14, %rsi
callq 0x4150
incl %r15d
cmpl 0x3325b9(%rip), %r15d   # 0x3af1e8
jl 0x7cc18
cmpl $0x5, %ebx
ja 0x7ccdc
movl %ebx, %eax
leaq 0x30239(%rip), %rcx     # 0xace7c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x308fa(%rip), %rsi     # 0xad54d
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 0x7ccdc
movq %rbp, %rdi
callq 0x4200
testl %eax, %eax
jle 0x7ccc1
leaq 0x308ea(%rip), %rsi     # 0xad570
jmp 0x7ccc8
leaq 0x30927(%rip), %rsi     # 0xad5b6
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq (%rsp), %r8
movq %rbp, %r9
jmp 0x7ccb8
leaq 0x308fa(%rip), %rsi     # 0xad5a2
movq %r14, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
movq (%rsp), %r9
xorl %eax, %eax
callq 0x42e0
jmp 0x7ccdc
leaq 0x308bf(%rip), %rsi     # 0xad587
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 0x7b3d3
// File: /workspace/github_c_makefile_star2_O1/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, 0x3324e4(%rip)    # 0x3af1e8
jle 0x7cd22
xorl %r14d, %r14d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r14d
cmpl 0x3324c8(%rip), %r14d   # 0x3af1e8
jl 0x7cd09
cmpl $0x5, %ebp
ja 0x7cd44
leaq 0x30673(%rip), %rdi     # 0xad3a1
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_O1/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 0x332490(%rip), %eax    # 0x3af1e8
leal -0x1(%rax), %ecx
movl %ecx, 0x332487(%rip)    # 0x3af1e8
cmpl $0x2, %eax
jl 0x7cd82
xorl %r14d, %r14d
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4150
incl %r14d
cmpl 0x332468(%rip), %r14d   # 0x3af1e8
jl 0x7cd69
cmpl $0x5, %ebp
ja 0x7cddc
movl %ebp, %eax
leaq 0x30104(%rip), %rcx     # 0xace94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2f31c(%rip), %rdi     # 0xac0bc
movl $0x2, %esi
jmp 0x7cdcf
leaq 0x30531(%rip), %rdi     # 0xad2df
movl $0x5, %esi
jmp 0x7cdcf
leaq 0x3080e(%rip), %rdi     # 0xad5ca
movl $0x6, %esi
jmp 0x7cdcf
leaq 0x2c6fa(%rip), %rdi     # 0xa94c4
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x42c0
decl 0x332406(%rip)          # 0x3af1e8
popq %rbx
popq %r14
popq %rbp
retq