LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libarray.c
// Function: find_mod_of_list
int find_mod_of_list(int *list, int size, int newlistsize)
{
 /*!Last Changed 03.03.2006 added by aydin*/
 int mod, *newlist, i;
 newlist = safecalloc(newlistsize, sizeof(int), "find_mod_of_list", 2);
 for (i = 0 ; i < size ; i++)
   if (list[i] >= 0 && list[i] < newlistsize)
     newlist[list[i]]++;
   else
     printf(m1322, "find_mod_of_list");
 mod = find_max_in_list(newlist, newlistsize);
 safe_free(newlist);
 return mod;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movslq %edx, %rdi
leaq 0x6f069(%rip), %rdx     # 0xa6822
movl $0x4, %esi
movl $0x2, %ecx
callq 0x39210
movq %rax, %rbx
testl %r15d, %r15d
jle 0x3780d
movl %r15d, %r13d
leaq 0x6f048(%rip), %r12     # 0xa6822
xorl %r15d, %r15d
movl (%r14,%r15,4), %eax
testl %eax, %eax
sets %cl
cmpl %ebp, %eax
setge %dl
orb %cl, %dl
jne 0x377f4
incl (%rbx,%rax,4)
jmp 0x37805
leaq 0x6f038(%rip), %rdi     # 0xa6833
movq %r12, %rsi
xorl %eax, %eax
callq 0x4030
incq %r15
cmpq %r15, %r13
jne 0x377dd
testl %ebp, %ebp
jle 0x37834
movl %ebp, %eax
movl $0x80000001, %ecx       # imm = 0x80000001
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl (%rbx,%rdx,4), %esi
cmpl %ecx, %esi
cmovgl %esi, %ecx
cmovgl %edx, %ebp
incq %rdx
cmpq %rdx, %rax
jne 0x3781f
jmp 0x37839
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x39194
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libarray.c
// Function: findMaxOutput
int findMaxOutput(double *Y, int length)
{
 int max = 0;
 int c;
 for (c = 0; c < length; c++)
  {
   if (Y[max] <= Y[c])
     max = c;
  }
 return max;
}

// Assembly:
testl %esi, %esi
jle 0x37876
movl %esi, %ecx
xorl %edx, %edx
xorl %eax, %eax
movslq %eax, %rsi
movsd (%rdi,%rdx,8), %xmm0
ucomisd (%rdi,%rsi,8), %xmm0
jb 0x3786d
movl %edx, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x3785c
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libarray.c
// Function: log_of_array
double* log_of_array(double* list, int size)
{
 /*!Last Changed 22.01.2007*/
 int i;
 double* result;
 result = safemalloc(size * sizeof(double), "log_of_array", 3);
 for (i = 0; i < size; i++)
   result[i] = safelog(list[i]);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r15
leaq (,%r15,8), %rdi
leaq 0x6efa9(%rip), %rsi     # 0xa6853
movl $0x3, %edx
callq 0x390f5
movq %rax, %r14
testl %r15d, %r15d
jle 0x378db
movl %ebp, %r15d
xorl %r12d, %r12d
movsd (%rbx,%r12,8), %xmm0
callq 0x38ea9
movsd %xmm0, (%r14,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x378c2
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libarray.c
// Function: multiply_two_arrays
double multiply_two_arrays(double* list1, double* list2, int size)
{
 /*!Last Changed 13.03.2007 Oya*/
 int i;
 double result = 0.0;
 for (i = 0; i < size; i++)
   result += list1[i] * list2[i];
 return result;
}

// Assembly:
testl %edx, %edx
jle 0x37929
movl %edx, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm1
mulsd (%rsi,%rcx,8), %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x37912
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libarray.c
// Function: multiply_two_arrays_by_value
double* multiply_two_arrays_by_value(double* list1, double* list2, int size)
{
 /*!Last Changed 13.03.2007 Oya*/
 int i;
 double* result;
 result = safemalloc(size * sizeof(double), "multiply_two_arrays_by_value", 3);
 for (i = 0; i < size; i++)
   result[i] = list1[i] * list2[i];
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %r15
leaq (,%r15,8), %rdi
leaq 0x6ef12(%rip), %rsi     # 0xa6860
movl $0x3, %edx
callq 0x390f5
testl %r15d, %r15d
jle 0x37979
movl %ebp, %ecx
xorl %edx, %edx
movsd (%r14,%rdx,8), %xmm0
mulsd (%rbx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x37961
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libarray.c
// Function: search_and_add_into_list
void search_and_add_into_list(int* list, int* itemcount, int newitem)
{
 /*!Last Changed 17.07.2005*/
 int i, j;
 for (i = 0; i < *itemcount; i++)
   if (list[i] > newitem)
     break;
   else
     if (list[i] == newitem)
       return;
 for (j = *itemcount - 1; j >= i; j--)
   list[j + 1] = list[j];
 list[i] = newitem;
 (*itemcount)++;
}

// Assembly:
movl (%rsi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
jle 0x3799d
cmpl %edx, (%rdi,%rax,4)
jg 0x3799d
je 0x379c3
incq %rax
cmpq %rax, %rcx
jne 0x3798c
movl %ecx, %eax
cmpl %eax, %ecx
jle 0x379bc
movslq %ecx, %r8
movslq %eax, %rcx
movl -0x4(%rdi,%r8,4), %r9d
movl %r9d, (%rdi,%r8,4)
leaq -0x1(%r8), %r9
movq %r9, %r8
cmpq %rcx, %r9
jg 0x379a7
movl %eax, %eax
movl %edx, (%rdi,%rax,4)
incl (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libarray.c
// Function: sum_of_list
int sum_of_list(int* list, int size)
{
 /*!Last Changed 28.05.2005*/
 int i, sum = 0;
 for (i = 0; i < size; i++)
   sum += list[i];
 return sum;
}

// Assembly:
testl %esi, %esi
jle 0x379f8
movl %esi, %ecx
xorl %edx, %edx
xorl %eax, %eax
addl (%rdi,%rdx,4), %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x379ec
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0x37a25
movl %edx, %eax
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm2
subsd (%rsi,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x37a0b
ucomisd %xmm1, %xmm0
jb 0x4300
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl %edx, %eax
testl %edx, %edx
jle 0x37a4d
xorl %r8d, %r8d
xorl %ecx, %ecx
addl (%rdi,%r8,4), %ecx
incq %r8
cmpq %r8, %rax
jne 0x37a3f
jmp 0x37a4f
xorl %ecx, %ecx
testl %ecx, %ecx
je 0x37a78
testl %edx, %edx
jle 0x37a9b
cvtsi2sd %ecx, %xmm0
xorl %ecx, %ecx
xorps %xmm1, %xmm1
cvtsi2sdl (%rdi,%rcx,4), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x37a5d
jmp 0x37a9b
testl %edx, %edx
jle 0x37a9b
cvtsi2sd %edx, %xmm1
movsd 0x6aa98(%rip), %xmm0    # 0xa2520
divsd %xmm1, %xmm0
xorl %ecx, %ecx
movsd %xmm0, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x37a8e
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl %edx, %eax
testl %edx, %edx
jle 0x37ab5
xorl %r8d, %r8d
xorl %ecx, %ecx
addl (%rdi,%r8,4), %ecx
incq %r8
cmpq %r8, %rax
jne 0x37aa7
jmp 0x37ab7
xorl %ecx, %ecx
testl %edx, %edx
jle 0x37ae0
addl %edx, %ecx
cvtsi2sd %ecx, %xmm0
xorl %ecx, %ecx
movl (%rdi,%rcx,4), %edx
incl %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x37ac3
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
jle 0x37afb
movl %esi, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
addsd (%rdi,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x37aed
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl %esi, %eax
testl %esi, %esi
jle 0x37b1e
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
addsd (%rdi,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x37b0b
cvttsd2si %xmm0, %ecx
jmp 0x37b20
xorl %ecx, %ecx
testl %ecx, %ecx
je 0x37b49
testl %esi, %esi
jle 0x37b6c
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x37b31
jmp 0x37b6c
testl %esi, %esi
jle 0x37b6c
cvtsi2sd %esi, %xmm1
movsd 0x6a9c7(%rip), %xmm0    # 0xa2520
divsd %xmm1, %xmm0
xorl %ecx, %ecx
movsd %xmm0, (%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x37b5f
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %r15
leaq (,%r15,8), %rdi
leaq 0x6ecef(%rip), %rsi     # 0xa687d
movl $0x3, %edx
callq 0x390f5
testl %r15d, %r15d
jle 0x37bb9
movl %ebp, %ecx
xorl %edx, %edx
movsd (%r14,%rdx,8), %xmm0
addsd (%rbx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x37ba1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %r15
movq %rdi, %r14
leaq 0x6d26b(%rip), %rsi     # 0xa4e48
callq 0x40f0
testq %rax, %rax
je 0x37c56
movq %rax, %rbx
leaq 0x70c9e(%rip), %rsi     # 0xa888f
movq %r15, %rdi
callq 0x40f0
testq %rax, %rax
je 0x37c73
movq %rax, %r14
movq %rsp, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
movq %rax, %rdx
callq 0x4120
testq %rax, %rax
je 0x37c39
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x41f0
movq %r15, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
movq %r14, %rdx
callq 0x4120
testq %rax, %rax
jne 0x37c19
movq %rbx, %rdi
callq 0x42a0
movq %r14, %rdi
callq 0x42a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6b5ad(%rip), %rdi     # 0xa320a
movq %r14, %rsi
xorl %eax, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x4030
leaq 0x6b590(%rip), %rdi     # 0xa320a
movq %r15, %rsi
xorl %eax, %eax
callq 0x4030
movq %rbx, %rdi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x42a0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7a1c8, %rsp          # imm = 0x7A1C8
movq %rdx, %rbp
movl %esi, %ebx
movsd %xmm0, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
callq 0x37e22
movl %eax, 0x4(%rsp)
movl %ebx, 0x14(%rsp)
testl %ebx, %ebx
jle 0x37e10
movl 0x4(%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl %eax, %eax
movq %rax, 0x28(%rsp)
leaq 0xa0(%rsp), %r12
movl $0x0, (%rsp)
movq %rbp, 0x18(%rsp)
movl 0x4(%rsp), %edi
callq 0x39fdc
movq %rax, %r14
movl (%rsp), %ecx
incl %ecx
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
leaq 0x6eb6f(%rip), %rsi     # 0xa688f
movq %rbp, %rdx
movl %ecx, (%rsp)
xorl %eax, %eax
callq 0x41b0
movq %rbx, %rdi
leaq 0x70b6a(%rip), %rsi     # 0xa88a1
callq 0x40f0
testq %rax, %rax
je 0x37e10
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
leaq 0x6eb45(%rip), %rsi     # 0xa689c
movq %rbp, %rdx
movl (%rsp), %ecx
xorl %eax, %eax
callq 0x41b0
movq %r15, %rdi
leaq 0x70b33(%rip), %rsi     # 0xa88a1
callq 0x40f0
testq %rax, %rax
je 0x37e10
movq %rax, %r13
movq 0x20(%rsp), %rdi
leaq 0x70b04(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x37e10
movq %rax, %r15
cmpl $0x0, 0x4(%rsp)
jle 0x37dde
xorl %ebp, %ebp
movq %r12, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r15, %rdx
callq 0x4120
xorps %xmm0, %xmm0
cvtsi2sdl (%r14,%rbp,4), %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq %rbx, %rsi
ja 0x37dcc
movq %r13, %rsi
movq %r12, %rdi
callq 0x41f0
incq %rbp
cmpq %rbp, 0x28(%rsp)
jne 0x37da1
movq %r15, %rdi
callq 0x42a0
movq %rbx, %rdi
callq 0x42a0
movq %r13, %rdi
callq 0x42a0
movq %r14, %rdi
callq 0x39194
movl (%rsp), %eax
cmpl 0x14(%rsp), %eax
movq 0x18(%rsp), %rbp
jne 0x37d00
addq $0x7a1c8, %rsp          # imm = 0x7A1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
leaq 0x70a12(%rip), %rsi     # 0xa88a1
callq 0x40f0
testq %rax, %rax
je 0x37ef0
movq %rax, %rbx
movq 0x9912d(%rip), %r15     # 0xd0fd0
movq (%r15), %rdx
movq %rsp, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x4120
testq %rax, %rax
je 0x37edb
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41f0
movq (%r15), %rdx
movq %r14, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x4120
testq %rax, %rax
jne 0x37ebb
movq %rbx, %rdi
callq 0x42a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6ea00(%rip), %rdi     # 0xa68f7
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4190
movq %rax, %r14
testl %r14d, %r14d
jle 0x37f3a
movl %r14d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpb $0x2e, (%rbx,%rcx)
je 0x37f3f
incq %rcx
cmpq %rcx, %rax
jne 0x37f2a
jmp 0x37f42
xorl %r14d, %r14d
jmp 0x37f42
movl %ecx, %r14d
movl %r14d, %eax
movl %r14d, %r12d
sarl $0x1f, %r12d
andl %r14d, %r12d
leal -0x1(%r12), %edx
decq %rax
movl %r14d, %ecx
testl %ecx, %ecx
jle 0x37f79
movl %eax, %esi
movzbl (%rbx,%rsi), %esi
decl %ecx
cmpl $0x5c, %esi
je 0x37f73
decq %rax
cmpl $0x2f, %esi
jne 0x37f5a
leal 0x1(%rcx), %r12d
jmp 0x37f7b
movl %edx, %ecx
movl %r14d, %eax
subl %ecx, %eax
movslq %eax, %r15
leaq 0x6e91f(%rip), %rsi     # 0xa68a9
movq %r15, %rdi
movl $0xb, %edx
callq 0x390f5
cmpl %r14d, %r12d
jge 0x37fbd
movslq %r12d, %rdx
movslq %r14d, %rcx
addq %rdx, %rbx
subq %rdx, %rcx
xorl %edx, %edx
movb (%rbx,%rdx), %sil
movslq %edx, %rdi
movb %sil, (%rax,%rdi)
incq %rdx
cmpq %rdx, %rcx
jne 0x37faa
movb $0x0, -0x1(%rax,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x7a120, %rsp          # imm = 0x7A120
leaq 0x70888(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x38061
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
leaq 0x6e88a(%rip), %rsi     # 0xa68b8
movq %r14, %rdi
callq 0x4280
xorl %r14d, %r14d
testq %rax, %rax
je 0x38057
leaq 0x6e873(%rip), %r15     # 0xa68b8
incl %r14d
xorl %edi, %edi
movq %r15, %rsi
callq 0x4280
testq %rax, %rax
jne 0x38045
movq %rbx, %rdi
callq 0x42a0
jmp 0x38067
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x37e22
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x6e7d7(%rip), %rsi     # 0xa68bc
movl $0x5, %edx
callq 0x390f5
movq %rax, %r14
leaq 0x70796(%rip), %rsi     # 0xa888f
movq %r15, %rdi
callq 0x40f0
testq %rax, %rax
je 0x381a9
movq %rax, %r15
leaq 0x6eafc(%rip), %rsi     # 0xa6c10
xorl %ebp, %ebp
movq %rsp, %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, %eax
je 0x3817d
leaq 0x6eae1(%rip), %r12     # 0xa6c10
movq %rsp, %r13
xorl %ebp, %ebp
cvttsd2si (%rsp), %eax
testl %ebp, %ebp
jle 0x3814f
movl %ebp, %ecx
xorl %edx, %edx
cmpl %eax, (%r14,%rdx,8)
je 0x38163
incq %rdx
cmpq %rdx, %rcx
jne 0x38141
movslq %ebp, %rcx
movl %eax, (%r14,%rcx,8)
movl $0x1, 0x4(%r14,%rcx,8)
incl %ebp
jmp 0x38168
incl 0x4(%r14,%rdx,8)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, %eax
jne 0x38134
testl %ebp, %ebp
jle 0x381b0
movl %ebp, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %esi, %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl 0x4(%r14,%rsi,8), %edi
cmpl %eax, %edi
cmovgl %edi, %eax
cmovgl %esi, %edx
incq %rsi
cmpq %rsi, %rcx
jne 0x3818f
movslq %edx, %rcx
jmp 0x381bc
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x381d2
movq $-0x1, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl (%r14,%rcx,8), %ebp
movl %eax, (%rbx)
movq %r14, %rdi
callq 0x39194
movq %r15, %rdi
callq 0x42a0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x4190
movq %rax, %r15
movl %r15d, %ecx
movl %r15d, %r13d
sarl $0x1f, %r13d
andl %r15d, %r13d
leal -0x1(%r13), %edx
decq %rcx
testl %eax, %eax
jle 0x38222
movl %ecx, %esi
decl %eax
decq %rcx
cmpb $0x2e, (%rbx,%rsi)
jne 0x3820b
leal 0x1(%rax), %r13d
jmp 0x38224
movl %edx, %eax
testl %r13d, %r13d
jle 0x382c7
movl %r15d, %ecx
subl %eax, %ecx
movslq %ecx, %r12
leaq 0x6e68a(%rip), %rsi     # 0xa68c6
movq %r12, %rdi
movl $0x9, %edx
callq 0x390f5
movq %rax, %r14
movb $0x0, -0x1(%rax,%r12)
cmpl %r15d, %r13d
jge 0x38274
movl %r13d, %ecx
movslq %r15d, %rax
addq %rcx, %rbx
subq %rcx, %rax
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, (%r14,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x38265
leaq 0x6e659(%rip), %rsi     # 0xa68d4
movq %r14, %rdi
callq 0x4260
testl %eax, %eax
je 0x382ce
leaq 0x6a4ef(%rip), %rsi     # 0xa277d
movq %r14, %rdi
callq 0x4260
testl %eax, %eax
je 0x382d2
leaq 0x6e637(%rip), %rsi     # 0xa68d8
movq %r14, %rdi
callq 0x4260
testl %eax, %eax
je 0x382d9
leaq 0x6e62a(%rip), %rsi     # 0xa68de
movq %r14, %rdi
callq 0x4260
xorl %ebx, %ebx
negl %eax
sbbl %ebx, %ebx
orl $0x3, %ebx
jmp 0x382de
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x382e6
xorl %ebx, %ebx
jmp 0x382de
movl $0x1, %ebx
jmp 0x382de
movl $0x2, %ebx
movq %r14, %rdi
callq 0x39194
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x7a128, %rsp          # imm = 0x7A128
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, (%rsi)
leaq 0x7057c(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x383d6
movq %rax, %r15
movq %rsp, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
testq %rax, %rax
je 0x38353
movq %rsp, %r12
incl (%rbx)
movq %r12, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r15, %rdx
callq 0x4120
testq %rax, %rax
jne 0x3833c
movq %r15, %rdi
callq 0x42a0
movslq (%rbx), %rdi
shlq $0x3, %rdi
leaq 0x6e579(%rip), %rsi     # 0xa68e2
movl $0xd, %edx
callq 0x390f5
movq %rax, %rbx
leaq 0x70512(%rip), %rsi     # 0xa888f
movq %r14, %rdi
callq 0x40f0
movq %rax, %r14
movq %rsp, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
testq %rax, %rax
je 0x383cc
movq %rsp, %r15
movq %rbx, %r12
movq (%r12), %rdi
movq %r15, %rsi
callq 0x3a404
movq %rax, (%r12)
movq %r15, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r14, %rdx
callq 0x4120
addq $0x8, %r12
testq %rax, %rax
jne 0x383a3
movq %r14, %rdi
callq 0x42a0
jmp 0x383e9
leaq 0x6ae2d(%rip), %rdi     # 0xa320a
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x4030
movq %rbx, %rax
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x70481(%rip), %rsi     # 0xa888f
callq 0x40f0
testq %rax, %rax
je 0x38472
movq %rax, %rbx
leaq 0x6e7ee(%rip), %rsi     # 0xa6c10
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4070
xorpd %xmm0, %xmm0
cmpl $-0x1, %eax
je 0x38488
movsd %xmm0, (%rsp)
leaq 0x6e7ca(%rip), %r14     # 0xa6c10
leaq 0x8(%rsp), %r15
movsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, %eax
jne 0x3844b
jmp 0x3848d
leaq 0x6ad91(%rip), %rdi     # 0xa320a
movq %r14, %rsi
xorl %eax, %eax
callq 0x4030
xorps %xmm0, %xmm0
jmp 0x3849a
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x42a0
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
xorl %ebx, %ebx
testl %ecx, %ecx
js 0x384ff
movq %rdi, %rax
leal 0x1(%rcx), %edi
leaq (%rax,%rdi,4), %rdi
movl %ecx, %r8d
movl (%rax,%r8,4), %ecx
cmpl %edx, %ecx
jl 0x384d7
movl $0x0, (%rax,%r8,4)
leal -0x1(%r8), %ecx
addq $-0x4, %rdi
testl %r8d, %r8d
jg 0x384b5
jmp 0x384ff
incl %ecx
movl %ecx, (%rax,%r8,4)
leal 0x1(%r8), %eax
movl $0x1, %ebx
cmpl %esi, %eax
jge 0x384ff
subl %r8d, %esi
addl $-0x2, %esi
leaq 0x4(,%rsi,4), %rdx
xorl %esi, %esi
callq 0x4050
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %r9d, %r9d
js 0x38534
leal 0x1(%r9), %r10d
xorl %r11d, %r11d
movl %r9d, %eax
movslq (%rdx,%rax,4), %r9
cmpl %r8d, %r9d
jl 0x38537
movl $0x0, (%rdx,%rax,4)
movl (%rsi), %r9d
movl %r9d, (%rdi,%rax,4)
leal -0x1(%rax), %r9d
decq %r11
testl %eax, %eax
jg 0x3850f
xorl %eax, %eax
retq
leaq 0x1(%r9), %r8
movl %r8d, (%rdx,%rax,4)
movl 0x4(%rsi,%r9,4), %r8d
movl %r8d, (%rdi,%rax,4)
leal 0x1(%rax), %r8d
movl $0x1, %eax
cmpl %ecx, %r8d
jge 0x38536
leaq (%rdi,%r10,4), %rdi
leaq (%rdx,%r10,4), %rdx
movl $0x0, (%rdx,%r11,4)
movl (%rsi), %r8d
movl %r8d, (%rdi,%r11,4)
incq %r11
leal (%r10,%r11), %r8d
cmpl %ecx, %r8d
jl 0x3855e
jmp 0x38536
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %edi, %r14
leaq (,%r14,4), %rdi
leaq 0x6e37d(%rip), %rsi     # 0xa6910
movl $0x2, %edx
callq 0x390f5
testl %r14d, %r14d
jle 0x385b1
movl %ebx, %ecx
xorl %edx, %edx
movl %edx, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x385a6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %ebp
movslq %edi, %r13
leaq (,%r13,4), %r12
leaq 0x6e344(%rip), %rsi     # 0xa6922
movq %r12, %rdi
movl $0x2, %edx
callq 0x390f5
movq %rax, %r14
movq %r12, %rdi
leaq 0x6e32a(%rip), %rsi     # 0xa6922
movl $0x3, %edx
callq 0x390f5
movq %rax, (%r15)
testl %r13d, %r13d
jle 0x38620
movl %ebp, %ecx
xorl %edx, %edx
movl %edx, (%rax,%rdx,4)
movl (%rbx,%rdx,4), %esi
movl %esi, (%r14,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x3860e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %edi, %r14
leaq (,%r14,4), %rdi
leaq 0x6e2f4(%rip), %rsi     # 0xa693e
movl $0x2, %edx
callq 0x390f5
testl %r14d, %r14d
jle 0x38670
movl %ebx, %edx
shlq $0x2, %rdx
movq %rax, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4050
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %edi, %r14
leaq (,%r14,4), %rdi
leaq 0x6e2bd(%rip), %rsi     # 0xa694d
movl $0x2, %edx
callq 0x390f5
testl %r14d, %r14d
jle 0x386b6
movl %ebx, %edx
shlq $0x2, %rdx
movq %rax, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4050
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %ebp
movslq %edi, %r13
leaq (,%r13,4), %r12
leaq 0x6e22d(%rip), %rsi     # 0xa6910
movq %r12, %rdi
movl $0x2, %edx
callq 0x390f5
movq %rax, %r14
movq %r12, %rdi
leaq 0x6e213(%rip), %rsi     # 0xa6910
movl $0x3, %edx
callq 0x390f5
movq %rax, (%r15)
testl %r13d, %r13d
jle 0x38728
movl %ebp, %ecx
xorl %edx, %edx
movl $0x0, (%rax,%rdx,4)
movl (%rbx), %esi
movl %esi, (%r14,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x38713
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/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:
movl $0x1, %eax
testl %edx, %edx
jle 0x389b0
testl %ecx, %ecx
jle 0x389b1
movl %edx, %edx
movl %ecx, %ecx
xorl %r8d, %r8d
movl (%rdi,%r8,4), %r9d
xorl %r10d, %r10d
cmpl (%rsi,%r10,4), %r9d
je 0x389a8
incq %r10
cmpq %r10, %rcx
jne 0x38998
jmp 0x389b1
incq %r8
cmpq %rdx, %r8
jne 0x38991
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movl %edi, %ebp
movl $0x1, %ebx
testl %edi, %edi
jle 0x389dd
movl %ebp, %eax
addl %ebx, %ebx
decl %eax
jne 0x389d7
movl %ebx, %r15d
leaq (,%r15,4), %rdi
leaq 0x6df89(%rip), %r12     # 0xa6978
movq %r12, %rsi
movl $0x4, %edx
callq 0x390f5
movq %rax, (%r14)
shlq $0x3, %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0x5, %edx
callq 0x390f5
movq %rax, %r15
cmpl $0x1, %ebx
movl %ebx, 0x4(%rsp)
movl %ebx, %eax
adcl $0x0, %eax
movq %rax, 0x10(%rsp)
xorl %ebx, %ebx
movq (%r14), %rax
movl $0x0, (%rax,%rbx,4)
testl %ebp, %ebp
jle 0x38a88
xorl %r12d, %r12d
movl %ebx, %r13d
testb $0x1, %r13b
je 0x38a72
movq (%r14), %rax
movslq (%rax,%rbx,4), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, (%rax,%rbx,4)
movq (%r15,%rbx,8), %rdi
leaq 0x4(,%rcx,4), %rsi
callq 0x390c8
movq %rax, (%r15,%rbx,8)
movq (%r14), %rcx
movslq (%rcx,%rbx,4), %rcx
movl %r12d, -0x4(%rax,%rcx,4)
movl %r13d, %eax
shrl $0x1f, %eax
addl %r13d, %eax
sarl %eax
incl %r12d
movl %eax, %r13d
cmpl %r12d, %ebp
jne 0x38a3d
incq %rbx
cmpq 0x10(%rsp), %rbx
jne 0x38a29
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl %esi, %r8d
movl %esi, %eax
sarl $0x1f, %eax
andl %esi, %eax
leal 0x1(%rsi), %ecx
incl %edx
testl %r8d, %r8d
jle 0x38adf
movl -0x4(%rdi,%r8,4), %r9d
leal 0x1(%r9), %r10d
movl %r10d, -0x4(%rdi,%r8,4)
decq %r8
decl %ecx
decl %edx
cmpl %edx, %r9d
jge 0x38abe
jmp 0x38ae1
movl %eax, %ecx
testl %ecx, %ecx
je 0x38b13
movl $0x1, %eax
cmpl %esi, %ecx
jge 0x38b12
movslq %ecx, %r8
movslq %esi, %rcx
leaq (%rdi,%r8,4), %rdx
movl -0x4(%rdx), %esi
incl %esi
subq %r8, %rcx
xorl %edi, %edi
leal (%rsi,%rdi), %r8d
movl %r8d, (%rdx,%rdi,4)
incq %rdi
cmpq %rdi, %rcx
jne 0x38b02
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %ecx, %r9d
movl %ecx, %r11d
sarl $0x1f, %r11d
andl %ecx, %r11d
leal 0x1(%rcx), %r10d
xorl %ebx, %ebx
movq %rbx, %rax
addq %r9, %rbx
testl %ebx, %ebx
jle 0x38b5c
leaq (%r9,%rax), %rbx
decq %rbx
movl %ebx, %ebx
movl (%rdx,%rbx,4), %r14d
leal 0x1(%r14), %ebp
movl %ebp, (%rdx,%rbx,4)
decl %r10d
leaq -0x1(%rax), %rbx
decl %r8d
cmpl %r8d, %r14d
jge 0x38b2d
jmp 0x38b5f
movl %r11d, %r10d
testl %r10d, %r10d
je 0x38baf
leal -0x1(%rcx), %r8d
movslq %r8d, %r8
leaq (%rdx,%r8,4), %r11
movslq (%r11,%rax,4), %r11
movl (%rsi,%r11,4), %r11d
leaq (%rdi,%r8,4), %r8
movl %r11d, (%r8,%rax,4)
movl $0x1, %eax
cmpl %r9d, %r10d
jge 0x38bb1
movslq %r10d, %r8
movslq %ecx, %rcx
movslq -0x4(%rdx,%r8,4), %r9
leaq 0x1(%r9), %r10
movl %r10d, (%rdx,%r8,4)
movl 0x4(%rsi,%r9,4), %r9d
movl %r9d, (%rdi,%r8,4)
incq %r8
cmpq %r8, %rcx
jne 0x38b8f
jmp 0x38bb1
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
testl %esi, %esi
jle 0x38bda
movl %esi, %ecx
incq %rcx
movl -0x8(%rdi,%rcx,4), %esi
cmpl %edx, %esi
jl 0x38bdb
movl $0x0, -0x8(%rdi,%rcx,4)
decq %rcx
cmpq $0x1, %rcx
jg 0x38bc1
retq
incl %esi
movl %esi, -0x8(%rdi,%rcx,4)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
testl %esi, %esi
jle 0x38c14
movl %esi, %ecx
incq %rcx
movl -0x8(%rdi,%rcx,4), %esi
movl -0x8(%rdx,%rcx,4), %r8d
decl %r8d
cmpl %r8d, %esi
jl 0x38c15
movl $0x0, -0x8(%rdi,%rcx,4)
decq %rcx
cmpq $0x1, %rcx
jg 0x38bf2
retq
incl %esi
movl %esi, -0x8(%rdi,%rcx,4)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
testl %ecx, %ecx
jle 0x38c4f
movl %ecx, %ecx
incq %rcx
movslq -0x8(%rdx,%rcx,4), %r9
cmpl %r8d, %r9d
jl 0x38c50
movl $0x0, -0x8(%rdx,%rcx,4)
movl (%rsi), %r9d
movl %r9d, -0x8(%rdi,%rcx,4)
decq %rcx
cmpq $0x1, %rcx
jg 0x38c2c
retq
leaq 0x1(%r9), %rax
movl %eax, -0x8(%rdx,%rcx,4)
movl 0x4(%rsi,%r9,4), %eax
movl %eax, -0x8(%rdi,%rcx,4)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leal -0x2(%r14), %r15d
cmpl $0x2, %esi
jl 0x38c9c
movl %r15d, %eax
movl (%rbx,%rax,4), %ecx
cmpl 0x4(%rbx,%rax,4), %ecx
jl 0x38c9c
leal -0x1(%r15), %eax
testl %r15d, %r15d
movl %eax, %r15d
jg 0x38c7e
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $-0x1, %r15d
je 0x38d0a
decl %r14d
movslq %r15d, %rax
movl (%rbx,%rax,4), %ecx
movslq %r14d, %r12
leaq (%rbx,%r12,4), %rsi
addq $0x4, %rsi
movq %rsi, %rdx
addq $-0x4, %rsi
cmpl -0x4(%rdx), %ecx
jge 0x38cb6
leaq (%rbx,%rax,4), %rdi
callq 0x395a3
incl %r15d
movl $0x1, %ebp
cmpl %r14d, %r15d
jge 0x38d0c
movslq %r15d, %r15
leaq (%rbx,%r12,4), %r14
leaq (%rbx,%r15,4), %rbx
incq %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x395a3
decq %r12
addq $-0x4, %r14
addq $0x4, %rbx
leaq 0x1(%r15), %rax
cmpq %r12, %r15
movq %rax, %r15
jl 0x38ce6
jmp 0x38d0c
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
testb $0x1, %dil
je 0x38dbe
movapd %xmm0, %xmm1
jmp 0x38dc6
movsd 0x6975a(%rip), %xmm1    # 0xa2520
cmpl $0x2, %edi
jl 0x38de4
mulsd %xmm0, %xmm0
testb $0x2, %dil
je 0x38dd9
mulsd %xmm0, %xmm1
movl %edi, %eax
shrl %eax
cmpl $0x3, %edi
movl %eax, %edi
ja 0x38dcb
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movapd %xmm0, %xmm2
movapd 0x6a3db(%rip), %xmm0    # 0xa31e0
andpd %xmm0, %xmm2
andpd %xmm1, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x38e21
divsd %xmm2, %xmm0
mulsd %xmm0, %xmm0
movapd %xmm2, %xmm3
jmp 0x38e3d
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm1
jne 0x38e2d
jnp 0x38e6d
movapd %xmm0, %xmm3
divsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
movapd %xmm2, %xmm0
addsd 0x696db(%rip), %xmm0    # 0xa2520
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x38e55
sqrtsd %xmm0, %xmm0
jmp 0x38e69
pushq %rax
movsd %xmm3, (%rsp)
callq 0x4300
movsd (%rsp), %xmm3
addq $0x8, %rsp
mulsd %xmm0, %xmm3
movapd %xmm3, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x1, %eax
cmpl $0x2, %edi
jl 0x38efe
negl %edi
movl $0x2, %ecx
imull %ecx, %eax
leal (%rdi,%rcx), %edx
incl %edx
incl %ecx
cmpl $0x1, %edx
jne 0x38eef
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/libmath.c
// Function: binom
int binom(int m, int n)
{
 if (n == 0 || m == n)
   return 1;
 else
   return factorial(m) / (factorial(n) * factorial(m - n));
}

// Assembly:
testl %esi, %esi
sete %al
movl %edi, %edx
subl %esi, %edx
sete %cl
orb %al, %cl
movl $0x1, %eax
jne 0x38f92
movl $0x1, %ecx
cmpl $0x2, %edi
jl 0x38f3e
movl %edi, %r8d
negl %r8d
movl $0x2, %r9d
imull %r9d, %eax
leal (%r8,%r9), %r10d
incl %r10d
incl %r9d
cmpl $0x1, %r10d
jne 0x38f2a
cmpl $0x2, %esi
jl 0x38f68
movl %esi, %r8d
negl %r8d
movl $0x2, %r9d
movl $0x1, %ecx
imull %r9d, %ecx
leal (%r8,%r9), %r10d
incl %r10d
incl %r9d
cmpl $0x1, %r10d
jne 0x38f54
movl $0x1, %r8d
cmpl $0x2, %edx
jl 0x38f8a
subl %edi, %esi
movl $0x2, %edx
imull %edx, %r8d
leal (%rsi,%rdx), %edi
incl %edi
incl %edx
cmpl $0x1, %edi
jne 0x38f7a
imull %ecx, %r8d
cltd
idivl %r8d
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
cmpl %esi, %edi
jl 0x38fc1
movl %esi, %ebx
movl %edi, %r14d
testl %esi, %esi
sete %al
movl %edi, %ebp
subl %esi, %ebp
sete %cl
orb %al, %cl
je 0x38fcc
movsd 0x6955f(%rip), %xmm0    # 0xa2520
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %r14d
jl 0x3901c
leal -0x1(%r14), %r15d
movsd 0x6a062(%rip), %xmm1    # 0xa3040
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x4160
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
addsd 0x69509(%rip), %xmm1    # 0xa2520
decl %r15d
jne 0x38fde
cmpl $0x2, %ebp
jl 0x3906d
movl %ebx, %ebp
notl %ebp
addl %r14d, %ebp
movsd 0x6a010(%rip), %xmm1    # 0xa3040
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x4160
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
addsd 0x694b7(%rip), %xmm1    # 0xa2520
decl %ebp
jne 0x39030
cmpl $0x2, %ebx
jl 0x390b9
decl %ebx
movsd 0x69fc4(%rip), %xmm1    # 0xa3040
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x4160
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
addsd 0x6946b(%rip), %xmm1    # 0xa2520
decl %ebx
jne 0x3907c
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4060
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
callq 0x40e0
testq %rax, %rax
je 0x39110
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6d8a1(%rip), %rdi     # 0xa69b8
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4030
xorl %edi, %edi
callq 0x40c0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x39187
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x3917f
callq 0x4170
incq %r15
cmpq %r15, %r14
jne 0x39171
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4170