LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x38a4a
movl %eax, 0x4(%rsp)
movl %ebx, 0x14(%rsp)
testl %ebx, %ebx
jle 0x38a38
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 0x3afe4
movq %rax, %r14
movl (%rsp), %ecx
incl %ecx
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
leaq 0x70f75(%rip), %rsi     # 0xa98bd
movq %rbp, %rdx
movl %ecx, (%rsp)
xorl %eax, %eax
callq 0x41b0
movq %rbx, %rdi
leaq 0x7300e(%rip), %rsi     # 0xab96d
callq 0x40f0
testq %rax, %rax
je 0x38a38
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
leaq 0x70f4b(%rip), %rsi     # 0xa98ca
movq %rbp, %rdx
movl (%rsp), %ecx
xorl %eax, %eax
callq 0x41b0
movq %r15, %rdi
leaq 0x72fd7(%rip), %rsi     # 0xab96d
callq 0x40f0
testq %rax, %rax
je 0x38a38
movq %rax, %r13
movq 0x20(%rsp), %rdi
leaq 0x72fa8(%rip), %rsi     # 0xab95b
callq 0x40f0
testq %rax, %rax
je 0x38a38
movq %rax, %r15
cmpl $0x0, 0x4(%rsp)
jle 0x38a06
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 0x389f4
movq %r13, %rsi
movq %r12, %rdi
callq 0x41f0
incq %rbp
cmpq %rbp, 0x28(%rsp)
jne 0x389c9
movq %r15, %rdi
callq 0x42a0
movq %rbx, %rdi
callq 0x42a0
movq %r13, %rdi
callq 0x42a0
movq %r14, %rdi
callq 0x3a180
movl (%rsp), %eax
cmpl 0x14(%rsp), %eax
movq 0x18(%rsp), %rbp
jne 0x38928
addq $0x7a1c8, %rsp          # imm = 0x7A1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x72eb6(%rip), %rsi     # 0xab96d
callq 0x40f0
testq %rax, %rax
je 0x38b18
movq %rax, %rbx
movq 0x9b505(%rip), %r15     # 0xd3fd0
movq (%r15), %rdx
movq %rsp, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x4120
testq %rax, %rax
je 0x38b03
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 0x38ae3
movq %rbx, %rdi
callq 0x42a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
leaq 0x70e06(%rip), %rdi     # 0xa9925
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O3/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 0x38b62
movl %r14d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpb $0x2e, (%rbx,%rcx)
je 0x38b67
incq %rcx
cmpq %rcx, %rax
jne 0x38b52
jmp 0x38b6a
xorl %r14d, %r14d
jmp 0x38b6a
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 0x38ba1
movl %eax, %esi
movzbl (%rbx,%rsi), %esi
decl %ecx
cmpl $0x5c, %esi
je 0x38b9b
decq %rax
cmpl $0x2f, %esi
jne 0x38b82
leal 0x1(%rcx), %r12d
jmp 0x38ba3
movl %edx, %ecx
movl %r14d, %eax
subl %ecx, %eax
movslq %eax, %r15
leaq 0x70d25(%rip), %rsi     # 0xa98d7
movq %r15, %rdi
movl $0xb, %edx
callq 0x3a0e1
cmpl %r14d, %r12d
jge 0x38be5
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 0x38bd2
movb $0x0, -0x1(%rax,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x72d2c(%rip), %rsi     # 0xab95b
callq 0x40f0
testq %rax, %rax
je 0x38c89
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
leaq 0x70c90(%rip), %rsi     # 0xa98e6
movq %r14, %rdi
callq 0x4280
xorl %r14d, %r14d
testq %rax, %rax
je 0x38c7f
leaq 0x70c79(%rip), %r15     # 0xa98e6
incl %r14d
xorl %edi, %edi
movq %r15, %rsi
callq 0x4280
testq %rax, %rax
jne 0x38c6d
movq %rbx, %rdi
callq 0x42a0
jmp 0x38c8f
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_O3/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
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r15
callq 0x38a4a
movslq %eax, %rdi
shlq $0x3, %rdi
leaq 0x70bda(%rip), %rsi     # 0xa98ea
movl $0x5, %edx
callq 0x3a0e1
movq %rax, %r14
leaq 0x72c37(%rip), %rsi     # 0xab95b
movq %r15, %rdi
callq 0x40f0
testq %rax, %rax
je 0x38e10
movq %rax, %r15
leaq 0x70f41(%rip), %rsi     # 0xa9c80
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4070
movq $-0x1, %rcx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x38df6
movq %r12, 0x10(%rsp)
leaq 0x70f11(%rip), %r12     # 0xa9c80
leaq 0x8(%rsp), %r13
xorl %ebp, %ebp
cvttsd2si 0x8(%rsp), %eax
testl %ebp, %ebp
jle 0x38d92
movl %ebp, %ecx
xorl %edx, %edx
cmpl %eax, (%r14,%rdx,8)
je 0x38da6
incq %rdx
cmpq %rdx, %rcx
jne 0x38d84
movslq %ebp, %rcx
movl %eax, (%r14,%rcx,8)
movl $0x1, 0x4(%r14,%rcx,8)
incl %ebp
jmp 0x38dab
incl 0x4(%r14,%rdx,8)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x4070
cmpl $-0x1, %eax
jne 0x38d76
testl %ebp, %ebp
movq 0x10(%rsp), %r12
movq $-0x1, %rcx
jle 0x38df6
movl %ebp, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl 0x4(%r14,%rdx,8), %esi
cmpl %ebx, %esi
cmovgl %esi, %ebx
cmovgl %edx, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x38dde
movslq %ecx, %rcx
movl (%r14,%rcx,8), %ebp
movl %ebx, (%r12)
movq %r14, %rdi
callq 0x3a180
movq %r15, %rdi
callq 0x42a0
jmp 0x38e15
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %rax, %r15
movl %r15d, %eax
movslq %r15d, %rbp
leal 0x1(%rbp), %r13d
leaq (%r14,%rax), %rcx
decq %rcx
xorl %edx, %edx
leal (%r15,%rdx), %esi
testl %esi, %esi
jle 0x38f18
leaq -0x1(%rdx), %rbx
addl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
cmpb $0x2e, (%rcx,%rdx)
movq %rbx, %rdx
jne 0x38e4f
addl %ebx, %eax
movl %r15d, %ecx
subl %eax, %ecx
movslq %ecx, %r12
leaq 0x70a74(%rip), %rsi     # 0xa98f4
movq %r12, %rdi
movl $0x9, %edx
callq 0x3a0e1
movb $0x0, -0x1(%rax,%r12)
movq %rax, %r12
leal (%r15,%rbx), %eax
incl %eax
cmpl %r15d, %eax
jge 0x38ec5
incq %rbx
addq %rbp, %r14
movq %r12, %rax
addq %rbp, %rax
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
subq %r13, %rax
movb (%r14,%rbx), %cl
movb %cl, (%rax,%rbx)
incq %rbx
testl %ebx, %ebx
jne 0x38eb7
leaq 0x70a36(%rip), %rsi     # 0xa9902
movq %r12, %rdi
callq 0x4260
testl %eax, %eax
je 0x38f1f
leaq 0x6c89e(%rip), %rsi     # 0xa577d
movq %r12, %rdi
callq 0x4260
testl %eax, %eax
je 0x38f23
leaq 0x70a14(%rip), %rsi     # 0xa9906
movq %r12, %rdi
callq 0x4260
testl %eax, %eax
je 0x38f2a
leaq 0x70a07(%rip), %rsi     # 0xa990c
movq %r12, %rdi
callq 0x4260
xorl %ebp, %ebp
negl %eax
sbbl %ebp, %ebp
orl $0x3, %ebp
jmp 0x38f2f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x38f37
xorl %ebp, %ebp
jmp 0x38f2f
movl $0x1, %ebp
jmp 0x38f2f
movl $0x2, %ebp
movq %r12, %rdi
callq 0x3a180
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_O3/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 0x729f2(%rip), %rsi     # 0xab95b
callq 0x40f0
testq %rax, %rax
je 0x3902c
movq %rax, %r15
movq %rsp, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %rax, %rdx
callq 0x4120
testq %rax, %rax
je 0x38fa9
movq %rsp, %r12
incl (%rbx)
movq %r12, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r15, %rdx
callq 0x4120
testq %rax, %rax
jne 0x38f92
movq %r15, %rdi
callq 0x42a0
movslq (%rbx), %rdi
shlq $0x3, %rdi
leaq 0x70951(%rip), %rsi     # 0xa9910
movl $0xd, %edx
callq 0x3a0e1
movq %rax, %rbx
leaq 0x72988(%rip), %rsi     # 0xab95b
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 0x39022
movq %rsp, %r15
movq %rbx, %r12
movq (%r12), %rdi
movq %r15, %rsi
callq 0x3b494
movq %rax, (%r12)
movq %r15, %rdi
movl $0x7a120, %esi          # imm = 0x7A120
movq %r14, %rdx
callq 0x4120
addq $0x8, %r12
testq %rax, %rax
jne 0x38ff9
movq %r14, %rdi
callq 0x42a0
jmp 0x3903f
leaq 0x6d1d7(%rip), %rdi     # 0xa620a
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_O3/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 0x728f7(%rip), %rsi     # 0xab95b
callq 0x40f0
testq %rax, %rax
je 0x390c8
movq %rax, %rbx
leaq 0x70c08(%rip), %rsi     # 0xa9c80
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4070
xorpd %xmm0, %xmm0
cmpl $-0x1, %eax
je 0x390de
movsd %xmm0, (%rsp)
leaq 0x70be4(%rip), %r14     # 0xa9c80
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 0x390a1
jmp 0x390e3
leaq 0x6d13b(%rip), %rdi     # 0xa620a
movq %r14, %rsi
xorl %eax, %eax
callq 0x4030
xorps %xmm0, %xmm0
jmp 0x390f0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x42a0
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3915a
movq %rdi, %rax
movl %ecx, %edi
leaq (%rax,%rdi,4), %rdi
addq $0x4, %rdi
movl %ecx, %r8d
movl (%rax,%r8,4), %ecx
cmpl %edx, %ecx
jl 0x39132
movl $0x0, (%rax,%r8,4)
leal -0x1(%r8), %ecx
addq $-0x4, %rdi
testl %r8d, %r8d
jg 0x39110
jmp 0x3915a
incl %ecx
movl %ecx, (%rax,%r8,4)
leal 0x1(%r8), %eax
movl $0x1, %ebx
cmpl %esi, %eax
jge 0x3915a
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_O3/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 0x3918f
leal 0x1(%r9), %r10d
xorl %r11d, %r11d
movl %r9d, %eax
movslq (%rdx,%rax,4), %r9
cmpl %r8d, %r9d
jl 0x39192
movl $0x0, (%rdx,%rax,4)
movl (%rsi), %r9d
movl %r9d, (%rdi,%rax,4)
leal -0x1(%rax), %r9d
decq %r11
testl %eax, %eax
jg 0x3916a
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 0x39191
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 0x391b9
jmp 0x39191
// File: /workspace/github_c_makefile_star2_O3/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 0x70750(%rip), %rsi     # 0xa993e
movl $0x2, %edx
callq 0x3a0e1
testl %r14d, %r14d
jle 0x3928d
movl %ebx, %ecx
incl %ebx
andl $-0x2, %ebx
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x6d223(%rip), %xmm1    # 0xa6440
xorl %ecx, %ecx
movdqa 0x6d229(%rip), %xmm2    # 0xa6450
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x6d259(%rip), %xmm4    # 0xa6490
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0x3926b
movl %ecx, (%rax,%rcx,4)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x39280
leal 0x1(%rcx), %edx
movl %edx, 0x4(%rax,%rcx,4)
addq $0x2, %rcx
paddq %xmm4, %xmm1
cmpq %rcx, %rbx
jne 0x39237
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x70696(%rip), %rsi     # 0xa9950
movq %r12, %rdi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r14
movq %r12, %rdi
leaq 0x7067c(%rip), %rsi     # 0xa9950
movl $0x3, %edx
callq 0x3a0e1
movq %rax, (%r15)
testl %r13d, %r13d
jle 0x392fc
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 0x392ea
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_O3/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 0x70646(%rip), %rsi     # 0xa996c
movl $0x2, %edx
callq 0x3a0e1
testl %r14d, %r14d
jle 0x3934c
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_O3/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 0x7060f(%rip), %rsi     # 0xa997b
movl $0x2, %edx
callq 0x3a0e1
testl %r14d, %r14d
jle 0x39392
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_O3/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 0x7057f(%rip), %rsi     # 0xa993e
movq %r12, %rdi
movl $0x2, %edx
callq 0x3a0e1
movq %rax, %r14
movq %r12, %rdi
leaq 0x70565(%rip), %rsi     # 0xa993e
movl $0x3, %edx
callq 0x3a0e1
movq %rax, (%r15)
testl %r13d, %r13d
jle 0x39404
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 0x393ef
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_O3/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 0x39718
testl %ecx, %ecx
jle 0x39719
movl %edx, %edx
movl %ecx, %ecx
xorl %r8d, %r8d
movl (%rdi,%r8,4), %r9d
xorl %r10d, %r10d
cmpl (%rsi,%r10,4), %r9d
je 0x39710
incq %r10
cmpq %r10, %rcx
jne 0x39700
jmp 0x39719
incq %r8
cmpq %rdx, %r8
jne 0x396f9
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x39745
movl %ebp, %eax
addl %ebx, %ebx
decl %eax
jne 0x3973f
movl %ebx, %r15d
leaq (,%r15,4), %rdi
leaq 0x7024f(%rip), %r12     # 0xa99a6
movq %r12, %rsi
movl $0x4, %edx
callq 0x3a0e1
movq %rax, (%r14)
shlq $0x3, %r15
movq %r15, %rdi
movq %r12, %rsi
movl $0x5, %edx
callq 0x3a0e1
movq %rax, %r15
cmpl $0x1, %ebx
movl %ebx, 0x4(%rsp)
movl %ebx, %eax
adcl $0x0, %eax
movq %rax, 0x10(%rsp)
movq (%r14), %rcx
xorl %ebx, %ebx
movl $0x0, (%rcx,%rbx,4)
testl %ebp, %ebp
jle 0x397ed
xorl %r12d, %r12d
movl %ebx, %r13d
testb $0x1, %r13b
je 0x397d7
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 0x3a0b4
movq %rax, (%r15,%rbx,8)
movq (%r14), %rcx
movslq (%rcx,%rbx,4), %rdx
movl %r12d, -0x4(%rax,%rdx,4)
movl %r13d, %eax
shrl $0x1f, %eax
addl %r13d, %eax
sarl %eax
incl %r12d
movl %eax, %r13d
cmpl %r12d, %ebp
jne 0x397a5
incq %rbx
cmpq 0x10(%rsp), %rbx
jne 0x39794
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_O3/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 0x3984a
movl (%r8), %r9d
leal 0x1(%r9), %r10d
movl %r10d, (%r8)
decl %eax
decl %edx
addq $-0x4, %r8
cmpl %edx, %r9d
jge 0x39829
incl %eax
movl %eax, %ecx
jmp 0x39850
xorl %eax, %eax
testl %esi, %esi
jns 0x3987d
movl $0x1, %eax
cmpl %esi, %ecx
jge 0x3987d
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 0x3986d
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r10d
xorl %r11d, %r11d
movq %r11, %r9
leaq (%r10,%r11), %rax
testl %eax, %eax
jle 0x398c0
leaq (%r10,%r9), %rax
decq %rax
movl %eax, %r11d
movl (%rdx,%r11,4), %ebx
leal 0x1(%rbx), %eax
movl %eax, (%rdx,%r11,4)
leaq -0x1(%r9), %r11
decl %r8d
cmpl %r8d, %ebx
jge 0x39885
leal -0x1(%rcx), %r8d
movslq %r8d, %r8
addq %r11, %r8
incq %r8
jmp 0x398d9
movq %r10, %rax
addq %r9, %rax
je 0x39916
leal -0x1(%rcx), %eax
movslq %eax, %r8
leaq (%rdx,%r8,4), %rax
addq %r9, %r8
movl (%rax,%r9,4), %eax
cltq
movl (%rsi,%rax,4), %eax
movl %eax, (%rdi,%r8,4)
addl %r9d, %r10d
movl $0x1, %eax
cmpl %ecx, %r10d
jge 0x39918
movslq %ecx, %r8
leaq (%rdx,%r8,4), %rcx
leaq (%rdi,%r8,4), %rdx
movslq -0x4(%rcx,%r9,4), %rdi
leaq 0x1(%rdi), %r8
movl %r8d, (%rcx,%r9,4)
movl 0x4(%rsi,%rdi,4), %edi
movl %edi, (%rdx,%r9,4)
incq %r9
jne 0x398fa
jmp 0x39918
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3993e
movl %esi, %ecx
incq %rcx
movl -0x8(%rdi,%rcx,4), %esi
cmpl %edx, %esi
jl 0x3993f
movl $0x0, -0x8(%rdi,%rcx,4)
decq %rcx
cmpq $0x1, %rcx
ja 0x39925
retq
incl %esi
movl %esi, -0x8(%rdi,%rcx,4)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x39978
movl %esi, %ecx
incq %rcx
movl -0x8(%rdi,%rcx,4), %esi
movl -0x8(%rdx,%rcx,4), %r8d
decl %r8d
cmpl %r8d, %esi
jl 0x39979
movl $0x0, -0x8(%rdi,%rcx,4)
decq %rcx
cmpq $0x1, %rcx
ja 0x39956
retq
incl %esi
movl %esi, -0x8(%rdi,%rcx,4)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x399b3
movl %ecx, %ecx
incq %rcx
movslq -0x8(%rdx,%rcx,4), %r9
cmpl %r8d, %r9d
jl 0x399b4
movl $0x0, -0x8(%rdx,%rcx,4)
movl (%rsi), %r9d
movl %r9d, -0x8(%rdi,%rcx,4)
decq %rcx
cmpq $0x1, %rcx
ja 0x39990
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_O3/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 0x399fc
movl %r15d, %eax
movl (%rbx,%rax,4), %ecx
cmpl 0x4(%rbx,%rax,4), %ecx
jl 0x39a02
leal -0x1(%r15), %eax
testl %r15d, %r15d
movl %eax, %r15d
jg 0x399e2
jmp 0x39a69
cmpl $-0x1, %r15d
je 0x39a69
decl %r14d
movslq %r15d, %rax
leaq (%rbx,%rax,4), %rdi
movl (%rdi), %eax
movslq %r14d, %r12
leaq (%rbx,%r12,4), %rsi
addq $0x4, %rsi
movq %rsi, %rcx
addq $-0x4, %rsi
cmpl -0x4(%rcx), %eax
jge 0x39a19
callq 0x3a5af
incl %r15d
movl $0x1, %ebp
cmpl %r14d, %r15d
jge 0x39a6b
movslq %r15d, %r15
leaq (%rbx,%r12,4), %r14
leaq (%rbx,%r15,4), %rbx
incq %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a5af
decq %r12
addq $-0x4, %r14
addq $0x4, %rbx
leaq 0x1(%r15), %rax
cmpq %r12, %r15
movq %rax, %r15
jl 0x39a45
jmp 0x39a6b
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x39b1e
movapd %xmm0, %xmm1
jmp 0x39b26
movsd 0x6b9fa(%rip), %xmm1    # 0xa5520
cmpl $0x2, %edi
jl 0x39b44
mulsd %xmm0, %xmm0
testb $0x2, %dil
je 0x39b39
mulsd %xmm0, %xmm1
movl %edi, %eax
shrl %eax
cmpl $0x3, %edi
movl %eax, %edi
ja 0x39b2b
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6c67f(%rip), %xmm3    # 0xa61e0
andpd %xmm3, %xmm0
andpd %xmm1, %xmm3
ucomisd %xmm3, %xmm0
jbe 0x39b89
divsd %xmm0, %xmm3
mulsd %xmm3, %xmm3
addsd 0x6b9a1(%rip), %xmm3    # 0xa5520
sqrtsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
jmp 0x39bb0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x39b95
jnp 0x39bb0
divsd %xmm3, %xmm0
mulsd %xmm0, %xmm0
addsd 0x6b97b(%rip), %xmm0    # 0xa5520
xorps %xmm2, %xmm2
sqrtsd %xmm0, %xmm2
mulsd %xmm3, %xmm2
movapd %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x39ce7
leal 0x2(%rdi), %eax
andl $-0x4, %eax
addl $-0x2, %edi
movd %edi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa 0x6fd77(%rip), %xmm3    # 0xa99c0
movdqa 0x6fd7f(%rip), %xmm1    # 0xa99d0
movl $0x4, %ecx
movdqa 0x6fd82(%rip), %xmm4    # 0xa99e0
movdqa %xmm1, %xmm2
pmuludq %xmm3, %xmm1
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
pshufd $0xf5, %xmm3, %xmm5     # xmm5 = xmm3[1,1,3,3]
pshufd $0xf5, %xmm2, %xmm6     # xmm6 = xmm2[1,1,3,3]
pmuludq %xmm5, %xmm6
pshufd $0xe8, %xmm6, %xmm5     # xmm5 = xmm6[0,2,2,3]
punpckldq %xmm5, %xmm1    # xmm1 = xmm1[0],xmm5[0],xmm1[1],xmm5[1]
paddd %xmm4, %xmm3
movl %ecx, %edx
addl $-0x4, %ecx
addl %eax, %edx
addl $-0x4, %edx
cmpl $0x4, %edx
jne 0x39c5e
negl %ecx
movd %ecx, %xmm3
pshufd $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
por 0x6fd48(%rip), %xmm3    # 0xa99f0
movdqa 0x6c7a0(%rip), %xmm4    # 0xa6450
pxor %xmm4, %xmm0
pxor %xmm4, %xmm3
pcmpgtd %xmm0, %xmm3
pand %xmm3, %xmm2
pandn %xmm1, %xmm3
por %xmm2, %xmm3
pshufd $0xee, %xmm3, %xmm0     # xmm0 = xmm3[2,3,2,3]
pshufd $0xff, %xmm3, %xmm1     # xmm1 = xmm3[3,3,3,3]
pshufd $0xf5, %xmm3, %xmm2     # xmm2 = xmm3[1,1,3,3]
pmuludq %xmm1, %xmm2
pmuludq %xmm3, %xmm0
pmuludq %xmm2, %xmm0
movd %xmm0, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x39fad
movl %esi, %ebx
movl %edi, %r14d
testl %esi, %esi
sete %al
movl %edi, %ebp
subl %esi, %ebp
sete %cl
orb %al, %cl
je 0x39fb8
movsd 0x6b573(%rip), %xmm0    # 0xa5520
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %r14d
jl 0x3a008
leal -0x1(%r14), %r15d
movsd 0x6c076(%rip), %xmm1    # 0xa6040
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 0x6b51d(%rip), %xmm1    # 0xa5520
decl %r15d
jne 0x39fca
cmpl $0x2, %ebp
jl 0x3a059
movl %ebx, %ebp
notl %ebp
addl %r14d, %ebp
movsd 0x6c024(%rip), %xmm1    # 0xa6040
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 0x6b4cb(%rip), %xmm1    # 0xa5520
decl %ebp
jne 0x3a01c
cmpl $0x2, %ebx
jl 0x3a0a5
decl %ebx
movsd 0x6bfd8(%rip), %xmm1    # 0xa6040
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 0x6b47f(%rip), %xmm1    # 0xa5520
decl %ebx
jne 0x3a068
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4060
// File: /workspace/github_c_makefile_star2_O3/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 0x3a0fc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6f925(%rip), %rdi     # 0xa9a28
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4030
xorl %edi, %edi
callq 0x40c0
// File: /workspace/github_c_makefile_star2_O3/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 0x3a173
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x3a16b
callq 0x4170
incq %r15
cmpq %r15, %r14
jne 0x3a15d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4170
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/libmemory.c
// Function: free_3d
void free_3d(void ***p,int size1,int size2)
{
/*!Last Changed 23.02.2001*/
 int i,j;
 for (i = 0; i < size1; i++)
   for (j = 0; j < size2; j++)
     safe_free(p[i][j]);
 for (i = 0; i < size1; i++)
   safe_free(p[i]);
 safe_free(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x3a1e6
movl %edx, %r14d
movl %esi, 0x4(%rsp)
movl %esi, %r15d
movl %edx, %r12d
xorl %r13d, %r13d
testl %r14d, %r14d
jle 0x3a1c3
xorl %ebp, %ebp
movq (%rbx,%r13,8), %rax
movq (%rax,%rbp,8), %rdi
callq 0x4170
incq %rbp
cmpq %rbp, %r12
jne 0x3a1ae
incq %r13
cmpq %r15, %r13
jne 0x3a1a7
cmpl $0x0, 0x4(%rsp)
jle 0x3a1e6
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x4170
incq %r14
cmpq %r14, %r15
jne 0x3a1d5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4170
// File: /workspace/github_c_makefile_star2_O3/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 0x3a217
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6f80a(%rip), %rdi     # 0xa9a28
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4030
xorl %edi, %edi
callq 0x40c0
// File: /workspace/github_c_makefile_star2_O3/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
movq %r8, %r14
movl %ecx, %r13d
movl %edx, %ebp
movq %rsi, (%rsp)
movslq %edx, %rbx
imulq %rbx, %rdi
movq %r8, %rsi
movl %r9d, %r15d
movl %r9d, %edx
callq 0x3a0e1
movq %rax, %r12
testl %ebx, %ebx
jle 0x3a289
movslq %r13d, %r13
movl %ebp, %ebp
xorl %ebx, %ebx
movq %r13, %rdi
movq (%rsp), %rsi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x3a1fc
movq %rax, (%r12,%rbx,8)
incq %rbx
cmpq %rbx, %rbp
jne 0x3a26b
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_O3/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 $0x38, %rsp
movl %r9d, %ebp
movl %r8d, 0xc(%rsp)
movl %ecx, %r14d
movq %rdx, 0x30(%rsp)
movq %rsi, %r15
movl 0x78(%rsp), %edx
movq 0x70(%rsp), %rsi
movslq %ecx, %rbx
imulq %rbx, %rdi
callq 0x3a0e1
movq %rax, 0x10(%rsp)
testl %ebx, %ebx
jle 0x3a398
movl %ebp, 0x18(%rsp)
movslq 0xc(%rsp), %r13
imulq %r15, %r13
movl %r14d, 0x24(%rsp)
movl %r14d, %r12d
xorl %ebx, %ebx
movl 0x78(%rsp), %ebp
movq 0x70(%rsp), %r14
movq 0x10(%rsp), %r15
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3a0e1
movq %rax, (%r15,%rbx,8)
incq %rbx
cmpq %rbx, %r12
jne 0x3a303
cmpl $0x0, 0x24(%rsp)
movl 0x18(%rsp), %eax
jle 0x3a398
movslq %eax, %rbx
movl 0xc(%rsp), %eax
xorl %r8d, %r8d
movq %r12, 0x28(%rsp)
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rbp
cmpl $0x0, 0xc(%rsp)
movl 0x78(%rsp), %r13d
movq 0x30(%rsp), %rsi
movq 0x70(%rsp), %rdx
jle 0x3a38b
xorl %r15d, %r15d
movq %rbx, %rdi
movq %rsi, %r14
movq %r8, %r12
movl %r13d, %ecx
callq 0x3a1fc
movq %r14, %rsi
movq %r12, %r8
movq (%rbp,%r12,8), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x70(%rsp), %rdx
movq 0x18(%rsp), %rax
incq %r15
cmpq %r15, %rax
jne 0x3a359
incq %r8
movq 0x28(%rsp), %r12
cmpq %r12, %r8
jne 0x3a340
movq 0x10(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x28, %rsp
movl %r9d, %ebp
movl %r8d, 0x4(%rsp)
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %r15
movl 0x68(%rsp), %edx
movq 0x60(%rsp), %rsi
movslq %ecx, %rbx
imulq %rbx, %rdi
callq 0x3a0e1
movq %rax, 0x8(%rsp)
testl %ebx, %ebx
jle 0x3a50f
movq %r14, 0x20(%rsp)
movl %ebp, 0x10(%rsp)
movslq 0x4(%rsp), %r13
imulq %r15, %r13
movl %r12d, %eax
xorl %ebx, %ebx
movl 0x68(%rsp), %ebp
movq 0x60(%rsp), %r14
movq 0x8(%rsp), %r15
movq %rax, 0x18(%rsp)
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3a0e1
movq %rax, (%r15,%rbx,8)
movq 0x18(%rsp), %rax
incq %rbx
cmpq %rbx, %rax
jne 0x3a484
testl %r12d, %r12d
movl 0x10(%rsp), %eax
movq 0x20(%rsp), %rcx
jle 0x3a50f
movslq %eax, %r13
imulq %rcx, %r13
movl 0x4(%rsp), %eax
xorl %esi, %esi
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rbx
cmpl $0x0, 0x4(%rsp)
movl 0x68(%rsp), %edx
movq 0x60(%rsp), %r12
jle 0x3a505
xorl %ebp, %ebp
movq %r13, %rdi
movq %rsi, %r14
movq %r12, %rsi
movl %edx, %r15d
callq 0x3a0e1
movq %r14, %rsi
movl %r15d, %edx
movq (%rbx,%r14,8), %rcx
movq %rax, (%rcx,%rbp,8)
movq 0x10(%rsp), %rax
incq %rbp
cmpq %rbp, %rax
jne 0x3a4d9
incq %rsi
cmpq 0x18(%rsp), %rsi
jne 0x3a4c7
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3a554
movq %r14, %rdi
callq 0x41e0
leaq 0x6f4f5(%rip), %rdi     # 0xa9a50
callq 0x54920
leaq 0x6f4e0(%rip), %rsi     # 0xa9a47
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 0x3a59c
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
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/libmisc.c
// Function: findmincounts
int* findmincounts(char** names, int count)
{
 /*!Last Changed 25.01.2005*/
 int i, j, length, *result = safecalloc(count, sizeof(int), "findmincounts", 1);
 double** data, min;
 FILE* infile;
 length = file_length(names[0]);
 data = (double**) safemalloc_2d(sizeof(double*), sizeof(double), count, length, "findmincounts", 5);
 for (i = 0; i < count; i++)
  {
   infile = fopen(names[i], "r");
   if (!infile)
    {
     printf(m1274, names[i]);
     return NULL;
    }
   for (j = 0; j < length; j++)
     fscanf(infile, "%lf", &(data[i][j]));
   fclose(infile);
  }
 for (j = 0; j < length; j++)
  {
   min = data[0][j];
   for (i = 1; i < count; i++)
     if (data[i][j] < min)
       min = data[i][j];
   for (i = 0; i < count; i++)
     if (data[i][j] == min)
       (result[i])++;
  }
 free_2d((void**)data, count);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r12
movslq %esi, %r15
leaq 0x6f367(%rip), %r14     # 0xa9a5a
movl $0x4, %esi
movq %r15, %rdi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x3a1fc
movq %rax, 0x18(%rsp)
movq %r12, 0x10(%rsp)
movq (%r12), %rdi
callq 0x38a4a
movl %eax, %ebp
movl $0x8, %edi
movl $0x8, %esi
movl %r15d, %edx
movl %eax, %ecx
movq %r14, %r8
movl $0x5, %r9d
callq 0x3a3ac
movq %rax, %r14
movl %ebx, 0x4(%rsp)
movl %ebx, %r13d
movl %ebp, (%rsp)
movl %ebp, %eax
movq %rax, 0x8(%rsp)
testl %r15d, %r15d
jle 0x3a7ca
movq 0x8(%rsp), %rax
leaq (,%rax,8), %r12
leaq 0x6f519(%rip), %rbp     # 0xa9c80
xorl %ebx, %ebx
movq %r13, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq (%rax,%rbx,8), %rdi
leaq 0x711dd(%rip), %rsi     # 0xab95b
callq 0x40f0
testq %rax, %rax
je 0x3a845
movq %rax, %r15
cmpl $0x0, (%rsp)
jle 0x3a7b5
xorl %r13d, %r13d
movq (%r14,%rbx,8), %rdx
addq %r13, %rdx
movq %r15, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x4070
addq $0x8, %r13
cmpq %r13, %r12
jne 0x3a798
movq %r15, %rdi
callq 0x42a0
incq %rbx
movq 0x20(%rsp), %r13
cmpq %r13, %rbx
jne 0x3a76e
cmpl $0x0, (%rsp)
movq 0x18(%rsp), %rbx
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %r8
jle 0x3a83b
movq (%r14), %rax
xorl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm1
cmpl $0x2, %esi
jl 0x3a80d
movl $0x1, %edx
movq (%r14,%rdx,8), %rdi
movsd (%rdi,%rcx,8), %xmm0
minsd %xmm1, %xmm0
incq %rdx
movapd %xmm0, %xmm1
cmpq %rdx, %r13
jne 0x3a7f2
jmp 0x3a811
movapd %xmm1, %xmm0
testl %esi, %esi
jle 0x3a833
xorl %edx, %edx
movq (%r14,%rdx,8), %rdi
movsd (%rdi,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x3a82b
jp 0x3a82b
incl (%rbx,%rdx,4)
incq %rdx
cmpq %rdx, %r13
jne 0x3a817
incq %rcx
cmpq %r8, %rcx
jne 0x3a7e3
movq %r14, %rdi
callq 0x3a14b
jmp 0x3a85e
movq 0x10(%rsp), %rax
movq (%rax,%rbx,8), %rsi
leaq 0x6b9b5(%rip), %rdi     # 0xa620a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4030
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq