LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libiteration.c
// Function: next_iterator_from_list
BOOLEAN next_iterator_from_list(int* iterator, int* list, int* indexlist, int size, int range)
{
 /*!Last Changed 21.02.2008*/
 int i;
 for (i = size - 1; i >= 0; i--)
  {
   if (indexlist[i] < range)
    {
     indexlist[i]++;
     iterator[i] = list[indexlist[i]];
     return BOOLEAN_TRUE;
    }
   indexlist[i] = 0;
   iterator[i] = list[indexlist[i]];
  }
 return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x524cd
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x28(%rbp), %eax
jge 0x52492
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl $0x1, -0x4(%rbp)
jmp 0x524d4
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x52440
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libiteration.c
// Function: next_permutation
BOOLEAN next_permutation(int* permutation, int size)
{
 /*!Last Changed 21.02.2008*/
 int i = size - 2, j, k;
 while (i >= 0 && permutation[i] >= permutation[i + 1])
   i--;
 if (i == -1)
   return BOOLEAN_FALSE;
 j = size - 1;
 while (permutation[i] >= permutation[j])
   j--;
 swap_int(&(permutation[i]), &(permutation[j]));
 k = i + 1;
 j = size - 1;
 while (k < j)
  {
   swap_int(&(permutation[j]), &(permutation[k]));
   k++;
   j--;
  }
 return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
jl 0x52524
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movl -0x18(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
setge %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x5252d
jmp 0x52538
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x524f8
cmpl $-0x1, -0x18(%rbp)
jne 0x5254a
movl $0x0, -0x4(%rbp)
jmp 0x525f1
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jl 0x52576
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x52553
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x533d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x525ea
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x20(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x533d0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x525ab
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmath.c
// Function: fpow
double fpow(double x,int y)
{
 double result,t=x;
 if (y%2)
   result=x;
 else
   result=1;
 y/=2;
 while (y>0)
  {
   t=t*t;
   if (y%2)
     result*=t;
   y/=2;
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x52872
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x5287f
movsd 0x8f79e(%rip), %xmm0    # 0xe2018
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x528d1
movsd -0x20(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x528c1
movsd -0x20(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
jmp 0x5288d
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmath.c
// Function: pythag
double pythag(double a, double b)
{
 double absa, absb;
 absa = fabs(a);
 absb = fabs(b);
 if (absa > absb) 
   return absa * sqrt(1.0 + fpow(absb / absa, 2));
 else 
   return (absb == 0.0 ? 0.0 : absb * sqrt(1.0 + fpow(absa / absb, 2)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movaps 0x90502(%rip), %xmm1    # 0xe2e60
pand %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movaps 0x904ed(%rip), %xmm1    # 0xe2e60
pand %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x529cd
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
divsd -0x20(%rbp), %xmm0
movl $0x2, %edi
callq 0x52840
movaps %xmm0, %xmm1
movsd 0x8f667(%rip), %xmm0    # 0xe2018
addsd %xmm1, %xmm0
callq 0x42a0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x52a34
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x529e7
jp 0x529e7
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x52a2a
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
movl $0x2, %edi
callq 0x52840
movaps %xmm0, %xmm1
movsd 0x8f608(%rip), %xmm0    # 0xe2018
addsd %xmm1, %xmm0
callq 0x42a0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmath.c
// Function: factorial
int factorial(int n)
{
 int i, result = 1;
 for (i = 2; i <= n; i++)
   result *= i;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x2, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jg 0x52b92
movl -0x8(%rbp), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x52b75
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmath.c
// Function: binomdouble
double binomdouble(int m, int n)
{
 int i;
 double sum = 0.0;
 if (m < n)
   return 0;
 if (n == 0 || m == n)
   return 1;
 else
  {
   for (i = 2; i <= m; i++)
     sum += log(i);
   for (i = 2; i <= m - n; i++)
    sum -= log(i);
   for (i = 2; i <= n; i++)
    sum -= log(i);
   return exp(sum);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x52c2b
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x52cf7
cmpl $0x0, -0x10(%rbp)
je 0x52c39
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0x52c4b
movsd 0x8f3d7(%rip), %xmm0    # 0xe2018
movsd %xmm0, -0x8(%rbp)
jmp 0x52cf7
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x52c79
cvtsi2sdl -0x14(%rbp), %xmm0
callq 0x4120
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x52c52
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
subl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jg 0x52cb3
cvtsi2sdl -0x14(%rbp), %xmm0
callq 0x4120
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x52c80
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x52ce8
cvtsi2sdl -0x14(%rbp), %xmm0
callq 0x4120
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x52cba
movsd -0x20(%rbp), %xmm0
callq 0x4060
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmemory.c
// Function: safemalloc
void* safemalloc(size_t size, char* functionname, int line)
{
 /*!Last Changed 02.02.2004*/
 void* result;
 result = malloc(size);
 if (!result)
  {
   printf(m1305, functionname, line);
   exit(0);
  }
 else
  {
   #ifdef HEAP_DEBUG
     heap_debug_insert_data(result, size, functionname, line);
   #endif
   return result;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x52db3
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x937cb(%rip), %rdi     # 0xe6570
movb $0x0, %al
callq 0x4030
xorl %edi, %edi
callq 0x40a0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmemory.c
// Function: saferealloc
void* saferealloc(void* p, size_t size, char* functionname, int line)
{
 /*!Last Changed 28.11.2004*/
 void* result;
 #ifdef HEAP_DEBUG
   heap_debug_delete_data(p, 1);
 #endif
 result = realloc(p, size);
 if (!result)
  {
   printf(m1305, functionname, line);
   exit(0);
  }
 else
  {
   #ifdef HEAP_DEBUG
     heap_debug_insert_data(result, size, functionname, line);
   #endif
   return result;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4270
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x52e0b
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq 0x93773(%rip), %rdi     # 0xe6570
movb $0x0, %al
callq 0x4030
xorl %edi, %edi
callq 0x40a0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmemory.c
// Function: free_2d
void free_2d(void **p,int size)
{
/*!Last Changed 23.02.2001*/
 int i;
 for (i = 0; i < size; i++)
   if (p[i])
     safe_free(p[i]);
 safe_free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x52e6b
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x52e5e
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x52e80
jmp 0x52e60
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x52e36
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmemory.c
// Function: free_3d
void free_3d(void ***p,int size1,int size2)
{
/*!Last Changed 23.02.2001*/
 int i,j;
 for (i = 0; i < size1; i++)
   for (j = 0; j < size2; j++)
     safe_free(p[i][j]);
 for (i = 0; i < size1; i++)
   safe_free(p[i]);
 safe_free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x52f01
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x52ef4
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x52e80
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x52ec8
jmp 0x52ef6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x52eb9
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x52f2c
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x52e80
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x52f08
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmemory.c
// Function: safecalloc
void* safecalloc(size_t elementcount, size_t elementsize, char* functionname, int line)
{
 /*!Last Changed 02.02.2004*/
 void* result;
 result = calloc(elementcount, elementsize);
 if (!result)
  {
   printf(m1305, functionname, line);
   exit(0);
  }
 else
  {
   #ifdef HEAP_DEBUG
     heap_debug_insert_data(result, elementcount * elementsize, functionname, line);
   #endif
   return result;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4240
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x52f8b
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq 0x935f3(%rip), %rdi     # 0xe6570
movb $0x0, %al
callq 0x4030
xorl %edi, %edi
callq 0x40a0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmemory.c
// Function: safecalloc_2d
void** safecalloc_2d(size_t elementsize1, size_t elementsize2, int elementcount1, int elementcount2, char* functionname, int line)
{
 /*!Last Changed 06.02.2005*/
 void** result;
 int i;
 result = safemalloc(elementsize1 * elementcount1, functionname, line);
 for (i = 0; i < elementcount1; i++)
   result[i] = safecalloc(elementcount2, elementsize2, functionname, line);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
imulq %rax, %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x52d70
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x53017
movslq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x52f40
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x52fe1
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmemory.c
// Function: safecalloc_3d
void*** safecalloc_3d(size_t elementsize1, size_t elementsize2, size_t elementsize3, int elementcount1, int elementcount2, int elementcount3, char* functionname, int line)
{
 /*!Last Changed 06.02.2005*/
 void*** result;
 int i, j;
 result = safemalloc(elementsize1 * elementcount1, functionname, line);
 for (i = 0; i < elementcount1; i++)
   result[i] = safemalloc(elementsize2 * elementcount2, functionname, line);
 for (i = 0; i < elementcount1; i++)
   for (j = 0; j < elementcount2; j++)
     result[i][j] = safecalloc(elementcount3, elementsize3, functionname, line);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq %rax, %rdi
movq 0x10(%rbp), %rsi
movl 0x18(%rbp), %edx
callq 0x52d70
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x530b3
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rax
imulq %rax, %rdi
movq 0x10(%rbp), %rsi
movl 0x18(%rbp), %edx
callq 0x52d70
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x53079
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x53114
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x53107
movslq -0x24(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x10(%rbp), %rdx
movl 0x18(%rbp), %ecx
callq 0x52f40
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x530c9
jmp 0x53109
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x530ba
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmemory.c
// Function: safemalloc_2d
void** safemalloc_2d(size_t elementsize1, size_t elementsize2, int elementcount1, int elementcount2, char* functionname, int line)
{
 /*!Last Changed 06.02.2005*/
 void** result;
 int i;
 result = safemalloc(elementsize1 * elementcount1, functionname, line);
 for (i = 0; i < elementcount1; i++)
   result[i] = safemalloc(elementsize2 * elementcount2, functionname, line);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
imulq %rax, %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x52d70
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5319b
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
imulq %rax, %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x52d70
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x53161
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmemory.c
// Function: safemalloc_3d
void*** safemalloc_3d(size_t elementsize1, size_t elementsize2, size_t elementsize3, int elementcount1, int elementcount2, int elementcount3, char* functionname, int line)
{
 /*!Last Changed 06.02.2005*/
 void*** result;
 int i, j;
 result = safemalloc(elementsize1 * elementcount1, functionname, line);
 for (i = 0; i < elementcount1; i++)
   result[i] = safemalloc(elementsize2 * elementcount2, functionname, line);
 for (i = 0; i < elementcount1; i++)
   for (j = 0; j < elementcount2; j++)
     result[i][j] = safemalloc(elementsize3 * elementcount3, functionname, line);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq %rax, %rdi
movq 0x10(%rbp), %rsi
movl 0x18(%rbp), %edx
callq 0x52d70
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x53233
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rax
imulq %rax, %rdi
movq 0x10(%rbp), %rsi
movl 0x18(%rbp), %edx
callq 0x52d70
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x531f9
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x53298
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x5328b
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rax
imulq %rax, %rdi
movq 0x10(%rbp), %rsi
movl 0x18(%rbp), %edx
callq 0x52d70
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x53249
jmp 0x5328d
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5323a
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmisc.c
// Function: set_precision
void set_precision(char* precisionst, char* before, char* after)
{
 /*!Last Changed 05.07.2005*/
 char st[10];
 strcpy(precisionst, "");
 if (before)
   strcat(precisionst, before);
 sprintf(st, "%%4.%dlf", get_parameter_i("precision"));
 strcat(precisionst, st);
 if (after)
   strcat(precisionst, after);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9acab(%rip), %rsi     # 0xedfda
callq 0x4220
cmpq $0x0, -0x10(%rbp)
je 0x53348
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41a0
leaq -0x22(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x93241(%rip), %rdi     # 0xe6598
callq 0x78f10
movq -0x30(%rbp), %rdi
movl %eax, %edx
leaq 0x93226(%rip), %rsi     # 0xe658f
movb $0x0, %al
callq 0x4170
movq -0x8(%rbp), %rdi
leaq -0x22(%rbp), %rsi
callq 0x41a0
cmpq $0x0, -0x18(%rbp)
je 0x53391
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41a0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmisc.c
// Function: sort_function_int_ascending
int sort_function_int_ascending(const void *a, const void *b)
{
 /*!Last Changed 21.05.2005*/
 int num1, num2;
 num1 = *((int*) a);
 num2 = *((int*) b);
 if (num1 < num2)
   return -1;
 else
   if (num1 > num2)
     return 1;
 return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x5346f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x53489
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x53480
movl $0x1, -0x4(%rbp)
jmp 0x53489
jmp 0x53482
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmisc.c
// Function: sort_function_double_ascending
int sort_function_double_ascending(const void *a, const void *b)
{
 /*!Last Changed 02.03.2005*/
 double num1, num2;
 num1 = *((double*) a);
 num2 = *((double*) b);
 if (num1 < num2)
   return -1;
 else
   if (num1 > num2)
     return 1;
 return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x534ff
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5351d
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x53514
movl $0x1, -0x4(%rbp)
jmp 0x5351d
jmp 0x53516
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmisc.c
// Function: sort_function_observation_ascending
int sort_function_observation_ascending(const void *a, const void *b)
{
 /*!Last Changed 13.01.2009*/
 Obs obs1, obs2;
 obs1 = *((Obs*) a);
 obs2 = *((Obs*) b);
 if (obs1.observation < obs2.observation)
   return -1;
 else
   if (obs1.observation > obs2.observation)
     return 1;
 return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movsd -0x30(%rbp), %xmm1
movsd -0x50(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x535cb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x535e9
movsd -0x30(%rbp), %xmm0
ucomisd -0x50(%rbp), %xmm0
jbe 0x535e0
movl $0x1, -0x4(%rbp)
jmp 0x535e9
jmp 0x535e2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmisc.c
// Function: sort_function_image_object_ascending
int sort_function_image_object_ascending(const void *a, const void *b)
{
 /*!Last Changed 21.05.2005*/
 Object obj1, obj2;
 obj1 = *((Objectptr) a);
 obj2 = *((Objectptr) b);
 if (obj1.type > obj2.type)
   return 1;
 else
   if (obj1.type < obj2.type)
     return -1;
   else
     if (obj1.fnt.fontcolor > obj2.fnt.fontcolor)
       return 1;
     else
       if (obj1.fnt.fontcolor < obj2.fnt.fontcolor)
         return -1;
       else
         if (obj1.fnt.fontsize > obj2.fnt.fontsize)
           return 1;
         else
           if (obj1.fnt.fontsize < obj2.fnt.fontsize)
             return -1;
           else
             if (obj1.fnt.dashedtype > obj2.fnt.dashedtype)
               return 1;
             else
               if (obj1.fnt.dashedtype < obj2.fnt.dashedtype)
                 return -1;
 return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movl $0x60, %edx
callq 0x42b0
movq -0x18(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
movl $0x60, %edx
callq 0x42b0
movl -0x78(%rbp), %eax
cmpl -0xd8(%rbp), %eax
jbe 0x536d1
movl $0x1, -0x4(%rbp)
jmp 0x53784
movl -0x78(%rbp), %eax
cmpl -0xd8(%rbp), %eax
jae 0x536e8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x53784
movl -0x60(%rbp), %eax
cmpl -0xc0(%rbp), %eax
jbe 0x536ff
movl $0x1, -0x4(%rbp)
jmp 0x53784
movl -0x60(%rbp), %eax
cmpl -0xc0(%rbp), %eax
jae 0x53713
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x53784
movsd -0x68(%rbp), %xmm0
ucomisd -0xc8(%rbp), %xmm0
jbe 0x5372b
movl $0x1, -0x4(%rbp)
jmp 0x53784
movsd -0x68(%rbp), %xmm1
movsd -0xc8(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x53747
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x53784
movl -0x5c(%rbp), %eax
cmpl -0xbc(%rbp), %eax
jle 0x5375b
movl $0x1, -0x4(%rbp)
jmp 0x53784
movl -0x5c(%rbp), %eax
cmpl -0xbc(%rbp), %eax
jge 0x5376f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x53784
jmp 0x53771
jmp 0x53773
jmp 0x53775
jmp 0x53777
jmp 0x53779
jmp 0x5377b
jmp 0x5377d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmisc.c
// Function: sort_two_arrays
void sort_two_arrays(double* array1, int* array2, int size)
{
 /*!Last Changed 21.10.2004*/
 int i, j, tmpi;
 double tmp;
 for (i = 0; i < size; i++)
   for (j = i + 1; j < size; j++)
     if (array1[i] > array1[j])
      {
       tmpi = array2[i];
       array2[i] = array2[j];
       array2[j] = tmpi;
       tmp = array1[i];
       array1[i] = array1[j];
       array1[j] = tmp;
      }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x53ab3
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x53aa3
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x53a93
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x53a95
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x539fb
jmp 0x53aa5
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x539e6
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmisc.c
// Function: check_and_put_in_between
void check_and_put_in_between(int* x, int left, int right)
{
 /*!Last Changed 29.12.2005*/
 if (*x < left)
  *x = left;
 else
   if (*x > right)
     *x = right;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x53ae4
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0x53afa
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0x10(%rbp), %eax
jle 0x53af8
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0x53afa
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmisc.c
// Function: isfloat
int isfloat(char* st)
{
 /*!Last Changed 29.09.2004 added - sign*/
 /*!Last Changed 29.01.2004*/
 int i, len = strlen(st);
 for (i = 0; i < len; i++)
   if ((st[i] < '0' || st[i] > '9') && st[i] != '.' && st[i] != '-' && st[i] != 'E' && st[i] != 'e' && st[i] != '+')
     return 0;
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4150
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x53bbb
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x53b4d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x53bab
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x53bab
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x53bab
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x45, %eax
je 0x53bab
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x65, %eax
je 0x53bab
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
je 0x53bab
movl $0x0, -0x4(%rbp)
jmp 0x53bc2
jmp 0x53bad
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x53b1f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmisc.c
// Function: atoi_check
int atoi_check(char* st, int* value, int min, int max)
{
 /*!Last Changed 25.07.2006*/
 int tmp;
 if (isinteger(st))
  {
   tmp = atoi(st);
   if (tmp < min)
    {
     printf(m1405, tmp, min);
     return NO;
    }
   else
     if (tmp > max)
      {
       printf(m1406, tmp, max);
       return NO;
      }
     else
      {
       *value = tmp;
       return YES;
      }
  }
 else
   printf(m1341, st);
 return NO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x53bd0
cmpl $0x0, %eax
je 0x53d4c
movq -0x10(%rbp), %rdi
callq 0x41c0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x53d15
movl -0x24(%rbp), %esi
movl -0x1c(%rbp), %edx
leaq 0x928ab(%rip), %rdi     # 0xe65b0
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x53d65
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x53d3a
movl -0x24(%rbp), %esi
movl -0x20(%rbp), %edx
leaq 0x928d8(%rip), %rdi     # 0xe6602
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x53d65
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x53d65
movq -0x10(%rbp), %rsi
leaq 0x928fc(%rip), %rdi     # 0xe6653
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmisc.c
// Function: atof_check
int atof_check(char* st, double* value, double min, double max)
{
 /*!Last Changed 25.07.2006*/
 double tmp;
 if (isfloat(st))
  {
   tmp = atof(st);
   if (tmp < min)
    {
     printf(m1407, tmp, min);
     return NO;
    }
   else
     if (tmp > max)
      {
       printf(m1408, tmp, max);
       return NO;
      }
     else
      {
       *value = tmp;
       return YES;
      }
  }
 else
   printf(m1340, st);
 return NO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x53b00
cmpl $0x0, %eax
je 0x53e1e
movq -0x10(%rbp), %rdi
callq 0x4100
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x53ddb
movsd -0x30(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
leaq 0x9289e(%rip), %rdi     # 0xe6669
movb $0x2, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x53e37
movsd -0x30(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x53e08
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
leaq 0x928c7(%rip), %rdi     # 0xe66bf
movb $0x2, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x53e37
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x53e37
movq -0x10(%rbp), %rsi
leaq 0x928eb(%rip), %rdi     # 0xe6714
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmisc.c
// Function: in_list
int in_list(int searchvalue, int count, ...)
{
 /*!Last Changed 29.08.2005*/
 int i, compvalue;
 va_list ap;
 va_start(ap, count);
 for (i = 0; i < count; i++)
  {
   compvalue = va_arg(ap, int);
   if (searchvalue == compvalue)
     return 1;
  }
 return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
testb %al, %al
je 0x53e78
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x53f56
leaq -0x30(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0x53f0c
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0x53f29
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x53f46
movl $0x1, -0x4(%rbp)
jmp 0x53f5d
jmp 0x53f48
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x53ec5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libmisc.c
// Function: checkparams
int checkparams(int paramcount, int must, ...)
{
 int i;
 char* line;
 va_list ap;
 va_start(ap, must);
 if (paramcount < must)
  {
   i=0;
   line = va_arg(ap,char *);
   while (i < paramcount)
    {
     line=va_arg(ap,char *);
     i++;
    }
   printf("%s",line);
   return 0;
  }
 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x53fa8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x540fb
movl $0x0, -0x10(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xe4(%rbp)
cmpl $0x28, %eax
ja 0x5403c
movq -0xf0(%rbp), %rcx
movl -0xe4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0xf8(%rbp)
jmp 0x54059
movq -0xf0(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x540e0
leaq -0x30(%rbp), %rax
movq %rax, -0x108(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xfc(%rbp)
cmpl $0x28, %eax
ja 0x540aa
movq -0x108(%rbp), %rcx
movl -0xfc(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x110(%rbp)
jmp 0x540c7
movq -0x108(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x110(%rbp)
movq -0x110(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x54067
movq -0x18(%rbp), %rsi
leaq 0x909ad(%rip), %rdi     # 0xe4a98
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x54102
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/librandom.c
// Function: bootstrap_array
int* bootstrap_array(int size)
{
 /*!Last Changed 19.02.2005*/
 int i, *result = safemalloc(size * sizeof(int), "bootstrap_array", 1);
 for (i = 0; i < size; i++)
   result[i] = myrand() % size;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
leaq 0x9222e(%rip), %rsi     # 0xe6738
movl $0x1, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x54546
callq 0x54550
cltd
idivl -0x4(%rbp)
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x5451f
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/librandom.c
// Function: random_array
int *random_array(int size)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 31.10.2003*/
 int i,tmp,j;
 int *myarray;
 myarray = (int *) safemalloc(size * sizeof(int), "random_array", 3);
 for (i = 0; i < size; i++)
   myarray[i] = i;
 for (i = 0; i < size; i++)
  {
   j = myrand() % size;
   tmp = myarray[i];
   myarray[i] = myarray[j];
   myarray[j] = tmp;
  }
 return myarray;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
leaq 0x9212e(%rip), %rsi     # 0xe6748
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x18(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x54650
movl -0x8(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x5462f
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x546a8
callq 0x54550
cltd
idivl -0x4(%rbp)
movl %edx, -0x10(%rbp)
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movslq -0x8(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x54657
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/librandom.c
// Function: random_array_double
double* random_array_double(int size, double start, double end)
{
 /*!Last Changed 27.03.2006*/
 double* myarray;
 int i;
 myarray = (double *) safemalloc(size * sizeof(double), "random_identity_array", 2);
 for (i = 0; i < size; i++)
   myarray[i] = produce_random_value(start, end);
 return myarray;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x92071(%rip), %rsi     # 0xe6755
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x54728
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x545a0
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x546f9
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/librandom.c
// Function: random_combination
BOOLEAN random_combination(int* combination, int size, int range)
{
 /*!Last Changed 19.03.2008*/
 int i;
 for (i = 0; i < size; i++)
   combination[i] = myrand() % (range + 1);
 return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x54785
callq 0x54550
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x54759
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libstring.c
// Function: char_count
int char_count(char* st, char ch)
{
 /*!Last Changed 10.10.2004*/
 int result = 0, i, len = strlen(st);
 for (i = 0; i < len; i++)
   if (st[i] == ch)
     result++;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $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 0x5482e
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x54821
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x54823
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x547fc
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libstring.c
// Function: instr
int instr(char* st, char* searchst)
{
 /*!Last Changed 19.01.2005 returns -1 if not found returns position if found*/
 /*!Last Changed 03.02.2004*/
 int i, j, len1, len2;
 if (!st || !searchst)
   return -1;
 len1 = strlen(st);
 len2 = strlen(searchst);
 for (i = 0; i < len1 - len2 + 1; i++)
  {
   for (j = 0; j < len2; j++)
     if (st[i + j] != searchst[j])
       break;
   if (j == len2)
     return i;
  }
 return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5485e
cmpq $0x0, -0x18(%rbp)
jne 0x5486a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x548fc
movq -0x10(%rbp), %rdi
callq 0x4150
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4150
movl %eax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x24(%rbp), %ecx
subl -0x28(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x548f5
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x548d8
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x548cb
jmp 0x548d8
jmp 0x548cd
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x548a0
movl -0x20(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0x548e8
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x548fc
jmp 0x548ea
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x54889
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libstring.c
// Function: listindex
int listindex(char *element, char *array[], int elementcount)
{
 /*!Last Changed 10.04.2002*/
 int i;
 if (!element)
   return -2;
 for (i = 0; i < elementcount; i++)
   if (strIcmp(element, array[i]) == 0)
     return i;
 return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x54933
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x54978
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x54971
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x54990
cmpl $0x0, %eax
jne 0x54964
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x54978
jmp 0x54966
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5493a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libstring.c
// Function: strIcmp
int strIcmp(const char *s1, const char *s2)
{
/*!Last Changed 12.04.2002*/
 int len1=strlen(s1),len2=strlen(s2),i,min;
 if (len1<len2)
   min=len1;
 else
   min=len2;
 for (i=0;i<min;i++)
  {
   if (upper(s1[i])<upper(s2[i]))
     return -1;
   if (upper(s1[i])>upper(s2[i]))
     return 1;
  }
 if (len1<len2)
   return -1;
 if (len1>len2)
   return 1;
 return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4150
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4150
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x549c8
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x549ce
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x54a6b
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x54c80
movsbl %al, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x54c80
movb %al, %cl
movl -0x2c(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jge 0x54a1e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x54a94
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x54c80
movsbl %al, %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x54c80
movb %al, %cl
movl -0x30(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jle 0x54a5b
movl $0x1, -0x4(%rbp)
jmp 0x54a94
jmp 0x54a5d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x549d5
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x54a7c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x54a94
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x54a8d
movl $0x1, -0x4(%rbp)
jmp 0x54a94
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libstring.c
// Function: listindexc
int listindexc(char element, char array[], int elementcount)
{
 /*!Last Changed 03.01.2006*/
 int i;
 for (i = 0; i < elementcount; i++)
   if (element == array[i])
     return i;
 return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x54ae9
movsbl -0x5(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x54adc
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x54af0
jmp 0x54ade
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x54ab8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)