LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
xorpd %xmm0, %xmm0
cmpq %rax, %rsi
je 0x33c58
addsd (%rdi,%rax,8), %xmm0
incq %rax
jmp 0x33c49
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x33c3e
cvttsd2si %xmm0, %eax
testl %eax, %eax
je 0x33c98
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
cmpq %rax, %rbx
je 0x33cbf
movsd (%r14,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r14,%rax,8)
incq %rax
jmp 0x33c7e
cvtsi2sd %ebx, %xmm1
movsd 0x6187c(%rip), %xmm0    # 0x95520
divsd %xmm1, %xmm0
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
cmpq %rax, %rbx
je 0x33cbf
movsd %xmm0, (%r14,%rax,8)
incq %rax
jmp 0x33caf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %r15
leaq (,%r15,8), %rdi
leaq 0x65b37(%rip), %rsi     # 0x9981b
pushq $0x3
popq %rdx
callq 0x34f59
xorl %ecx, %ecx
testl %r15d, %r15d
cmovlel %ecx, %r15d
cmpq %rcx, %r15
je 0x33d0f
movsd (%r14,%rcx,8), %xmm0
addsd (%rbx,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
jmp 0x33cf5
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x640ef(%rip), %rsi     # 0x97e20
callq 0x40f0
testq %rax, %rax
je 0x33d97
movq %rax, %rbx
leaq 0x67b3a(%rip), %rsi     # 0x9b87f
movq %r15, %rdi
callq 0x40f0
testq %rax, %rax
je 0x33db4
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
movq %r14, %rdx
callq 0x4120
testq %rax, %rax
je 0x33d7a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x41f0
jmp 0x33d58
movq %rbx, %rdi
callq 0x42a0
movq %r14, %rdi
callq 0x42a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6246c(%rip), %rdi     # 0x9620a
movq %r14, %rsi
xorl %eax, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x4030
leaq 0x6244f(%rip), %rdi     # 0x9620a
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_O2/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, %r12
movl %esi, %ebx
movsd %xmm0, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
callq 0x33f62
cvtsi2sd %eax, %xmm0
xorl %ecx, %ecx
testl %eax, %eax
movl %eax, 0x10(%rsp)
cmovlel %ecx, %eax
movq %rax, 0x28(%rsp)
testl %ebx, %ebx
cmovlel %ecx, %ebx
movl %ebx, 0x14(%rsp)
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0xa0(%rsp), %r14
movl $0x0, 0x4(%rsp)
movq %r12, 0x18(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
je 0x33f50
movl 0x10(%rsp), %edi
callq 0x35cf7
movq %rax, %rbp
movl 0x4(%rsp), %ecx
incl %ecx
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
leaq 0x659c1(%rip), %rsi     # 0x9982d
movq %r12, %rdx
movl %ecx, 0x4(%rsp)
xorl %eax, %eax
callq 0x41b0
movq %rbx, %rdi
leaq 0x67a0d(%rip), %rsi     # 0x9b891
callq 0x40f0
testq %rax, %rax
je 0x33f50
movq %rax, %r15
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
leaq 0x65996(%rip), %rsi     # 0x9983a
movq %r12, %rdx
movl 0x4(%rsp), %ecx
xorl %eax, %eax
callq 0x41b0
movq %rbx, %rdi
leaq 0x679d5(%rip), %rsi     # 0x9b891
callq 0x40f0
testq %rax, %rax
je 0x33f50
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x679a6(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x33f50
movq %rax, %r13
xorl %r12d, %r12d
cmpq %r12, 0x28(%rsp)
je 0x33f26
movq %r14, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r13, %rdx
callq 0x4120
cvtsi2sdl (%rbp,%r12,4), %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq %r15, %rsi
ja 0x33f19
movq %rbx, %rsi
movq %r14, %rdi
callq 0x41f0
incq %r12
jmp 0x33ee9
movq %r13, %rdi
callq 0x42a0
movq %r15, %rdi
callq 0x42a0
movq %rbx, %rdi
callq 0x42a0
movq %rbp, %rdi
callq 0x34ff7
movq 0x18(%rsp), %r12
jmp 0x33e3d
addq $0x7a1c8, %rsp          # imm = 0x7A1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x678c4(%rip), %rsi     # 0x9b891
callq 0x40f0
testq %rax, %rax
je 0x3401b
movq %rax, %rbx
movq 0x97fef(%rip), %r15     # 0xcbfd0
movq %rsp, %r14
movq (%r15), %rdx
movq %r14, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x4120
testq %rax, %rax
je 0x34006
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41f0
jmp 0x33fe4
movq %rbx, %rdi
callq 0x42a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
leaq 0x65873(%rip), %rdi     # 0x99895
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4190
movq %rax, %r14
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
cmpq %rax, %r14
je 0x3405e
cmpb $0x2e, (%rbx,%rax)
je 0x34063
incq %rax
jmp 0x3404e
movq %r14, %rax
jmp 0x34066
movl %eax, %r14d
pushq $-0x1
popq %rcx
testq %rax, %rax
jle 0x34087
movzbl -0x1(%rbx,%rax), %edx
decq %rax
cmpl $0x5c, %edx
je 0x34080
cmpl $0x2f, %edx
jne 0x34069
leal 0x1(%rax), %ebp
movl %eax, %ecx
jmp 0x34089
xorl %ebp, %ebp
movl %r14d, %eax
subl %ecx, %eax
movslq %eax, %r15
leaq 0x657af(%rip), %rsi     # 0x99847
pushq $0xb
popq %rdx
movq %r15, %rdi
callq 0x34f59
movslq %ebp, %rcx
movslq %r14d, %rdx
addq %rcx, %rbx
xorl %esi, %esi
leaq (%rcx,%rsi), %rdi
cmpq %rdx, %rdi
jge 0x340c7
movb (%rbx,%rsi), %dil
movslq %esi, %r8
movb %dil, (%rax,%r8)
incq %rsi
jmp 0x340ae
movb $0x0, -0x1(%rax,%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x67771(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x34161
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
leaq 0x65721(%rip), %r15     # 0x99856
movq %r14, %rdi
movq %r15, %rsi
callq 0x4280
xorl %r14d, %r14d
testq %rax, %rax
je 0x34157
incl %r14d
xorl %edi, %edi
movq %r15, %rsi
callq 0x4280
jmp 0x34143
movq %rbx, %rdi
callq 0x42a0
jmp 0x34165
pushq $-0x1
popq %r14
movl %r14d, %eax
addq $0x7a120, %rsp          # imm = 0x7A120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x33f62
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x65677(%rip), %rsi     # 0x9985a
pushq $0x5
popq %rdx
callq 0x34f59
movq %rax, %r14
leaq 0x6768a(%rip), %rsi     # 0x9b87f
movq %r15, %rdi
callq 0x40f0
testq %rax, %rax
je 0x34298
movq %rax, %r15
leaq 0x65998(%rip), %r12     # 0x99ba8
movq %rsp, %r13
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, %eax
je 0x3425e
cvttsd2si (%rsp), %eax
xorl %ecx, %ecx
cmpq %rcx, %rbp
je 0x3424a
leaq 0x1(%rcx), %rdx
cmpl %eax, (%r14,%rcx,8)
movq %rdx, %rcx
jne 0x34231
incl -0x4(%r14,%rdx,8)
jmp 0x34215
movl %ebp, %ecx
movl %eax, (%r14,%rcx,8)
movl $0x1, 0x4(%r14,%rcx,8)
incq %rbp
jmp 0x34215
pushq $-0x1
popq %rax
xorl %ecx, %ecx
movl %eax, %edx
subq $0x1, %rbp
jb 0x3427d
movl 0x4(%r14,%rcx,8), %esi
cmpl %eax, %esi
cmovgl %esi, %eax
cmovgl %ecx, %edx
incq %rcx
jmp 0x34265
movslq %edx, %rcx
movl (%r14,%rcx,8), %ebp
movl %eax, (%rbx)
movq %r14, %rdi
callq 0x34ff7
movq %r15, %rdi
callq 0x42a0
jmp 0x3429b
pushq $-0x1
popq %rbp
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_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x4190
movl %eax, %ecx
movslq %eax, %r12
leaq 0x1(%r12), %r13
pushq $-0x1
popq %rbp
testl %ecx, %ecx
jle 0x3438a
leaq -0x1(%rcx), %rdx
decq %r13
cmpb $0x2e, -0x1(%r14,%rcx)
movq %rdx, %rcx
jne 0x342cc
subl %edx, %eax
movslq %eax, %r15
leaq 0x65572(%rip), %rsi     # 0x99864
pushq $0x9
popq %rdx
movq %r15, %rdi
callq 0x34f59
movq %rax, %rbx
movb $0x0, -0x1(%rax,%r15)
movl %r13d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
subq %rcx, %rax
cmpq %r12, %r13
jge 0x34324
movb (%r14,%r13), %cl
movb %cl, (%rax,%r13)
incq %r13
jmp 0x34312
leaq 0x65547(%rip), %rsi     # 0x99872
movq %rbx, %rdi
callq 0x4260
testl %eax, %eax
je 0x34377
leaq 0x6143f(%rip), %rsi     # 0x9577d
movq %rbx, %rdi
callq 0x4260
testl %eax, %eax
je 0x3437b
leaq 0x65525(%rip), %rsi     # 0x99876
movq %rbx, %rdi
callq 0x4260
testl %eax, %eax
je 0x3437f
leaq 0x65518(%rip), %rsi     # 0x9987c
movq %rbx, %rdi
callq 0x4260
xorl %ebp, %ebp
negl %eax
sbbl %ebp, %ebp
orl $0x3, %ebp
jmp 0x34382
xorl %ebp, %ebp
jmp 0x34382
pushq $0x1
jmp 0x34381
pushq $0x2
popq %rbp
movq %rbx, %rdi
callq 0x34ff7
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_O2/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, %r14
movq %rdi, %rbx
andl $0x0, (%rsi)
leaq 0x674c6(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x34455
movq %rax, %r15
movq %rsp, %r12
movq %r12, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r15, %rdx
callq 0x4120
testq %rax, %rax
je 0x343e7
incl (%r14)
jmp 0x343cd
movq %r15, %rdi
callq 0x42a0
movslq (%r14), %rdi
shlq $0x3, %rdi
leaq 0x65483(%rip), %rsi     # 0x99880
pushq $0xd
popq %rdx
callq 0x34f59
movq %rax, %r14
leaq 0x67470(%rip), %rsi     # 0x9b87f
movq %rbx, %rdi
callq 0x40f0
movq %rax, %rbx
movq %rsp, %r15
movq %r14, %r12
movq %r15, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rbx, %rdx
callq 0x4120
testq %rax, %rax
je 0x3444b
movq (%r12), %rdi
movq %r15, %rsi
callq 0x3604c
movq %rax, (%r12)
addq $0x8, %r12
jmp 0x34420
movq %rbx, %rdi
callq 0x42a0
jmp 0x34469
leaq 0x61dae(%rip), %rdi     # 0x9620a
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4030
movq %r14, %rax
addq $0x7a128, %rsp          # imm = 0x7A128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x673f1(%rip), %rsi     # 0x9b87f
callq 0x40f0
testq %rax, %rax
je 0x344e6
movq %rax, %rbx
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x656fd(%rip), %r14     # 0x99ba8
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, %eax
je 0x344d7
movsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
jmp 0x344b0
movq %rbx, %rdi
callq 0x42a0
movsd (%rsp), %xmm0
jmp 0x344fa
leaq 0x61d1d(%rip), %rdi     # 0x9620a
movq %r14, %rsi
xorl %eax, %eax
callq 0x4030
xorps %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testl %ecx, %ecx
js 0x3451b
movl %ecx, %eax
movl (%rdi,%rax,4), %r8d
cmpl %edx, %r8d
jl 0x3451e
andl $0x0, (%rdi,%rax,4)
decl %ecx
jmp 0x34504
xorl %eax, %eax
retq
incl %r8d
movl %r8d, (%rdi,%rax,4)
leaq (%rdi,%rax,4), %rdx
addq $0x4, %rdx
incl %ecx
pushq $0x1
popq %rax
cmpl %esi, %ecx
jge 0x3451d
andl $0x0, (%rdx)
incl %ecx
addq $0x4, %rdx
jmp 0x34532
// File: /workspace/github_c_makefile_star2_O2/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 0x34562
movl %r9d, %r10d
movslq (%rdx,%r10,4), %rax
cmpl %r8d, %eax
jl 0x34565
andl $0x0, (%rdx,%r10,4)
movl (%rsi), %eax
movl %eax, (%rdi,%r10,4)
decl %r9d
jmp 0x34541
xorl %eax, %eax
retq
leaq 0x1(%rax), %r8
movl %r8d, (%rdx,%r10,4)
leaq (%rsi,%rax,4), %r8
addq $0x4, %r8
incl %r9d
pushq $0x1
popq %rax
movl (%r8), %r8d
movl %r8d, (%rdi,%r10,4)
cmpl %ecx, %r9d
jge 0x34564
andl $0x0, 0x4(%rdx,%r10,4)
incl %r9d
incq %r10
movq %rsi, %r8
jmp 0x3457b
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movslq %edi, %rbx
leaq (,%rbx,4), %rdi
leaq 0x65303(%rip), %rsi     # 0x998ae
pushq $0x2
popq %rdx
callq 0x34f59
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x345c7
movl %ecx, (%rax,%rcx,4)
incq %rcx
jmp 0x345ba
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
movslq %edi, %rbp
leaq (,%rbp,4), %r12
leaq 0x652d4(%rip), %r13     # 0x998c0
pushq $0x2
popq %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x34f59
movq %rax, %r14
pushq $0x3
popq %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x34f59
movq %rax, (%r15)
xorl %ecx, %ecx
testl %ebp, %ebp
cmovlel %ecx, %ebp
cmpq %rcx, %rbp
je 0x34629
movl %ecx, (%rax,%rcx,4)
movl (%rbx,%rcx,4), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
jmp 0x34615
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_O2/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 %rbx
movslq %edi, %rbx
leaq (,%rbx,4), %rdi
leaq 0x6528e(%rip), %rsi     # 0x998dc
pushq $0x2
popq %rdx
callq 0x34f59
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x3466b
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0x3465d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movslq %edi, %rbx
leaq (,%rbx,4), %rdi
leaq 0x6526b(%rip), %rsi     # 0x998eb
pushq $0x2
popq %rdx
callq 0x34f59
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x3469d
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0x3468f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
movslq %edi, %rbp
leaq (,%rbp,4), %r12
leaq 0x651ec(%rip), %r13     # 0x998ae
pushq $0x2
popq %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x34f59
movq %rax, %r14
pushq $0x3
popq %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x34f59
movq %rax, (%r15)
xorl %ecx, %ecx
testl %ebp, %ebp
cmovlel %ecx, %ebp
cmpq %rcx, %rbp
je 0x346ff
andl $0x0, (%rax,%rcx,4)
movl (%rbx), %edx
movl %edx, (%r14,%rcx,4)
incq %rcx
jmp 0x346eb
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_O2/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:
xorl %r8d, %r8d
testl %ecx, %ecx
cmovlel %r8d, %ecx
testl %edx, %edx
cmovlel %r8d, %edx
pushq $0x1
popq %rax
cmpq %rdx, %r8
je 0x34902
xorl %r9d, %r9d
cmpq %r9, %rcx
je 0x34900
movl (%rdi,%r8,4), %r10d
leaq 0x1(%r9), %r11
cmpl (%rsi,%r9,4), %r10d
movq %r11, %r9
jne 0x348e5
incq %r8
jmp 0x348dd
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x18(%rsp)
xorl %r12d, %r12d
testl %edi, %edi
cmovgl %edi, %r12d
pushq $0x1
popq %rcx
movl %r12d, %eax
subl $0x1, %eax
jb 0x34933
addl %ecx, %ecx
jmp 0x3492a
movl %ecx, 0x14(%rsp)
movl %ecx, %ebx
leaq (,%rbx,4), %rdi
leaq 0x64fce(%rip), %r15     # 0x99916
pushq $0x4
popq %rdx
movq %r15, %rsi
callq 0x34f59
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rbx, 0x20(%rsp)
leaq (,%rbx,8), %rdi
pushq $0x5
popq %rdx
movq %r15, %rsi
callq 0x34f59
movq %rax, %r15
xorl %ebx, %ebx
pushq $0x2
popq %r13
cmpq 0x20(%rsp), %rbx
je 0x349e2
movq 0x8(%rsp), %rax
movq (%rax), %rcx
andl $0x0, (%rcx,%rbx,4)
xorl %r14d, %r14d
movl %ebx, %ebp
cmpl %r14d, %r12d
je 0x349dd
testb $0x1, %bpl
je 0x349d0
movslq (%rcx,%rbx,4), %rax
leaq 0x1(%rax), %rdx
movl %edx, (%rcx,%rbx,4)
movq (%r15,%rbx,8), %rdi
leaq 0x4(,%rax,4), %rsi
callq 0x34f30
movq %rax, (%r15,%rbx,8)
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movslq (%rcx,%rbx,4), %rdx
movl %r14d, -0x4(%rax,%rdx,4)
movl %ebp, %eax
cltd
idivl %r13d
incl %r14d
movl %eax, %ebp
jmp 0x34994
incq %rbx
jmp 0x3497c
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, (%rax)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %eax
movl %esi, %ecx
sarl $0x1f, %ecx
andl %esi, %ecx
incl %edx
leaq (%rdi,%rax,4), %r8
addq $-0x4, %r8
movl %esi, %eax
testl %eax, %eax
jle 0x34a35
movl (%r8), %r9d
leal 0x1(%r9), %r10d
movl %r10d, (%r8)
decl %eax
decl %edx
addq $-0x4, %r8
cmpl %edx, %r9d
jge 0x34a14
incl %eax
movl %eax, %ecx
jmp 0x34a3c
xorl %eax, %eax
testl %esi, %esi
js 0x34a3c
retq
movslq %ecx, %rcx
movslq %esi, %rdx
pushq $0x1
popq %rax
cmpq %rdx, %rcx
jge 0x34a3b
movl -0x4(%rdi,%rcx,4), %esi
incl %esi
movl %esi, (%rdi,%rcx,4)
incq %rcx
jmp 0x34a45
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movl %ecx, %eax
xorl %r11d, %r11d
movq %r11, %r9
leaq (%rax,%r11), %r10
testl %r10d, %r10d
jle 0x34a99
leaq (%rax,%r9), %r10
decq %r10
movl %r10d, %r11d
movl (%rdx,%r11,4), %ebx
leal 0x1(%rbx), %r10d
movl %r10d, (%rdx,%r11,4)
leaq -0x1(%r9), %r11
decl %r8d
cmpl %r8d, %ebx
jge 0x34a5e
leal -0x1(%rcx), %eax
cltq
addq %r11, %rax
incq %rax
jmp 0x34aae
addq %r9, %rax
je 0x34ae4
leal -0x1(%rcx), %eax
cltq
leaq (%rdx,%rax,4), %r8
addq %r9, %rax
movl (%r8,%r9,4), %r10d
movslq %r10d, %r8
movl (%rsi,%r8,4), %r8d
movl %r8d, (%rdi,%rax,4)
movslq %ecx, %rcx
addq %rcx, %r9
movl $0x1, %eax
cmpq %rcx, %r9
jge 0x34ae6
movslq -0x4(%rdx,%r9,4), %r8
leaq 0x1(%r8), %r10
movl %r10d, (%rdx,%r9,4)
movl 0x4(%rsi,%r8,4), %r8d
movl %r8d, (%rdi,%r9,4)
incq %r9
jmp 0x34ac4
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %esi, %eax
testl %eax, %eax
jle 0x34b00
movl -0x4(%rdi,%rax,4), %ecx
cmpl %edx, %ecx
jl 0x34b03
andl $0x0, -0x4(%rdi,%rax,4)
decq %rax
jmp 0x34aea
xorl %eax, %eax
retq
incl %ecx
movl %ecx, -0x4(%rdi,%rax,4)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %esi, %eax
testl %eax, %eax
jle 0x34b2b
movl -0x4(%rdi,%rax,4), %ecx
movl -0x4(%rdx,%rax,4), %esi
decl %esi
cmpl %esi, %ecx
jl 0x34b2e
andl $0x0, -0x4(%rdi,%rax,4)
decq %rax
jmp 0x34b0f
xorl %eax, %eax
retq
incl %ecx
movl %ecx, -0x4(%rdi,%rax,4)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %ecx, %eax
testl %eax, %eax
jle 0x34b58
movslq -0x4(%rdx,%rax,4), %rcx
cmpl %r8d, %ecx
jl 0x34b5b
andl $0x0, -0x4(%rdx,%rax,4)
movl (%rsi), %ecx
movl %ecx, -0x4(%rdi,%rax,4)
decq %rax
jmp 0x34b3a
xorl %eax, %eax
retq
leaq 0x1(%rcx), %r8
movl %r8d, -0x4(%rdx,%rax,4)
movl 0x4(%rsi,%rcx,4), %ecx
movl %ecx, -0x4(%rdi,%rax,4)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
leal -0x2(%rsi), %eax
movl %eax, %ecx
testl %ecx, %ecx
js 0x34b93
movl %ecx, %edx
movl (%rbx,%rdx,4), %edi
cmpl 0x4(%rbx,%rdx,4), %edi
jl 0x34ba5
decl %ecx
jmp 0x34b80
xorl %ebp, %ebp
cmpl $-0x2, %eax
jle 0x34ba7
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %eax
decl %esi
movslq %eax, %r15
leaq (%rbx,%r15,4), %rdi
movl (%rdi), %eax
movslq %esi, %r12
leaq (%rbx,%r12,4), %rsi
addq $0x4, %rsi
movq %rsi, %rcx
addq $-0x4, %rsi
cmpl -0x4(%rcx), %eax
jge 0x34bbd
callq 0x3537f
leaq (%rbx,%r15,4), %r14
addq $0x4, %r14
incq %r15
leaq (%rbx,%r12,4), %rbx
pushq $0x1
popq %rbp
cmpq %r12, %r15
jge 0x34b9a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3537f
decq %r12
incq %r15
addq $0x4, %r14
addq $-0x4, %rbx
jmp 0x34be0
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edi, %eax
testb $0x1, %al
je 0x34ca6
movapd %xmm0, %xmm1
jmp 0x34cae
movsd 0x60872(%rip), %xmm1    # 0x95520
pushq $0x2
popq %rcx
cltd
idivl %ecx
testl %eax, %eax
jle 0x34cc8
mulsd %xmm0, %xmm0
testb $0x1, %al
je 0x34cc4
mulsd %xmm0, %xmm1
shrl %eax
jmp 0x34cb4
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmath.c
// Function: pythag
double pythag(double a, double b)
{
 double absa, absb;
 absa = fabs(a);
 absb = fabs(b);
 if (absa > absb) 
   return absa * sqrt(1.0 + fpow(absb / absa, 2));
 else 
   return (absb == 0.0 ? 0.0 : absb * sqrt(1.0 + fpow(absa / absb, 2)));
}

// Assembly:
pushq %rax
movapd %xmm0, %xmm2
movapd 0x614f6(%rip), %xmm0    # 0x961e0
andpd %xmm0, %xmm2
andpd %xmm1, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x34d03
divsd %xmm2, %xmm0
movsd %xmm2, (%rsp)
jmp 0x34d1c
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm1
jne 0x34d0f
jnp 0x34d4a
movsd %xmm0, (%rsp)
divsd %xmm0, %xmm2
movapd %xmm2, %xmm0
pushq $0x2
popq %rdi
callq 0x34c9a
addsd 0x607f4(%rip), %xmm0    # 0x95520
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x34d3c
sqrtsd %xmm0, %xmm0
jmp 0x34d41
callq 0x4300
movsd (%rsp), %xmm3
mulsd %xmm0, %xmm3
movapd %xmm3, %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmath.c
// Function: factorial
int factorial(int n)
{
 int i, result = 1;
 for (i = 2; i <= n; i++)
   result *= i;
 return result;
}

// Assembly:
pushq $0x1
popq %rax
pushq $0x2
popq %rcx
cmpl %edi, %ecx
jg 0x34dcd
imull %ecx, %eax
incl %ecx
jmp 0x34dc2
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x34e40
movl %esi, %ebx
movl %edi, %ebp
testl %esi, %esi
sete %al
movl %edi, %r14d
subl %esi, %r14d
sete %cl
orb %al, %cl
je 0x34e4b
movsd 0x606e0(%rip), %xmm0    # 0x95520
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movsd %xmm0, 0x10(%rsp)
pushq $0x2
popq %r15
movsd 0x611eb(%rip), %xmm0    # 0x96048
cmpl %ebp, %r15d
jg 0x34e96
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4160
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movsd %xmm1, 0x10(%rsp)
addsd 0x6068f(%rip), %xmm0    # 0x95520
incl %r15d
jmp 0x34e5d
pushq $0x2
popq %rbp
movsd 0x611a7(%rip), %xmm0    # 0x96048
cmpl %r14d, %ebp
jg 0x34ed9
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4160
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movsd %xmm1, 0x10(%rsp)
addsd 0x6064b(%rip), %xmm0    # 0x95520
incl %ebp
jmp 0x34ea1
pushq $0x2
popq %rbp
movsd 0x61164(%rip), %xmm0    # 0x96048
cmpl %ebx, %ebp
jg 0x34f1b
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4160
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movsd %xmm1, 0x10(%rsp)
addsd 0x60609(%rip), %xmm0    # 0x95520
incl %ebp
jmp 0x34ee4
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4060
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmemory.c
// Function: alloc
void *alloc(void *p, size_t size, int count)
{
 /*!Last Changed 02.02.2004 added safemalloc*/
 if (count == 1)
   return safemalloc(size, "alloc", 2);
 else
   return saferealloc(p, size, "alloc", 4);
}

// Assembly:
cmpl $0x1, %edx
jne 0x34f4a
leaq 0x64f67(%rip), %rax     # 0x99ea3
pushq $0x2
popq %rdx
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x34f59
leaq 0x64f52(%rip), %rdx     # 0x99ea3
pushq $0x4
popq %rcx
jmp 0x34f8e
// File: /workspace/github_c_makefile_star2_O2/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 0x34f74
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x649d5(%rip), %rdi     # 0x99950
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4030
xorl %edi, %edi
callq 0x40c0
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %r14d
movq %rdi, %rbx
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x34fea
movq (%rbx,%r15,8), %rdi
callq 0x4170
incq %r15
jmp 0x34fd7
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4170
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmemory.c
// Function: free_3d
void free_3d(void ***p,int size1,int size2)
{
/*!Last Changed 23.02.2001*/
 int i,j;
 for (i = 0; i < size1; i++)
   for (j = 0; j < size2; j++)
     safe_free(p[i][j]);
 for (i = 0; i < size1; i++)
   safe_free(p[i]);
 safe_free(p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r15d
movl %esi, %ebx
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %r15d
movq %rdi, %r14
testl %esi, %esi
cmovlel %r12d, %ebx
cmpq %rbx, %r12
je 0x35040
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x3503b
movq (%r14,%r12,8), %rax
movq (%rax,%r13,8), %rdi
callq 0x4170
incq %r13
jmp 0x35024
incq %r12
jmp 0x3501c
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x35056
movq (%r14,%r15,8), %rdi
callq 0x4170
incq %r15
jmp 0x35043
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4170
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmemory.c
// Function: safecalloc
void* safecalloc(size_t elementcount, size_t elementsize, char* functionname, int line)
{
 /*!Last Changed 02.02.2004*/
 void* result;
 result = calloc(elementcount, elementsize);
 if (!result)
  {
   printf(m1305, functionname, line);
   exit(0);
  }
 else
  {
   #ifdef HEAP_DEBUG
     heap_debug_insert_data(result, elementcount * elementsize, functionname, line);
   #endif
   return result;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
callq 0x4290
testq %rax, %rax
je 0x35082
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x648c7(%rip), %rdi     # 0x99950
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4030
xorl %edi, %edi
callq 0x40c0
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmemory.c
// Function: safecalloc_2d
void** safecalloc_2d(size_t elementsize1, size_t elementsize2, int elementcount1, int elementcount2, char* functionname, int line)
{
 /*!Last Changed 06.02.2005*/
 void** result;
 int i;
 result = safemalloc(elementsize1 * elementcount1, functionname, line);
 for (i = 0; i < elementcount1; i++)
   result[i] = safecalloc(elementcount2, elementsize2, functionname, line);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r13d
movq %rsi, (%rsp)
movslq %edx, %rbp
imulq %rbp, %rdi
movq %r8, %r15
movq %r8, %rsi
movl %r9d, %r14d
movl %r9d, %edx
callq 0x34f59
movq %rax, %r12
movslq %r13d, %r13
xorl %ebx, %ebx
testl %ebp, %ebp
cmovlel %ebx, %ebp
cmpq %rbx, %rbp
je 0x350f3
movq %r13, %rdi
movq (%rsp), %rsi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x35067
movq %rax, (%r12,%rbx,8)
incq %rbx
jmp 0x350d3
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmemory.c
// Function: safecalloc_3d
void*** safecalloc_3d(size_t elementsize1, size_t elementsize2, size_t elementsize3, int elementcount1, int elementcount2, int elementcount3, char* functionname, int line)
{
 /*!Last Changed 06.02.2005*/
 void*** result;
 int i, j;
 result = safemalloc(elementsize1 * elementcount1, functionname, line);
 for (i = 0; i < elementcount1; i++)
   result[i] = safemalloc(elementsize2 * elementcount2, functionname, line);
 for (i = 0; i < elementcount1; i++)
   for (j = 0; j < elementcount2; j++)
     result[i][j] = safecalloc(elementcount3, elementsize3, functionname, line);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %ebx
movq %rdx, %r14
movq %rsi, %rbp
movl 0x58(%rsp), %edx
movq 0x50(%rsp), %rsi
movslq %ecx, %r15
imulq %r15, %rdi
callq 0x34f59
movq %rax, %r12
movslq %ebx, %r13
imulq %rbp, %r13
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
cmpq %rbp, %r15
je 0x35168
movq %r13, %rdi
movq 0x50(%rsp), %rsi
movl 0x58(%rsp), %edx
callq 0x34f59
movq %rax, (%r12,%rbp,8)
incq %rbp
jmp 0x35149
movslq 0xc(%rsp), %r13
xorl %ebp, %ebp
testl %ebx, %ebx
cmovlel %ebp, %ebx
movq %r15, 0x10(%rsp)
cmpq %r15, %rbp
je 0x351b1
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x351a7
movq %r13, %rdi
movq %r14, %rsi
movq 0x50(%rsp), %rdx
movl 0x58(%rsp), %ecx
callq 0x35067
movq (%r12,%rbp,8), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x35181
incq %rbp
movq 0x10(%rsp), %r15
jmp 0x35179
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmemory.c
// Function: safemalloc_2d
void** safemalloc_2d(size_t elementsize1, size_t elementsize2, int elementcount1, int elementcount2, char* functionname, int line)
{
 /*!Last Changed 06.02.2005*/
 void** result;
 int i;
 result = safemalloc(elementsize1 * elementcount1, functionname, line);
 for (i = 0; i < elementcount1; i++)
   result[i] = safemalloc(elementsize2 * elementcount2, functionname, line);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r14
movl %ecx, %ebp
movq %rsi, (%rsp)
movslq %edx, %r13
imulq %r13, %rdi
movq %r8, %rsi
movl %r9d, %edx
callq 0x34f59
movq %rax, %r15
movslq %ebp, %r12
imulq (%rsp), %r12
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
cmpq %rbp, %r13
je 0x3521b
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x34f59
movq %rax, (%r15,%rbp,8)
incq %rbp
jmp 0x35200
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmemory.c
// Function: safemalloc_3d
void*** safemalloc_3d(size_t elementsize1, size_t elementsize2, size_t elementsize3, int elementcount1, int elementcount2, int elementcount3, char* functionname, int line)
{
 /*!Last Changed 06.02.2005*/
 void*** result;
 int i, j;
 result = safemalloc(elementsize1 * elementcount1, functionname, line);
 for (i = 0; i < elementcount1; i++)
   result[i] = safemalloc(elementsize2 * elementcount2, functionname, line);
 for (i = 0; i < elementcount1; i++)
   for (j = 0; j < elementcount2; j++)
     result[i][j] = safemalloc(elementsize3 * elementcount3, functionname, line);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x4(%rsp)
movl %r8d, %ebx
movq %rdx, 0x8(%rsp)
movq %rsi, %r13
movl 0x58(%rsp), %edx
movq 0x50(%rsp), %rsi
movslq %ecx, %rbp
imulq %rbp, %rdi
movl %edx, %r14d
callq 0x34f59
movq %rax, %r15
movslq %ebx, %r12
imulq %r13, %r12
xorl %r13d, %r13d
testl %ebp, %ebp
cmovlel %r13d, %ebp
cmpq %r13, %rbp
je 0x35294
movq %r12, %rdi
movq 0x50(%rsp), %rsi
movl %r14d, %edx
callq 0x34f59
movq %rax, (%r15,%r13,8)
incq %r13
jmp 0x35276
movslq 0x4(%rsp), %r12
imulq 0x8(%rsp), %r12
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
movq %rbp, 0x10(%rsp)
cmpq %rbp, %r13
je 0x352e0
xorl %ebp, %ebp
cmpq %rbp, %rbx
je 0x352d6
movq %r12, %rdi
movq 0x50(%rsp), %rsi
movl %r14d, %edx
callq 0x34f59
movq (%r15,%r13,8), %rcx
movq %rax, (%rcx,%rbp,8)
incq %rbp
jmp 0x352b4
incq %r13
movq 0x10(%rsp), %rbp
jmp 0x352ad
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/olcaytaner[P]Isell/libmisc.c
// Function: set_precision
void set_precision(char* precisionst, char* before, char* after)
{
 /*!Last Changed 05.07.2005*/
 char st[10];
 strcpy(precisionst, "");
 if (before)
   strcat(precisionst, before);
 sprintf(st, "%%4.%dlf", get_parameter_i("precision"));
 strcat(precisionst, st);
 if (after)
   strcat(precisionst, after);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movb $0x0, (%rdi)
testq %rsi, %rsi
je 0x35324
movq %r14, %rdi
callq 0x41e0
leaq 0x6464d(%rip), %rdi     # 0x99978
callq 0x4cd35
leaq 0x64638(%rip), %rsi     # 0x9996f
leaq 0x6(%rsp), %r15
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x41b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x41e0
testq %rbx, %rbx
je 0x3536c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x41e0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq