LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: euclidian_distance
double euclidian_distance(double* list1, double* list2, int p)
{
 /*!Last Changed 01.10.2010*/
 int i;
 double sum = 0;
 for (i = 0; i < p; i++)
   sum += (list1[i] - list2[i]) * (list1[i] - list2[i]);
 return sqrt(sum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x50a0b
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x509b2
movsd -0x20(%rbp), %xmm0
callq 0x42a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: normalize_array
void normalize_array(int* counts, double* posterior, int size)
{
 /*!Last Changed 05.01.2009*/
 int i, sum;
 sum = sum_of_list(counts, size);
 if (sum == 0)
   for (i = 0; i < size; i++)
     posterior[i] = 1.0 / size;
 else
   for (i = 0; i < size; i++)
     posterior[i] = counts[i] / (sum + 0.0);
}

// 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
movl -0x14(%rbp), %esi
callq 0x50940
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x50a82
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x50a80
cvtsi2sdl -0x14(%rbp), %xmm1
movsd 0x915b4(%rip), %xmm0    # 0xe2018
divsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x50a4f
jmp 0x50ac8
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x50ac6
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x50a89
jmp 0x50ac8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: normalize_array_laplace
void normalize_array_laplace(int* counts, double* posterior, int size)
{
 int i, sum;
 sum = sum_of_list(counts, size);
 for (i = 0; i < size; i++)
   posterior[i] = (counts[i] + 1) / (sum + size + 0.0);
}

// 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
movl -0x14(%rbp), %esi
callq 0x50940
movl %eax, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x50b40
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movl -0x1c(%rbp), %eax
addl -0x14(%rbp), %eax
cvtsi2sd %eax, %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x50af9
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: sum_of_list_double
double sum_of_list_double(double* list, int size)
{
 /*!Last Changed 28.05.2005*/
 int i;
 double sum = 0;
 for (i = 0; i < size; i++)
   sum += list[i];
 return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x50b94
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x50b6a
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: normalize_array_of_doubles
void normalize_array_of_doubles(double* list, int size)
{
 /*!Last Changed 09.07.2009*/
 int i, sum;
 sum = sum_of_list_double(list, size);
 if (sum == 0.0)
   for (i = 0; i < size; i++)
     list[i] = 1.0 / size;
 else
   for (i = 0; i < size; i++)
     list[i] = list[i] / (sum + 0.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x50b50
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
cvtsi2sdl -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x50c0c
jp 0x50c0c
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x50c0a
cvtsi2sdl -0xc(%rbp), %xmm1
movsd 0x9142a(%rip), %xmm0    # 0xe2018
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x50bd9
jmp 0x50c52
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x50c50
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
xorps %xmm2, %xmm2
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x50c13
jmp 0x50c52
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libarray.c
// Function: sum_of_two_arrays
double* sum_of_two_arrays(double* list1, double* list2, int size)
{
 /*!Last Changed 22.01.2007*/
 int i;
 double* result;
 result = safemalloc(size * sizeof(double), "sum_of_two_arrays", 3);
 for (i = 0; i < size; i++)
   result[i] = list1[i] + list2[i];
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x957d2(%rip), %rsi     # 0xe6454
movl $0x3, %edx
callq 0x52d70
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x50cd1
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x50c97
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libfile.c
// Function: concat_file
void concat_file(char* dest,char* src)
{
/*!Last Changed 27.04.2002*/
 FILE* myfile1;
 FILE* myfile2;
 char st[500];
 if ((myfile1=fopen(dest,"a"))==NULL)
  {
   printf(m1274, dest);
   return;
  }
 if ((myfile2=fopen(src,"r"))==NULL)
  {
   printf(m1274, src);
   fclose(myfile1);
   return;
  }
 while (fgets(st,500,myfile2))
   fputs(st,myfile1);
 fclose(myfile1);
 fclose(myfile2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x93cea(%rip), %rsi     # 0xe49e8
callq 0x40c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x50d21
movq -0x8(%rbp), %rsi
leaq 0x92172(%rip), %rdi     # 0xe2e8a
movb $0x0, %al
callq 0x4030
jmp 0x50d99
movq -0x10(%rbp), %rdi
leaq 0x9747a(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x50d58
movq -0x10(%rbp), %rsi
leaq 0x92144(%rip), %rdi     # 0xe2e8a
movb $0x0, %al
callq 0x4030
movq -0x18(%rbp), %rdi
callq 0x4250
jmp 0x50d99
jmp 0x50d5a
leaq -0x220(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x40f0
cmpq $0x0, %rax
je 0x50d87
leaq -0x220(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x41b0
jmp 0x50d5a
movq -0x18(%rbp), %rdi
callq 0x4250
movq -0x20(%rbp), %rdi
callq 0x4250
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libfile.c
// Function: dividefile
void dividefile(char* fname, double ratio, int howmany, char* directory)
{
 int *tmp, size, i, j;
 char filename[100];
 char myline[READLINELENGTH];
 FILE *infile,*outfile1,*outfile2;
 size = file_length(fname);
 for (i=0;i<howmany;i++)
  {
   tmp = random_array(size);
   sprintf(filename,"%s/run%d.tra",directory,i+1);
   outfile1 = fopen(filename,"w");
   if (!outfile1)
     return;
   sprintf(filename,"%s/run%d.tes",directory,i+1);
   outfile2 = fopen(filename,"w");
   if (!outfile2)
     return;
   infile = fopen(fname,"r");
   if (!infile)
     return;
   for (j=0;j<size;j++)
    {
     fgets(myline,READLINELENGTH,infile);
     if (tmp[j]<(ratio*size))
       fprintf(outfile1,"%s",myline);
     else
       fprintf(outfile2,"%s",myline);
    }
   fclose(infile);
   fclose(outfile1);
   fclose(outfile2);
   safe_free(tmp);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a1e0, %rsp          # imm = 0x7A1E0
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x50f90
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x50f7d
movl -0x2c(%rbp), %edi
callq 0x54600
movq %rax, -0x28(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x30(%rbp), %ecx
addl $0x1, %ecx
leaq 0x95658(%rip), %rsi     # 0xe6466
movb $0x0, %al
callq 0x4170
leaq -0xa0(%rbp), %rdi
leaq 0x9739b(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x7a1d0(%rbp)
cmpq $0x0, -0x7a1d0(%rbp)
jne 0x50e3e
jmp 0x50f7d
leaq -0xa0(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x30(%rbp), %ecx
addl $0x1, %ecx
leaq 0x9561d(%rip), %rsi     # 0xe6473
movb $0x0, %al
callq 0x4170
leaq -0xa0(%rbp), %rdi
leaq 0x97353(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x7a1d8(%rbp)
cmpq $0x0, -0x7a1d8(%rbp)
jne 0x50e86
jmp 0x50f7d
movq -0x8(%rbp), %rdi
leaq 0x97315(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x7a1c8(%rbp)
cmpq $0x0, -0x7a1c8(%rbp)
jne 0x50eac
jmp 0x50f7d
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x50f42
leaq -0x7a1c0(%rbp), %rdi
movq -0x7a1c8(%rbp), %rdx
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
movsd -0x10(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm2
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x50f16
movq -0x7a1d0(%rbp), %rdi
leaq -0x7a1c0(%rbp), %rdx
leaq 0x93b8b(%rip), %rsi     # 0xe4a98
movb $0x0, %al
callq 0x4280
jmp 0x50f32
movq -0x7a1d8(%rbp), %rdi
leaq -0x7a1c0(%rbp), %rdx
leaq 0x93b6d(%rip), %rsi     # 0xe4a98
movb $0x0, %al
callq 0x4280
jmp 0x50f34
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x50eb3
movq -0x7a1c8(%rbp), %rdi
callq 0x4250
movq -0x7a1d0(%rbp), %rdi
callq 0x4250
movq -0x7a1d8(%rbp), %rdi
callq 0x4250
movq -0x28(%rbp), %rdi
callq 0x52e80
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x50dde
addq $0x7a1e0, %rsp          # imm = 0x7A1E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libfile.c
// Function: file_length
int file_length(char *file_name)
{
 int i = 0;
 FILE *myfile;
 char myline[READLINELENGTH];
 if ((myfile = fopen(file_name, "r")) == NULL)
   return 0;
 while (fgets(myline, READLINELENGTH, myfile))
  {
   i++;
  }
 fclose(myfile); 
 return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a140, %rsp          # imm = 0x7A140
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x971f5(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x50fc9
movl $0x0, -0x4(%rbp)
jmp 0x51000
jmp 0x50fcb
leaq -0x7a140(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
cmpq $0x0, %rax
je 0x50ff1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x50fcb
movq -0x20(%rbp), %rdi
callq 0x4250
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x7a140, %rsp          # imm = 0x7A140
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libfile.c
// Function: editfile
void editfile(char* filename)
{
/*Last changed 18.03.2002*/
 FILE* outputfile;
 char st[500];
 outputfile=fopen(filename,"w");
 if (!outputfile)
  {
   printf(m1068);
   return;
  }
 while (fgets(st,500,stdin))
   fputs(st,outputfile);
 fclose(outputfile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x97194(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5104a
leaq 0x9543f(%rip), %rdi     # 0xe6480
movb $0x0, %al
callq 0x4030
jmp 0x51088
jmp 0x5104c
leaq -0x210(%rbp), %rdi
movq 0xb2f8e(%rip), %rax     # 0x103fe8
movq (%rax), %rdx
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x40f0
cmpq $0x0, %rax
je 0x5107f
leaq -0x210(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x41b0
jmp 0x5104c
movq -0x10(%rbp), %rdi
callq 0x4250
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libfile.c
// Function: file_only_name
char *file_only_name(char *file_name)
{
 /*!Last Changed 09.01.2007 added linux file style*/
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 06.02.2001*/
 char *st;
 int i,j,end,start,len = strlen(file_name);
 for (i = 0; i < len; i++)
   if (file_name[i] == '.')
     break;
 end = i;
 for (j = i - 1; j >= 0; j--)
   if (file_name[j] == '\\' || file_name[j] == '/')
     break;
 start = j;
 st = safemalloc((end - start) * sizeof(char), "file_only_name", 11);
 for (j = start + 1; j < end; j++)
   st[j - start - 1] = file_name[j];
 st[end - start - 1] = '\0';
 return st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4150
movl %eax, -0x24(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x510e7
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x510da
jmp 0x510e7
jmp 0x510dc
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x510bf
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x5112d
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0x5111e
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x51120
jmp 0x5112d
jmp 0x51122
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x510f6
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
movslq %eax, %rdi
shlq $0x0, %rdi
leaq 0x95353(%rip), %rsi     # 0xe649a
movl $0xb, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5118f
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5115e
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libfile.c
// Function: fileexists
int fileexists(char* filename)
{
/*!Last Changed 18.03.2002*/
 FILE* file;
 if ((file=fopen(filename,"r")) != NULL)
  {
   fclose(file);
   return 1;
  }
 else
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x96fdf(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x511e8
movq -0x18(%rbp), %rdi
callq 0x4250
movl $0x1, -0x4(%rbp)
jmp 0x511ef
movl $0x0, -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/libfile.c
// Function: number_of_floats_in_file
int number_of_floats_in_file(char* fname)
{
 /*!Last Changed 14.01.2009*/
 char myline[READLINELENGTH], *p;
 int count = 0;
 FILE* myfile;
 myfile = fopen(fname, "r");
 if (!myfile)
   return -1;
 fgets(myline, READLINELENGTH, myfile);
 p = strtok(myline, " ;\n");
 while (p)
  {
   count++;
   p = strtok(NULL, " ;\n");
  }
 fclose(myfile);
 return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a150, %rsp          # imm = 0x7A150
movq %rdi, -0x10(%rbp)
movl $0x0, -0x7a13c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x96f82(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x7a148(%rbp)
cmpq $0x0, -0x7a148(%rbp)
jne 0x51243
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x512bc
leaq -0x7a130(%rbp), %rdi
movq -0x7a148(%rbp), %rdx
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
leaq -0x7a130(%rbp), %rdi
leaq 0x95240(%rip), %rsi     # 0xe64a9
callq 0x4230
movq %rax, -0x7a138(%rbp)
cmpq $0x0, -0x7a138(%rbp)
je 0x512a7
movl -0x7a13c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7a13c(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x95210(%rip), %rsi     # 0xe64a9
callq 0x4230
movq %rax, -0x7a138(%rbp)
jmp 0x51275
movq -0x7a148(%rbp), %rdi
callq 0x4250
movl -0x7a13c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x7a150, %rsp          # imm = 0x7A150
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libfile.c
// Function: find_string_in_file
FILE* find_string_in_file(FILE *infile, char *substring)
{
/*!Last Changed 24.03.2006 Aydin*/ 
 char temp[READLINELENGTH];
 if (!infile)
   return infile;
 while (infile)
  {
   fgets(temp, READLINELENGTH, infile);
   if (strstr(temp, substring))
    return infile;
  }
 return(infile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a140, %rsp          # imm = 0x7A140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x512f4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5133c
jmp 0x512f6
cmpq $0x0, -0x10(%rbp)
je 0x51334
leaq -0x7a140(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
leaq -0x7a140(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4190
cmpq $0x0, %rax
je 0x51332
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5133c
jmp 0x512f6
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x7a140, %rsp          # imm = 0x7A140
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libfile.c
// Function: modoffile
int modoffile(char* fname, int* howmany)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 FILE* myfile;
 Fileelement* l;
 double tmp;
 int count = 0, i, tmpi, max, maxindex;
 l = (Fileelement*)safemalloc(file_length(fname)*sizeof(Fileelement), "modoffile", 5);
 myfile = fopen(fname, "r");
 if (!myfile)
   return -1;
 while (fscanf(myfile,"%lf",&tmp)!=EOF)
  {
   tmpi = (int)tmp;
   for (i = 0; i < count; i++)
     if (l[i].e==tmpi)
       break;
   if (i<count)
     l[i].count++;
   else
    {
     l[count].e = tmpi;
     l[count].count = 1;
     count++;
    }
  }
 max = -1;
 maxindex = -1;
 for (i = 0; i < count; i++)
   if (l[i].count > max)
    {
     max = l[i].count;
     maxindex = i;
    }
 tmpi = l[maxindex].e;
 *howmany = max;
 safe_free(l);
 fclose(myfile);
 return tmpi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50f90
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x9512f(%rip), %rsi     # 0xe64ad
movl $0x5, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x96e0f(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x513b3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x514ce
jmp 0x513b5
movq -0x20(%rbp), %rdi
leaq 0x95408(%rip), %rsi     # 0xe67c8
leaq -0x30(%rbp), %rdx
movb $0x0, %al
callq 0x4070
cmpl $-0x1, %eax
je 0x5144f
cvttsd2si -0x30(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x51406
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,8), %eax
cmpl -0x3c(%rbp), %eax
jne 0x513f9
jmp 0x51406
jmp 0x513fb
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x513df
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x51423
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %edx
addl $0x1, %edx
movl %edx, 0x4(%rax,%rcx,8)
jmp 0x5144a
movl -0x3c(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl %edx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl $0x1, 0x4(%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x513b5
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x5149f
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %eax
cmpl -0x40(%rbp), %eax
jle 0x51492
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x40(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x51494
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x51464
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl (%rax,%rcx,8), %eax
movl %eax, -0x3c(%rbp)
movl -0x40(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x52e80
movq -0x20(%rbp), %rdi
callq 0x4250
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libfile.c
// Function: net_extension
int net_extension(char *file_name)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 06.02.2001*/
 int i, j, len = strlen(file_name);
 char *st;
 int result;
 j= len - 1;
 while ((j>=0)&&(file_name[j]!='.'))
   j--;
 if (j<0)
   return -1;
 st = safemalloc((len - j)*sizeof(char), "net_extension", 9);
 st[len - j - 1]='\0';
 for (i=j+1;i<len;i++)
   st[i-j-1]=file_name[i];
 if (strcmp(st,"net")==0)
   result = 0;
 else
   if (strcmp(st,"xml")==0)
     result = 1;
   else
     if (strcmp(st,"hugin")==0)
       result = 2;
     else
       if (strcmp(st,"bif")==0)
         result = 3;
       else
         result = -1;
 safe_free(st);
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4150
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x2d(%rbp)
jl 0x51521
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x5152a
jmp 0x51535
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x51501
cmpl $0x0, -0x18(%rbp)
jge 0x51547
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5164b
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movslq %eax, %rdi
shlq $0x0, %rdi
leaq 0x94f5c(%rip), %rsi     # 0xe64b7
movl $0x9, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x515b7
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
subl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x51586
movq -0x28(%rbp), %rdi
leaq 0x94f03(%rip), %rsi     # 0xe64c5
callq 0x4210
cmpl $0x0, %eax
jne 0x515d5
movl $0x0, -0x2c(%rbp)
jmp 0x5163c
movq -0x28(%rbp), %rdi
leaq 0x90e04(%rip), %rsi     # 0xe23e4
callq 0x4210
cmpl $0x0, %eax
jne 0x515f3
movl $0x1, -0x2c(%rbp)
jmp 0x5163a
movq -0x28(%rbp), %rdi
leaq 0x94ecb(%rip), %rsi     # 0xe64c9
callq 0x4210
cmpl $0x0, %eax
jne 0x51611
movl $0x2, -0x2c(%rbp)
jmp 0x51638
movq -0x28(%rbp), %rdi
leaq 0x94eb3(%rip), %rsi     # 0xe64cf
callq 0x4210
cmpl $0x0, %eax
jne 0x5162f
movl $0x3, -0x2c(%rbp)
jmp 0x51636
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
jmp 0x51638
jmp 0x5163a
jmp 0x5163c
movq -0x28(%rbp), %rdi
callq 0x52e80
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libfile.c
// Function: read_file_into_array
char** read_file_into_array(char* filename, int* linecount)
{
 /*!Last Changed 11.10.2006*/
 FILE *myfile;
 char myline[READLINELENGTH], **lines = NULL;
 int i;
 *linecount = 0;
 if ((myfile = fopen(filename, "r")) == NULL)
  {
   printf(m1274, filename);
   return NULL;
  }
 while (fgets(myline, READLINELENGTH, myfile))
   (*linecount)++;
 fclose(myfile);
 lines = (char **)safemalloc((*linecount) * sizeof(char *), "read_file_into_array", 13);
 myfile = fopen(filename, "r");
 i = 0;
 while (fgets(myline, READLINELENGTH, myfile))
  {
   lines[i] = strcopy(lines[i], myline);
   i++;
  }
 fclose(myfile);
 return lines;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7a150, %rsp          # imm = 0x7A150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x7a148(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x96b13(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x516c1
movq -0x10(%rbp), %rsi
leaq 0x917dd(%rip), %rdi     # 0xe2e8a
movb $0x0, %al
callq 0x4030
movq $0x0, -0x8(%rbp)
jmp 0x517a8
jmp 0x516c3
leaq -0x7a140(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
cmpq $0x0, %rax
je 0x516eb
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x516c3
movq -0x20(%rbp), %rdi
callq 0x4250
movq -0x18(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
leaq 0x94dcd(%rip), %rsi     # 0xe64d3
movl $0xd, %edx
callq 0x52d70
movq %rax, -0x7a148(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x96a84(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x20(%rbp)
movl $0x0, -0x7a14c(%rbp)
leaq -0x7a140(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x7a120, %esi          # imm = 0x7A120
callq 0x40f0
cmpq $0x0, %rax
je 0x51794
movq -0x7a148(%rbp), %rax
movslq -0x7a14c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x7a140(%rbp), %rsi
callq 0x54ba0
movq %rax, %rdx
movq -0x7a148(%rbp), %rax
movslq -0x7a14c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x7a14c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7a14c(%rbp)
jmp 0x51735
movq -0x20(%rbp), %rdi
callq 0x4250
movq -0x7a148(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x7a150, %rsp          # imm = 0x7A150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libfile.c
// Function: file_sum
double file_sum(char *fname)
{
 /*Last Changed 04.02.2005*/
 FILE *myfile;
 double sum = 0, temp;
 if ((myfile = fopen(fname, "r")) == NULL)
  {
   printf(m1274, fname);
   return 0;
  }
 while (fscanf(myfile, "%lf", &temp) != EOF)
   sum += temp;
 fclose(myfile);
 return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x969c7(%rip), %rsi     # 0xe81a6
callq 0x40c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x5180a
movq -0x10(%rbp), %rsi
leaq 0x91691(%rip), %rdi     # 0xe2e8a
movb $0x0, %al
callq 0x4030
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x5184b
jmp 0x5180c
movq -0x18(%rbp), %rdi
leaq 0x94fb1(%rip), %rsi     # 0xe67c8
leaq -0x28(%rbp), %rdx
movb $0x0, %al
callq 0x4070
cmpl $-0x1, %eax
je 0x51838
movsd -0x28(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x5180c
movq -0x18(%rbp), %rdi
callq 0x4250
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libiteration.c
// Function: bypass_iterator
BOOLEAN bypass_iterator(int* iterator, int size, int range, int bypassno)
{
 /*!Last Changed 21.02.2008*/
 int i, j;
 for (i = bypassno; i >= 0; i--)
  {
   if (iterator[i] < range)
    {
     iterator[i]++;
     for (j = i + 1; j < size; j++)
       iterator[j] = 0;
     return BOOLEAN_TRUE;
    }
   iterator[i] = 0;
  }
 return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x518ec
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
jge 0x518d2
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x518c9
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x518a7
movl $0x1, -0x4(%rbp)
jmp 0x518f3
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x51877
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libiteration.c
// Function: bypass_iterator_from_list
BOOLEAN bypass_iterator_from_list(int* iterator, int* list, int* indexlist, int size, int range, int bypassno)
{
 /*!Last Changed 21.02.2008*/
 int i, j;
 for (i = bypassno; i >= 0; i--)
  {
   if (indexlist[i] < range)
    {
     indexlist[i]++;
     iterator[i] = list[indexlist[i]];
     for (j = i + 1; j < size; j++)
      {
       indexlist[j] = 0;
       iterator[j] = list[indexlist[j]];
      }
     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 %r9d, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jl 0x519fb
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x28(%rbp), %eax
jge 0x519c0
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x519b7
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x34(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x51977
movl $0x1, -0x4(%rbp)
jmp 0x51a02
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x51921
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libiteration.c
// Function: first_combination
int* first_combination(int size)
{
 /*!Last Changed 21.02.2008*/
 int i;
 int* result = safemalloc(size * sizeof(int), "first_combination", 2);
 for (i = 0; i < size; i++)
   result[i] = i;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
leaq 0x94abe(%rip), %rsi     # 0xe64e8
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x51a60
movl -0x8(%rbp), %edx
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 0x51a3f
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libiteration.c
// Function: first_combination_from_list
int* first_combination_from_list(int size, int* list, int** indexlist)
{
 /*!Last Changed 21.02.2008*/
 int i;
 int* result = safemalloc(size * sizeof(int), "first_combination_from_list", 2);
 *indexlist = safemalloc(size * sizeof(int), "first_combination_from_list", 3);
 for (i = 0; i < size; i++)
  {
   (*indexlist)[i] = i;
   result[i] = list[(*indexlist)[i]];
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
leaq 0x94a68(%rip), %rsi     # 0xe64fa
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
leaq 0x94a4b(%rip), %rsi     # 0xe64fa
movl $0x3, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x51b0f
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x51aca
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libiteration.c
// Function: first_iterator
int* first_iterator(int size)
{
 /*!Last Changed 21.02.2008*/
 int i;
 int* result = safemalloc(size * sizeof(int), "first_iterator", 2);
 for (i = 0; i < size; i++)
   result[i] = 0;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
leaq 0x949dc(%rip), %rsi     # 0xe6516
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x51b71
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x51b4f
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libiteration.c
// Function: first_mixed_iterator
int* first_mixed_iterator(int size)
{
 /*!Last Changed 14.11.2009*/
 int i;
 int* result = safemalloc(size * sizeof(int), "first_mixed_iterator", 2);
 for (i = 0; i < size; i++)
   result[i] = 0;
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
leaq 0x9498b(%rip), %rsi     # 0xe6525
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x51bd1
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x51baf
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libiteration.c
// Function: first_iterator_from_list
int* first_iterator_from_list(int size, int* list, int** indexlist)
{
 /*!Last Changed 21.02.2008*/
 int i;
 int* result = safemalloc(size * sizeof(int), "first_combination", 2);
 *indexlist = safemalloc(size * sizeof(int), "first_combination", 3);
 for (i = 0; i < size; i++)
  {
   (*indexlist)[i] = 0;
   result[i] = list[(*indexlist)[i]];
  }
 return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
leaq 0x948e6(%rip), %rsi     # 0xe64e8
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x28(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
leaq 0x948c9(%rip), %rsi     # 0xe64e8
movl $0x3, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x51c80
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x51c3a
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libiteration.c
// Function: is_subset
BOOLEAN is_subset(int* set1, int* set2, int size1, int size2)
{
 int i, j;
 BOOLEAN found;
 for (i = 0; i < size1; i++)
  {
   found = BOOLEAN_FALSE;
   for (j = 0; j < size2; j++)
     if (set1[i] == set2[j])
      {
       found = BOOLEAN_TRUE;
       break;
      }
   if (!found)
     return BOOLEAN_FALSE;
  }
 return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x51ff1
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x51fd5
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x28(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x51fc8
movl $0x1, -0x2c(%rbp)
jmp 0x51fd5
jmp 0x51fca
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x51f9f
cmpl $0x0, -0x2c(%rbp)
jne 0x51fe4
movl $0x0, -0x4(%rbp)
jmp 0x51ff8
jmp 0x51fe6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x51f89
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libiteration.c
// Function: generate_subsets
int** generate_subsets(int howmany, int *total, int** counts)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 /*!Last Changed 07.05.2001*/
 int i, j, k, **sets, res = 1;
 for (i = 0;i < howmany;i++)
   res *= 2;
 (*counts) = (int *)safemalloc(res * sizeof(int), "generate_subsets", 4);
 sets = (int **)safemalloc(res * sizeof(int *), "generate_subsets", 5);
 for (i = 0;i < res;i++)
  {
   (*counts)[i]=0;
   k=i;
   for (j = 0;j < howmany;j++)
    {
     if (k % 2)
      {
       (*counts)[i]++;
       sets[i] = alloc(sets[i],(*counts)[i] * sizeof(int),(*counts)[i]);
       sets[i][(*counts)[i] - 1] = j;
      }
     k = k / 2;
    }
  }
 (*total) = res;
 return sets;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x34(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x5203c
movl -0x34(%rbp), %eax
shll %eax
movl %eax, -0x34(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x52021
movslq -0x34(%rbp), %rdi
shlq $0x2, %rdi
leaq 0x94505(%rip), %rsi     # 0xe6550
movl $0x4, %edx
callq 0x52d70
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq -0x34(%rbp), %rdi
shlq $0x3, %rdi
leaq 0x944e2(%rip), %rsi     # 0xe6550
movl $0x5, %edx
callq 0x52d70
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x52171
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x52161
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x52145
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movslq (%rax,%rcx,4), %rsi
shlq $0x2, %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x52d10
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rbp), %edx
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rsi
movl (%rcx,%rsi,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x520ae
jmp 0x52163
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x52083
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libiteration.c
// Function: next_combination
BOOLEAN next_combination(int* combination, int size, int range)
{
 /*Output includes range i.e., range = 3 last element is ... 3*/
 /*!Last Changed 21.02.2008*/
 int i, j;
 for (i = size - 1; i > -1; i--) 
  {
   combination[i]++;
   if (combination[i] <= range - size + i + 1)
     break;
  }
 if (i == -1)
   return BOOLEAN_FALSE;
 for (j = i + 1; j < size; j++)
   combination[j] = combination[j - 1] + 1;
 return BOOLEAN_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jle 0x521e8
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x18(%rbp), %ecx
subl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jg 0x521db
jmp 0x521e8
jmp 0x521dd
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x521a7
cmpl $-0x1, -0x1c(%rbp)
jne 0x521f7
movl $0x0, -0x4(%rbp)
jmp 0x52238
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x52231
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x52200
movl $0x1, -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_combination_from_list
BOOLEAN next_combination_from_list(int* combination, int* list, int* indexlist, int size, int range)
{
 /*!Last Changed 21.02.2008*/
 int i, j;
 for (i = size - 1; i > -1; i--) 
  {
   indexlist[i]++;
   if (indexlist[i] <= range - size + i)
     break;
  }
 if (i == -1)
   return BOOLEAN_FALSE;
 combination[i] = list[indexlist[i]];
 for (j = i + 1; j < size; j++)
  {
   indexlist[j] = indexlist[j - 1] + 1;
   combination[j] = list[indexlist[j]]; 
  }
 return BOOLEAN_TRUE;
}

// 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 $-0x1, -0x2c(%rbp)
jle 0x5229e
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x28(%rbp), %ecx
subl -0x24(%rbp), %ecx
addl -0x2c(%rbp), %ecx
cmpl %ecx, %eax
jg 0x52291
jmp 0x5229e
jmp 0x52293
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x52260
cmpl $-0x1, -0x2c(%rbp)
jne 0x522ad
movl $0x0, -0x4(%rbp)
jmp 0x5232a
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, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x52323
movq -0x20(%rbp), %rax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x522d4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/libiteration.c
// Function: next_iterator
BOOLEAN next_iterator(int* iterator, int size, int range)
{
 /*Output includes range i.e., range = 3 last element is 3 3 3 ...*/
 /*!Last Changed 21.02.2008*/
 int i;
 for (i = size - 1; i >= 0; i--)
  {
   if (iterator[i] < range)
    {
     iterator[i]++;
     return BOOLEAN_TRUE;
    }
   iterator[i] = 0;
  }
 return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x52391
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
jge 0x52377
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl $0x1, -0x4(%rbp)
jmp 0x52398
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x52347
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_mixed_iterator
BOOLEAN next_mixed_iterator(int* iterator, int size, int* rangelist)
{
 /*Output does not include range i.e., rangelist[0] = 3, rangelist[1] = 4, rangelist[2] = 2 last element is 2 3 1 */
 /*!Last Changed 14.11.2009*/
 int i;
 for (i = size - 1; i >= 0; i--)
  {
   if (iterator[i] < rangelist[i] - 1)
    {
     iterator[i]++;
     return BOOLEAN_TRUE;
    }
   iterator[i] = 0;
  }
 return BOOLEAN_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x5240f
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x523f5
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl $0x1, -0x4(%rbp)
jmp 0x52416
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x523b8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)