LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: goto_endconstructor
void goto_endconstructor(int* variable, char* constructorname, char* endconstructorname, char** code, int linecount, int* instruction_pointer)
{
 /*!Last Changed 14.07.2006*/
 char templine[READLINELENGTH], *p;
 int howmany = 1, i;
 *variable = 0;
 for (i = *instruction_pointer + 1; i < linecount; i++)
  {
   strcpy(templine, code[i]);
   p = strtok(templine," \t\n");
   if (strcmp(p, constructorname) == 0)
     howmany++;
   else
     if (strcmp(p, endconstructorname) == 0)
      {
       howmany--;
       if (howmany == 0)
         break;
      }
  }
 *instruction_pointer = i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a160, %rsp          # imm = 0x7A160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movl $0x1, -0x7a15c(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x30(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x7a160(%rbp)
movl -0x7a160(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x490a9
leaq -0x7a150(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x7a160(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4220
leaq -0x7a150(%rbp), %rdi
leaq 0x9cd0b(%rip), %rsi     # 0xe5d39
callq 0x4230
movq %rax, -0x7a158(%rbp)
movq -0x7a158(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4210
cmpl $0x0, %eax
jne 0x49060
movl -0x7a15c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7a15c(%rbp)
jmp 0x49093
movq -0x7a158(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4210
cmpl $0x0, %eax
jne 0x49091
movl -0x7a15c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x7a15c(%rbp)
cmpl $0x0, -0x7a15c(%rbp)
jne 0x4908f
jmp 0x490a9
jmp 0x49091
jmp 0x49093
jmp 0x49095
movl -0x7a160(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7a160(%rbp)
jmp 0x48ff6
movl -0x7a160(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
addq $0x7a160, %rsp          # imm = 0x7A160
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: set_variable
int set_variable(char* name, void* value)
{
 /*!Last Changed 22.12.2006 added matrix type*/
 /*!Last Changed 03.01.2006*/
	/*!Last Changed 05.11.2003 Added File variable with type 4*/
 /*!Last Changed 02.05.2002*/
 variableptr myvar;
 myvar = get_variable(name);
 if (!myvar)
  {
   printf(m1437, name);
   return 0;
  }
 switch (myvar->type)
  {
   case INTEGER_TYPE:myvar->value.intvalue = atoi((char *)value);
                     break;
   case REAL_TYPE   :myvar->value.floatvalue = atof((char *)value);
                     break;
   case ARRAY_TYPE  :set_multidimensional_array(myvar, value);
                     break;
   case STRING_TYPE :
			case FILE_TYPE   :if (myvar->value.stringvalue)
                       safe_free(myvar->value.stringvalue);
                     myvar->value.stringvalue = strcopy(myvar->value.stringvalue, (char *)value);
                     break;
   case MATRIX_TYPE :if (myvar->value.matrixvalue)
																					 {
																						 matrix_free(*(myvar->value.matrixvalue));
																						 safe_free(myvar->value.matrixvalue);
                       myvar->value.matrixvalue = NULL;
																					 }
                     if (strcmp((char *)value, "0") != 0)
  				                 myvar->value.matrixvalue = (matrixptr)value;
                     break;
   default          :break;
  }
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b5e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x493f2
movq -0x10(%rbp), %rsi
leaq 0x9ce78(%rip), %rdi     # 0xe6257
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x494f4
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x5, %rax
ja 0x494eb
movq -0x28(%rbp), %rax
leaq 0x9c43b(%rip), %rcx     # 0xe584c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0x41c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
jmp 0x494ed
movq -0x18(%rbp), %rdi
callq 0x4100
movq -0x20(%rbp), %rax
movsd %xmm0, 0x28(%rax)
jmp 0x494ed
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4ca30
jmp 0x494ed
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x49472
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x52e80
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x54ba0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x494ed
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x494c8
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x59ea0
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x52e80
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rdi
leaq 0xa3db4(%rip), %rsi     # 0xed287
callq 0x4210
cmpl $0x0, %eax
je 0x494e9
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x494ed
jmp 0x494ed
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: check_parameter_type
int check_parameter_type(char* varname, VARIABLE_TYPE vartype, variableptr variables, int variablecount)
{
 /*!Last Changed 21.12.2006*/
 int k;
 Variable myvar;
 k = return_variable_index(varname, variables, variablecount);
 if (k == -1)
   return FAILURE;
 else
  {
   myvar = variables[k];
   while (myvar.type == ARRAY_TYPE) 
     myvar = myvar.value.array[0];
   if (myvar.type != vartype)
     return FAILURE;
  }
 return SUCCESS; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x495a0
movl %eax, -0x28(%rbp)
cmpl $-0x1, -0x28(%rbp)
jne 0x49538
movl $0x0, -0x4(%rbp)
jmp 0x49589
movq -0x20(%rbp), %rsi
movslq -0x28(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
leaq -0x58(%rbp), %rdi
movl $0x30, %edx
callq 0x42b0
cmpl $0x3, -0x58(%rbp)
jne 0x4956f
movq -0x30(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movl $0x30, %edx
callq 0x42b0
jmp 0x49555
movl -0x58(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x49580
movl $0x0, -0x4(%rbp)
jmp 0x49589
jmp 0x49582
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: return_variable_index
int return_variable_index(char* name, variableptr vars, int varcount)
{
 /*!Last Changed 02.05.2002*/
 int i;
 char* st = array_variable(name);
 if (st)
  {
   for (i = 0; i < varcount; i++)
     if (strcmp(st, vars[i].name) == 0)
      {
       safe_free(st);
       return i;
      }
  }
 else
  {
   for (i = 0; i < varcount; i++)
     if (strcmp(name, vars[i].name)==0)
       return i;
  }
	if (st)
		 safe_free(st);
 return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4ba60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x49617
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x49615
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rsi
callq 0x4210
cmpl $0x0, %eax
jne 0x49608
movq -0x28(%rbp), %rdi
callq 0x52e80
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x49675
jmp 0x4960a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x495ce
jmp 0x4965e
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4965c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rsi
callq 0x4210
cmpl $0x0, %eax
jne 0x4964f
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x49675
jmp 0x49651
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4961e
jmp 0x4965e
cmpq $0x0, -0x28(%rbp)
je 0x4966e
movq -0x28(%rbp), %rdi
callq 0x52e80
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: add_default_variables
void add_default_variables(variableptr* variables, int* variablecount)
{
	/*!Last Changed 06.08.2007*/
 add_variable(REAL_TYPE, default_variables, DEFAULT_VARIABLE_COUNT, variables, variablecount);
 add_variable(STRING_TYPE, default_string_variables, DEFAULT_STRING_VARIABLE_COUNT, variables, variablecount);
 add_variable(STRING_TYPE, default_array_variables, DEFAULT_ARRAY_VARIABLE_COUNT, variables, variablecount);
 add_variable(STRING_TYPE, default_performance_variables, DEFAULT_PERFORMANCE_VARIABLE_COUNT, variables, variablecount);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x1, %edi
leaq 0xbb17c(%rip), %rsi     # 0x104db0
movl $0xa, %edx
callq 0x49ca0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x2, %edi
leaq 0xbb1ae(%rip), %rsi     # 0x104e00
movl $0xa, %edx
callq 0x49ca0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x2, %edi
leaq 0xbb1e0(%rip), %rsi     # 0x104e50
movl $0x1e, %edx
callq 0x49ca0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x2, %edx
leaq 0xbb2b2(%rip), %rsi     # 0x104f40
movl %edx, %edi
callq 0x49ca0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: check_of_variables
int check_of_variables(char* st, variableptr variables, int variablecount)
{
	/*!Last Changed 12.10.2004*/
	int i = 0, len = strlen(st), mode = 0, start, end, j;
	char varname[READLINELENGTH];
	while (i < len)
	 {
		 if (st[i] == '%')
			 {
				 mode = (mode + 1) % 2;
					if (mode == 1)
						 start = i + 1;
					else
					 {
						 end = i - 1;
							if (start < end)
							 {
								 for (j = start; j <= end; j++)
										 varname[j - start] = st[j];
									varname[j - start] = '\0';
         if (return_variable_index(varname, variables, variablecount) == -1)
										 return 0;
							 }
					 }
			 }
		 i++;
	 }
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a160, %rsp          # imm = 0x7A160
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4150
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4acfc
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x25, %eax
jne 0x4acee
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, -0x28(%rbp)
cmpl $0x1, -0x28(%rbp)
jne 0x4ac73
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4acec
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x4acea
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jg 0x4acb7
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb (%rax,%rcx), %cl
movl -0x34(%rbp), %eax
subl -0x2c(%rbp), %eax
cltq
movb %cl, -0x7a160(%rbp,%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4ac8a
movl -0x34(%rbp), %eax
subl -0x2c(%rbp), %eax
cltq
movb $0x0, -0x7a160(%rbp,%rax)
leaq -0x7a160(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x495a0
cmpl $-0x1, %eax
jne 0x4ace8
movl $0x0, -0x4(%rbp)
jmp 0x4ad03
jmp 0x4acea
jmp 0x4acec
jmp 0x4acee
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4ac30
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x7a160, %rsp          # imm = 0x7A160
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: free_variables
void free_variables(variableptr vars, int count)
{
 /*!Last Changed 22.12.2006 added matrix type*/
 /*!Last Changed 04.01.2006 added free_multidimensional_array*/
	/*!Last Changed 29.11.2004*/
	int i;
 for (i = 0; i < count; i++)
	 {
		 safe_free(vars[i].name);
			switch (vars[i].type)
			 {
			  case INTEGER_TYPE:
					case REAL_TYPE   :break;
					case STRING_TYPE :
					case FILE_TYPE   :if (vars[i].value.stringvalue)
													            safe_free(vars[i].value.stringvalue);
						                 break;
     case MATRIX_TYPE :if (vars[i].value.matrixvalue)
                        {
                         matrix_free(*(vars[i].value.matrixvalue));
                         safe_free(vars[i].value.matrixvalue);
                        }
                       break;
					case ARRAY_TYPE  :free_multidimensional_array(&(vars[i]));
												           break;
     default          :break;
			 }
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4ae2d
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq 0x18(%rax,%rcx), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movl (%rax,%rcx), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x4ae1b
movq -0x18(%rbp), %rax
leaq 0x9ab34(%rip), %rcx     # 0xe58ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x4ae1d
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x28(%rax)
je 0x4adb4
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
callq 0x52e80
jmp 0x4ae1d
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x28(%rax)
je 0x4ae03
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x59ea0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
callq 0x52e80
jmp 0x4ae1d
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x4cbb0
jmp 0x4ae1d
jmp 0x4ae1d
jmp 0x4ae1f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4ad26
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: charatindex
void charatindex(char* name, int index)
{
	/*!Last Changed 27.01.2004*/
	char* st;
	char message[2];
	st = get_string_value(name);
	if (!st)
		 return;
	sprintf(message, "%c", st[index - 1]);
	set_default_string_variable("sout1", message);
	safe_free(st);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4aeb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4ae65
jmp 0x4aea1
leaq -0x1a(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edx
leaq 0x9ba97(%rip), %rsi     # 0xe6918
movb $0x0, %al
callq 0x4170
leaq -0x1a(%rbp), %rsi
leaq 0x9acf4(%rip), %rdi     # 0xe5b87
callq 0x4af70
movq -0x18(%rbp), %rdi
callq 0x52e80
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: get_string_value
char* get_string_value(char* name)
{
 /*!Last Changed 03.01.2006*/
	/*!Last Changed 06.02.2004 put controls*/
 /*!Last Changed 27.01.2004*/
	char message[READLINELENGTH], *st = NULL;
	variableptr myvar;
 myvar = get_and_check_variable_type(name, 2, "string");
	if (!myvar)
			return NULL;
	if (myvar->value.stringvalue)
		 strcpy(message, myvar->value.stringvalue);
	else
		{
			printf(m1295, name);
			return NULL;
		}
	st = strcopy(st, message);
	return st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a140, %rsp          # imm = 0x7A140
movq %rdi, -0x10(%rbp)
movq $0x0, -0x7a138(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x9c2f4(%rip), %rdx     # 0xe71ce
callq 0x4b280
movq %rax, -0x7a140(%rbp)
cmpq $0x0, -0x7a140(%rbp)
jne 0x4aefa
movq $0x0, -0x8(%rbp)
jmp 0x4af62
movq -0x7a140(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x4af21
leaq -0x7a130(%rbp), %rdi
movq -0x7a140(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x4220
jmp 0x4af3d
movq -0x10(%rbp), %rsi
leaq 0x9b220(%rip), %rdi     # 0xe614c
movb $0x0, %al
callq 0x4030
movq $0x0, -0x8(%rbp)
jmp 0x4af62
movq -0x7a138(%rbp), %rdi
leaq -0x7a130(%rbp), %rsi
callq 0x54ba0
movq %rax, -0x7a138(%rbp)
movq -0x7a138(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x7a140, %rsp          # imm = 0x7A140
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: set_default_string_variable
int set_default_string_variable(char* name, char* st)
{
 /*!Last Changed 03.01.2006*/
 /*!Last Changed 05.05.2002*/
 variableptr myvar;
 myvar = get_variable(name);
 if (!myvar)
   return 0;
 if (myvar->value.stringvalue)
   safe_free(myvar->value.stringvalue);
 myvar->value.stringvalue = strcopy(myvar->value.stringvalue, st);
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b5e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4af9d
movl $0x0, -0x4(%rbp)
jmp 0x4afd8
movq -0x20(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x4afb5
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x52e80
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x54ba0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: stringlength
void stringlength(char* name)
{
	/*!Last Changed 27.01.2004*/
	char* st;
	st = get_string_value(name);
	if (!st)
		 return;
	set_default_variable("out1", strlen(st) + 0.0);
	safe_free(st);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4aeb0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4b012
jmp 0x4b05e
movq -0x10(%rbp), %rdi
callq 0x4150
movq %rax, %xmm0
movaps 0x9aa79(%rip), %xmm1    # 0xe5aa0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x9aa7d(%rip), %xmm1    # 0xe5ab0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
leaq 0x9ab38(%rip), %rdi     # 0xe5b88
callq 0x4b070
movq -0x10(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: set_default_variable
int set_default_variable(char* name, double value)
{
 /*!Last Changed 03.01.2006*/
 /*!Last Changed 16.04.2002*/
 variableptr myvar;
 myvar = get_variable(name);
 if (!myvar)
   return 0;
 myvar->value.floatvalue = value;
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b5e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4b09e
movl $0x0, -0x4(%rbp)
jmp 0x4b0b3
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: countchar
void countchar(char* name, char* ch)
{
 /*!Last Changed 27.01.2004*/
	int count = 0, i, len;
	char* st;
	st = get_string_value(name);
	if (!st)
		 return;
	len = strlen(st);
	for (i = 0; i < len; i++)
		 if (st[i] == ch[0])
				 count++;
	set_default_variable("out1", count + 0.0);
	safe_free(st);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4aeb0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4b0ed
jmp 0x4b156
movq -0x28(%rbp), %rdi
callq 0x4150
movl %eax, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4b135
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x4b128
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4b12a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4b100
cvtsi2sdl -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
leaq 0x9aa40(%rip), %rdi     # 0xe5b88
callq 0x4b070
movq -0x28(%rbp), %rdi
callq 0x52e80
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: tokenize
void tokenize(char* name, char* separators)
{
 /*!Last Changed 03.01.2006*/
 /*!Last Changed 27.01.2004*/
 int i, count;
	char message[READLINELENGTH];
 char* tokens[1000];
	char varname[15];
	variableptr myvar;
 myvar = get_and_check_variable_type(name, 2, "string");
	if (!myvar)
			return;
 if (myvar->value.stringvalue)
  	strcpy(message, myvar->value.stringvalue);
	else
		{
			printf(m1295, name);
			return;
		}
 stringlist(message, separators, tokens, &count);
 for (i = 0; i < count; i++)
  {
   sprintf(varname,"aout1[%d]", i + 1);
   set_variable(varname, tokens[i]);
   safe_free(tokens[i]);
  }
	set_default_variable("out1", count + 0.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7c0a0, %rsp          # imm = 0x7C0A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x9c04b(%rip), %rdx     # 0xe71ce
callq 0x4b280
movq %rax, -0x7c098(%rbp)
cmpq $0x0, -0x7c098(%rbp)
jne 0x4b19e
jmp 0x4b26d
movq -0x7c098(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x4b1c5
leaq -0x7a140(%rbp), %rdi
movq -0x7c098(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x4220
jmp 0x4b1dc
movq -0x8(%rbp), %rsi
leaq 0x9af7c(%rip), %rdi     # 0xe614c
movb $0x0, %al
callq 0x4030
jmp 0x4b26d
leaq -0x7a140(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x7c080(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x54bf0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4b255
leaq -0x7c08f(%rbp), %rdi
movl -0x14(%rbp), %edx
addl $0x1, %edx
leaq 0x9af59(%rip), %rsi     # 0xe6173
movb $0x0, %al
callq 0x4170
leaq -0x7c08f(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq -0x7c080(%rbp,%rax,8), %rsi
callq 0x493b0
movslq -0x14(%rbp), %rax
movq -0x7c080(%rbp,%rax,8), %rdi
callq 0x52e80
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4b1fe
cvtsi2sdl -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
leaq 0x9a920(%rip), %rdi     # 0xe5b88
callq 0x4b070
addq $0x7c0a0, %rsp          # imm = 0x7C0A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: get_and_check_variable_type
variableptr get_and_check_variable_type(char* name, VARIABLE_TYPE validtype, char* message)
{
 /*!Last Changed 03.01.2006*/
 variableptr myvar;
 myvar = get_variable(name);
 if (!myvar)
   printf(m1302, name);
 else
   if (myvar->type != validtype)
    {
     printf(m1303, message);
     return NULL;
    }
 return myvar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b5e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4b2bb
movq -0x10(%rbp), %rsi
leaq 0x9afc8(%rip), %rdi     # 0xe627a
movb $0x0, %al
callq 0x4030
jmp 0x4b2e4
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x4b2e2
movq -0x20(%rbp), %rsi
leaq 0x9afc5(%rip), %rdi     # 0xe6296
movb $0x0, %al
callq 0x4030
movq $0x0, -0x8(%rbp)
jmp 0x4b2ec
jmp 0x4b2e4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: read_userfile
void read_userfile(char* name, char* varname)
{
 /*!Last Changed 03.01.2006*/
	/*!Last Changed 29.10.2005*/
 /*!Last Changed 21.10.2004*/
 /*!Last Changed 27.01.2004*/
	char message[READLINELENGTH];
	variableptr myvar;
 myvar = get_and_check_variable_type(name, 4, "file");
	if (!myvar)
			return;
	if (myvar->userfile)
		 fscanf(myvar->userfile, "%s", message);
	set_variable(varname, message);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a140, %rsp          # imm = 0x7A140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
leaq 0xa31b7(%rip), %rdx     # 0xee4da
callq 0x4b280
movq %rax, -0x7a138(%rbp)
cmpq $0x0, -0x7a138(%rbp)
jne 0x4b33b
jmp 0x4b379
movq -0x7a138(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4b369
movq -0x7a138(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x7a130(%rbp), %rdx
leaq 0x99736(%rip), %rsi     # 0xe4a98
movb $0x0, %al
callq 0x4070
movq -0x10(%rbp), %rdi
leaq -0x7a130(%rbp), %rsi
callq 0x493b0
addq $0x7a140, %rsp          # imm = 0x7A140
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: get_variable
variableptr get_variable(char* st)
{
	/*!Last Changed 02.01.2006*/
	int ind;
	char* st2;
 variableptr myvar;
 ind = return_variable_index(st, vars, varcount);
 if (ind != -1)
		{
   st2 = array_variable(st);
   if (st2)
				{
     myvar = array_pos(st, &(vars[ind]));
     safe_free(st2);
					return myvar;
			 }
   else
				 return &(vars[ind]);
	 }
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xba241(%rip), %rax     # 0x105838
movq (%rax), %rsi
leaq 0xb9ed3(%rip), %rax     # 0x1054d4
movl (%rax), %edx
callq 0x495a0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x4b675
movq -0x10(%rbp), %rdi
callq 0x4ba60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4b65a
movq -0x10(%rbp), %rdi
leaq 0xba208(%rip), %rax     # 0x105838
movq (%rax), %rsi
movslq -0x14(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rsi
callq 0x4c290
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x52e80
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4b67d
leaq 0xba1d7(%rip), %rax     # 0x105838
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x4b67d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: write_userfile
void write_userfile(char* name, char* line)
{
 /*!Last Changed 03.01.2006*/
 /*!Last Changed 05.11.2003*/
	variableptr myvar;
 myvar = get_and_check_variable_type(name, 4, "file");
	if (!myvar)
			return;
	if (myvar->userfile)
			fprintf(myvar->userfile, "%s\n", line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
leaq 0xa2e2a(%rip), %rdx     # 0xee4da
callq 0x4b280
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4b6c2
jmp 0x4b6e7
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4b6e7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xa15ee(%rip), %rsi     # 0xeccce
movb $0x0, %al
callq 0x4280
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: open_userfile
void open_userfile(char* name, char* filetype)
{
 /*!Last Changed 03.01.2006*/
	/*!Last Changed 27.01.2004*/
 /*!Last Changed 10.11.2003*/
 variableptr myvar;
 myvar = get_and_check_variable_type(name, 4, "file");
	if (!myvar)
			return;
	if (!(myvar->userfile))
		{
			myvar->userfile = fopen(myvar->value.stringvalue, filetype);
			if (!(myvar->userfile))
					printf(m1296, myvar->value.stringvalue, filetype);
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
leaq 0xa2dca(%rip), %rdx     # 0xee4da
callq 0x4b280
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4b722
jmp 0x4b770
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4b770
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4b76e
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rdx
leaq 0x9aa52(%rip), %rdi     # 0xe61b9
movb $0x0, %al
callq 0x4030
jmp 0x4b770
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: close_userfile
void close_userfile(char* name)
{
 /*!Last Changed 03.01.2006*/
 /*!Last Changed 05.11.2003*/
 variableptr myvar;
 myvar = get_and_check_variable_type(name, 4, "file");
	if (!myvar)
			return;
	if (myvar->userfile)
		{
			fclose(myvar->userfile);
			myvar->userfile = NULL;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x4, %esi
leaq 0xa2d3e(%rip), %rdx     # 0xee4da
callq 0x4b280
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4b7ae
jmp 0x4b7d2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4b7d2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4250
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: array_variable
char* array_variable(char* name)
{
	/*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 02.05.2002*/
 char* st = NULL;
 int i, len;
	len = strlen(name);
 for (i = 0; i < len; i++)
   if (name[i] == '[')
    {
     st = safemalloc(sizeof(char) * (i + 1), "array_variable", 7);
     strncpy(st, name, i);
     st[i] = '\0';
     break;
    }
 return st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4150
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4baee
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5b, %eax
jne 0x4bae1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
leaq 0x9a767(%rip), %rsi     # 0xe621b
movl $0x7, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x4260
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x4baee
jmp 0x4bae3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4ba87
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: check_var
BOOLEAN check_var(struct variable var, char* value)
{
	/*!Last Changed 05.11.2003 Added file variable with type 4*/
 /*!Last Changed 02.05.2002*/
 int tmp;
 double tmpd;
 switch (var.type)
  {
   case INTEGER_TYPE:tmp = atoi(value);
                     if (var.value.intvalue == tmp)
                       return BOOLEAN_TRUE;
                     else
                       return BOOLEAN_FALSE;
   case REAL_TYPE   :tmpd = atof(value);
                     if (var.value.floatvalue == tmpd)
                       return BOOLEAN_TRUE;
                     else
                       return BOOLEAN_FALSE;
   case STRING_TYPE :
			case FILE_TYPE   :if (strcmp(var.value.stringvalue, value) == 0)
                       return BOOLEAN_TRUE;
                     else
                       return BOOLEAN_FALSE;
   default          :break;
  }
 return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x4, %rax
ja 0x4bbbe
movq -0x28(%rbp), %rax
leaq 0x99dc5(%rip), %rcx     # 0xe58f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x41c0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x14(%rbp)
movl 0x28(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x4bb5b
movl $0x1, -0x4(%rbp)
jmp 0x4bbc7
movl $0x0, -0x4(%rbp)
jmp 0x4bbc7
movq -0x10(%rbp), %rdi
callq 0x4100
movq -0x30(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movsd 0x28(%rax), %xmm0
ucomisd -0x20(%rbp), %xmm0
jne 0x4bb8d
jp 0x4bb8d
movl $0x1, -0x4(%rbp)
jmp 0x4bbc7
movl $0x0, -0x4(%rbp)
jmp 0x4bbc7
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4210
cmpl $0x0, %eax
jne 0x4bbb5
movl $0x1, -0x4(%rbp)
jmp 0x4bbc7
movl $0x0, -0x4(%rbp)
jmp 0x4bbc7
jmp 0x4bbc0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: get_value
double get_value(struct variable var)
{
/*!Last Changed 02.05.2002*/
 switch (var.type)
  {
   case INTEGER_TYPE:return var.value.intvalue;
   case REAL_TYPE   :return var.value.floatvalue;
   default          :return 0;
  }
 return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x4bc71
jmp 0x4bc67
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x4bc81
jmp 0x4bc91
movq -0x18(%rbp), %rax
cvtsi2sdl 0x28(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4bc99
movq -0x18(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4bc99
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: set_value
void set_value(variableptr var, double value1)
{
 /*!Last Changed 03.01.2006*/
 /*!Last Changed 02.05.2002*/
 switch (var->type)
  {
   case INTEGER_TYPE:var->value.intvalue = (int)value1;
                     break;
   case REAL_TYPE   :var->value.floatvalue = value1;
                     break;
   default          :break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x4bcc6
jmp 0x4bcbc
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x4bcd4
jmp 0x4bce4
cvttsd2si -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
jmp 0x4bce6
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x28(%rax)
jmp 0x4bce6
jmp 0x4bce6
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: array_sizes
int* array_sizes(char* name, int* dimcount)
{
 /*!Last Changed 06.01.2006*/
 int i, start, end = 0, len, *dimensions = NULL;
 char st[READLINELENGTH], *p;
 len = strlen(name);
 for (i = 0; i < len; i++)
   if (name[i] == '[')
     start = i + 1;
   else
     if (name[i] == ']')
      {
       end = i - 1;
       break;
      }
 for (i = start; i <= end; i++)
   st[i - start] = name[i];
 st[i - start] = '\0';
 p = strtok(st, ",");
 *dimcount = 0;
 while (p)
  {
   (*dimcount)++;
   dimensions = alloc(dimensions, (*dimcount) * sizeof(int), *dimcount);
   dimensions[(*dimcount) - 1] = atoi(p);
   p = strtok(NULL, ",");
  }
 return dimensions;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a160, %rsp          # imm = 0x7A160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4150
movl %eax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x4c1a4
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5b, %eax
jne 0x4c179
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4c197
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
jne 0x4c195
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4c1a4
jmp 0x4c197
jmp 0x4c199
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4c155
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x4c1d7
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %cl
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
cltq
movb %cl, -0x7a150(%rbp,%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4c1aa
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
cltq
movb $0x0, -0x7a150(%rbp,%rax)
leaq -0x7a150(%rbp), %rdi
leaq 0x99425(%rip), %rsi     # 0xe561a
callq 0x4230
movq %rax, -0x7a158(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x7a158(%rbp)
je 0x4c278
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
shlq $0x2, %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
callq 0x52d10
movq %rax, -0x28(%rbp)
movq -0x7a158(%rbp), %rdi
callq 0x41c0
movl %eax, %edx
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
xorl %eax, %eax
movl %eax, %edi
leaq 0x993b0(%rip), %rsi     # 0xe561a
callq 0x4230
movq %rax, -0x7a158(%rbp)
jmp 0x4c20b
movq -0x28(%rbp), %rax
addq $0x7a160, %rsp          # imm = 0x7A160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: array_pos
variableptr array_pos(char *name, variableptr myvar)
{
 /*!Last Changed 06.01.2006*/
	/*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 02.05.2002*/
 int i, start, end = 0, len;
 char st[READLINELENGTH], *p;
 variableptr myvar2, result = myvar;
 Expnodeptr list;
 len = strlen(name);
 for (i = 0; i < len; i++)
   if (name[i] == '[')
     start = i + 1;
   else
     if (name[i] == ']')
      {
       end = i - 1;
       break;
      }
 for (i = start; i <= end; i++)
   st[i - start] = name[i];
 st[i - start] = '\0';
 p = strtok(st, ",");
 while (p)
  {
   list = create_expression_list(p);
   myvar2 = evaluate_expression_list(list);
   result = &(result->value.array[myvar2->value.intvalue - 1]);
   safe_free(myvar2);
   p = strtok(NULL, ",");
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a160, %rsp          # imm = 0x7A160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x7a158(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4150
movl %eax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x4c317
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5b, %eax
jne 0x4c2ec
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4c30a
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
jne 0x4c308
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4c317
jmp 0x4c30a
jmp 0x4c30c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4c2c8
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x4c34a
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %cl
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
cltq
movb %cl, -0x7a140(%rbp,%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4c31d
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
cltq
movb $0x0, -0x7a140(%rbp,%rax)
leaq -0x7a140(%rbp), %rdi
leaq 0x992b2(%rip), %rsi     # 0xe561a
callq 0x4230
movq %rax, -0x7a148(%rbp)
cmpq $0x0, -0x7a148(%rbp)
je 0x4c3f2
movq -0x7a148(%rbp), %rdi
callq 0x4c410
movq %rax, -0x7a160(%rbp)
movq -0x7a160(%rbp), %rdi
callq 0x4c5e0
movq %rax, -0x7a150(%rbp)
movq -0x7a158(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x7a150(%rbp), %rcx
movl 0x28(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x7a158(%rbp)
movq -0x7a150(%rbp), %rdi
callq 0x52e80
xorl %eax, %eax
movl %eax, %edi
leaq 0x99236(%rip), %rsi     # 0xe561a
callq 0x4230
movq %rax, -0x7a148(%rbp)
jmp 0x4c374
movq -0x7a158(%rbp), %rax
addq $0x7a160, %rsp          # imm = 0x7A160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: create_expression_list
Expnodeptr create_expression_list(char* st)
{
 /*!Last Changed 03.01.2006*/
 char st1[READLINELENGTH];
 int i = 0, j = 0, indexs, indexo;
 Expnodeptr start = NULL, tmpbefore = NULL;
 while (st[i])
  {
   indexs = listindexc(st[i], separators, 5);
   indexo = listindexc(st[i], operators, 7);
   if (indexs != -1 || indexo != -1)
    {
     st1[j] = '\0';
     add_expnode(st1, &tmpbefore, &start);
     st1[0] = st[i];
     st1[1] = '\0';
     add_expnode(st1, &tmpbefore, &start);
     j = -1;
    }
   else
     st1[j] = st[i];
   i++;
   j++;
  }
 st1[j] = '\0';
 add_expnode(st1, &tmpbefore, &start); 
 st1[0] = st[i];
 st1[1] = '\0';
 add_expnode(st1, &tmpbefore, &start);
 return start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a150, %rsp          # imm = 0x7A150
movq %rdi, -0x8(%rbp)
movl $0x0, -0x7a134(%rbp)
movl $0x0, -0x7a138(%rbp)
movq $0x0, -0x7a148(%rbp)
movq $0x0, -0x7a150(%rbp)
movq -0x8(%rbp), %rax
movslq -0x7a134(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x4c565
movq -0x8(%rbp), %rax
movslq -0x7a134(%rbp), %rcx
leaq 0xb8928(%rip), %rsi     # 0x104d98
movl $0x5, %edx
movsbl (%rax,%rcx), %edi
callq 0x54aa0
movl %eax, -0x7a13c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x7a134(%rbp), %rcx
leaq 0xb8907(%rip), %rsi     # 0x104d9d
movl $0x7, %edx
movsbl (%rax,%rcx), %edi
callq 0x54aa0
movl %eax, -0x7a140(%rbp)
cmpl $-0x1, -0x7a13c(%rbp)
jne 0x4c4bc
cmpl $-0x1, -0x7a140(%rbp)
je 0x4c526
movslq -0x7a138(%rbp), %rax
movb $0x0, -0x7a130(%rbp,%rax)
leaq -0x7a130(%rbp), %rdi
leaq -0x7a150(%rbp), %rsi
leaq -0x7a148(%rbp), %rdx
callq 0x4d1c0
movq -0x8(%rbp), %rax
movslq -0x7a134(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x7a130(%rbp)
movb $0x0, -0x7a12f(%rbp)
leaq -0x7a130(%rbp), %rdi
leaq -0x7a150(%rbp), %rsi
leaq -0x7a148(%rbp), %rdx
callq 0x4d1c0
movl $0xffffffff, -0x7a138(%rbp) # imm = 0xFFFFFFFF
jmp 0x4c542
movq -0x8(%rbp), %rax
movslq -0x7a134(%rbp), %rcx
movb (%rax,%rcx), %cl
movslq -0x7a138(%rbp), %rax
movb %cl, -0x7a130(%rbp,%rax)
movl -0x7a134(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7a134(%rbp)
movl -0x7a138(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7a138(%rbp)
jmp 0x4c449
movslq -0x7a138(%rbp), %rax
movb $0x0, -0x7a130(%rbp,%rax)
leaq -0x7a130(%rbp), %rdi
leaq -0x7a150(%rbp), %rsi
leaq -0x7a148(%rbp), %rdx
callq 0x4d1c0
movq -0x8(%rbp), %rax
movslq -0x7a134(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x7a130(%rbp)
movb $0x0, -0x7a12f(%rbp)
leaq -0x7a130(%rbp), %rdi
leaq -0x7a150(%rbp), %rsi
leaq -0x7a148(%rbp), %rdx
callq 0x4d1c0
movq -0x7a148(%rbp), %rax
addq $0x7a150, %rsp          # imm = 0x7A150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: set_default_value
void set_default_value(variableptr var)
{
 /*!Last Changed 22.12.2006 added matrix type*/
 /*!Last Changed 03.01.2006*/
	/*!Last Changed 05.11.2003 Added File variable with type 4*/
 /*!Last Changed 02.05.2002*/
 switch (var->type)
  {
   case INTEGER_TYPE:var->value.intvalue = 0;
                     break;
   case REAL_TYPE   :var->value.floatvalue = 0;
                     break;
   case FILE_TYPE   :var->userfile = NULL;
			case STRING_TYPE :var->value.stringvalue = NULL;
                     break;
   case MATRIX_TYPE :var->value.matrixvalue = NULL;
                     break;
   default          :break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x5, %rax
ja 0x4ca1f
movq -0x10(%rbp), %rax
leaq 0x99021(%rip), %rcx     # 0xe59f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
jmp 0x4ca21
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
jmp 0x4ca21
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x4ca21
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x4ca21
jmp 0x4ca21
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/lang.c
// Function: set_multidimensional_array
void set_multidimensional_array(variableptr myvar, void* value)
{
 /*!Last Changed 22.12.2006 added matrix type*/
 /*!Last Changed 05.01.2006*/
 int j;
 for (j = 0; j < myvar->arraysize; j++)
   switch (myvar->value.array[j].type)
    {
     case INTEGER_TYPE:myvar->value.array[j].value.intvalue = atoi((char *)value);
                       break;
     case REAL_TYPE   :myvar->value.array[j].value.floatvalue = atof((char *)value);
                       break;
     case ARRAY_TYPE  :set_multidimensional_array(&(myvar->value.array[j]), value);
                       break;
     case STRING_TYPE :
     case FILE_TYPE   :if (myvar->value.array[j].value.stringvalue)
                         safe_free(myvar->value.array[j].value.stringvalue);
                       myvar->value.array[j].value.stringvalue = strcopy(myvar->value.array[j].value.stringvalue, (char *)value);
                       break;
     case MATRIX_TYPE :myvar->value.array[j].value.matrixvalue = (matrixptr) value;
                       break;
     default          :break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x4cb9e
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movl (%rax,%rcx), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0x4cb8c
movq -0x20(%rbp), %rax
leaq 0x98f85(%rip), %rcx     # 0xe5a0c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x41c0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x28(%rax)
jmp 0x4cb8e
movq -0x10(%rbp), %rdi
callq 0x4100
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x28(%rax)
jmp 0x4cb8e
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4ca30
jmp 0x4cb8e
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x28(%rax)
je 0x4cb33
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x54ba0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x28(%rax)
jmp 0x4cb8e
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x28(%rax)
jmp 0x4cb8e
jmp 0x4cb8e
jmp 0x4cb90
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4ca47
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)