LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: symmetry_thermo
int symmetry_thermo(char seq[])
{
        int i = 0;
        int seq_len=strlen(seq);
        int mp = seq_len/2;
        if(seq_len%2==1)
                return 0;          

        while(i<mp) 
        {
                if((seq[i]=='A'&&seq[seq_len-1-i]!='T')||(seq[i]=='T'&&seq[seq_len-1-i]!='A')||(seq[seq_len-1-i]=='A'&&seq[i]!='T')||(seq[seq_len-1-i]=='T'&&seq[i]!='A'))
                        return 0;   
                if((seq[i]=='C'&&seq[seq_len-1-i]!='G')||(seq[i]=='G'&&seq[seq_len-1-i]!='C')||(seq[seq_len-1-i]=='C'&&seq[i]!='G')||(seq[seq_len-1-i]=='G'&&seq[i]!='C'))
                        return 0;
		i++;
        }
        return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x10b0
movl %eax, %ecx
andl $0x80000001, %ecx       # imm = 0x80000001
cmpl $0x1, %ecx
jne 0x8759
xorl %ecx, %ecx
jmp 0x881e
cmpl $0x2, %eax
jl 0x8819
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %ecx, %edx
leaq -0x1(%rax), %rsi
xorl %edi, %edi
movzbl (%rbx,%rdi), %r8d
cmpl $0x41, %r8d
jne 0x8791
movb $0x1, %r9b
cmpb $0x54, (%rbx,%rsi)
movq %rsi, %r10
je 0x87b1
jmp 0x8752
movq %rdi, %r10
notq %r10
addq %rax, %r10
movb $0x1, %r9b
cmpl $0x54, %r8d
jne 0x87b1
xorl %r9d, %r9d
cmpb $0x41, (%rbx,%rsi)
movl $0x0, %ecx
jne 0x881e
movzbl (%rbx,%r10), %ecx
cmpl $0x54, %ecx
je 0x87d3
cmpl $0x41, %ecx
jne 0x87de
xorl %ecx, %ecx
testb %r9b, %r9b
jne 0x881e
orl $0x4, %r8d
cmpl $0x47, %r8d
jne 0x880a
jmp 0x881e
cmpl $0x41, %r8d
je 0x880a
jmp 0x8752
cmpl $0x47, %r8d
je 0x87f4
cmpl $0x43, %r8d
jne 0x87fe
cmpl $0x47, %ecx
je 0x880a
jmp 0x8752
cmpl $0x43, %ecx
je 0x880a
jmp 0x8752
orl $0x4, %ecx
cmpl $0x47, %ecx
je 0x8752
incq %rdi
decq %rsi
cmpq %rdi, %rdx
jne 0x8778
movl $0x1, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: generate_primer
void generate_primer(char *seq,char primer[],int start,int length,int flag) //flag=0:plus
{
        int i;
        
        if(flag==0)
        {
                for(i=0;i<length;i++)
                        primer[i]=seq[start+i];
                primer[i]='\0';
        }
        else
        {
                for(i=0;i<length;i++)
                {
                        if((seq[start+length-1-i]=='A')||(seq[start+length-1-i]=='a'))
                                primer[i]='T';
                        else if((seq[start+length-1-i]=='T')||(seq[start+length-1-i]=='t'))
                                primer[i]='A';
                        else if((seq[start+length-1-i]=='C')||(seq[start+length-1-i]=='c'))
                                primer[i]='G';
                        else 
                                primer[i]='C';
                }
                primer[length]='\0';
        }
}

// Assembly:
testl %r8d, %r8d
je 0x96e6
testl %ecx, %ecx
jle 0x96e1
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movl %ecx, %eax
addl %ecx, %edx
decl %edx
xorl %r8d, %r8d
movabsq $0x100000001, %r9       # imm = 0x100000001
movabsq $0x400000004, %r10      # imm = 0x400000004
movabsq $0x8000000080000, %r11  # imm = 0x8000000080000
movslq %edx, %rbx
movzbl (%rdi,%rbx), %ebx
addl $-0x41, %ebx
cmpl $0x33, %ebx
ja 0x96cf
btq %rbx, %r9
jb 0x96cb
btq %rbx, %r10
jb 0x96c7
btq %rbx, %r11
jae 0x96cf
movb $0x41, %bl
jmp 0x96d1
movb $0x47, %bl
jmp 0x96d1
movb $0x54, %bl
jmp 0x96d1
movb $0x43, %bl
movb %bl, (%rsi,%r8)
incq %r8
decl %edx
cmpq %r8, %rax
jne 0x96a2
popq %rbx
popq %rbp
movslq %ecx, %rax
jmp 0x9706
testl %ecx, %ecx
jle 0x9704
movslq %edx, %rdx
movl %ecx, %eax
addq %rdx, %rdi
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
movb %dl, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x96f4
jmp 0x9706
xorl %eax, %eax
movb $0x0, (%rsi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: reverse
void reverse(char seq[],char rev[],int length)
{
	int i;

	for(i=0;i<length;i++)
        {
                if(seq[length-1-i]=='A')
                {
                        rev[i]='T';
                        continue;
                }
                if(seq[length-1-i]=='T')
                {
                        rev[i]='A';
                        continue;
                }
                if(seq[length-1-i]=='C')
                {
                        rev[i]='G';
                        continue;
                }
                rev[i]='C';
        }
        rev[i]='\0';
}

// Assembly:
testl %edx, %edx
jle 0x9753
pushq %rbp
movq %rsp, %rbp
movl %edx, %eax
movq %rsi, %rcx
movq %rax, %rdx
movzbl -0x1(%rdi,%rdx), %r8d
cmpl $0x41, %r8d
je 0x973d
cmpl $0x43, %r8d
je 0x9738
cmpl $0x54, %r8d
jne 0x9742
movb $0x41, %r8b
jmp 0x9745
movb $0x47, %r8b
jmp 0x9745
movb $0x54, %r8b
jmp 0x9745
movb $0x43, %r8b
movb %r8b, (%rcx)
incq %rcx
decq %rdx
jne 0x971b
popq %rbp
jmp 0x9755
xorl %eax, %eax
movb $0x0, (%rsi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: sort_merge
void sort_merge(int *store,int *temp,int *data,int start,int end)
{
        int middle;

        if(start<end)
        {
                middle=(start+end)/2;
                sort_merge(store,temp,data,start,middle);
                sort_merge(store,temp,data,(middle+1),end);
                merge(store,temp,data,start,end,middle);
        }
}

// Assembly:
cmpl %r8d, %ecx
jge 0xb62a
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %r14d
leal (%rbx,%r14), %eax
movl %eax, %r15d
shrl $0x1f, %r15d
addl %eax, %r15d
sarl %r15d
movq %rdi, -0x30(%rbp)
movq %rsi, %r13
movq %rdx, %r12
movl %r15d, %r8d
callq 0xb5b2
leal 0x1(%r15), %ecx
movq -0x30(%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %ebx, %r8d
callq 0xb5b2
movq -0x30(%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %r14d, %ecx
movl %ebx, %r8d
movl %r15d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb437
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: check_add
int check_add(int F3_pos,int *best_par,int expect)
{
        int i,dis;

	for(i=0;i<expect;i++)
	{
		if(best_par[i]==-1) //the empty record
			return 1;
		dis=best_par[i]-F3_pos;
		if(abs(dis)<300)
			return 0;
	}
        return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
testl %edx, %edx
jle 0xd8b3
movl %edx, %ecx
xorl %edx, %edx
movl (%rsi,%rdx,4), %r8d
cmpl $-0x1, %r8d
je 0xd8b3
subl %edi, %r8d
movl %r8d, %r9d
negl %r9d
cmovsl %r8d, %r9d
cmpl $0x12b, %r9d            # imm = 0x12B
jbe 0xd8b1
incq %rdx
cmpq %rdx, %rcx
jne 0xd887
jmp 0xd8b3
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: how_manyPrimer
void how_manyPrimer(struct Primer *head,int common)
{
	struct Primer *p_primer;
	struct Node *p_node;
	int i,num,*list;

	list=(int *)malloc(common*sizeof(int));
	p_primer=head;
	while(p_primer)
	{
		p_node=p_primer->common;
		for(i=0;i<common;i++)
			list[i]=0;
		while(p_node)
		{
			list[p_node->gi]=1;
			p_node=p_node->next;
		}
		num=0;
                for(i=0;i<common;i++)
                        num=num+list[i];
		p_primer->total=num;
		p_primer=p_primer->next;
	}
	free(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %rdi
shlq $0x2, %rdi
callq 0x11a0
movq %rax, %r15
testq %r14, %r14
je 0xd93f
movl %ebx, %r13d
leaq (,%r13,4), %rax
movq %rax, -0x30(%rbp)
movq 0x30(%r14), %r12
testl %ebx, %ebx
jle 0xd915
movq %r15, %rdi
xorl %esi, %esi
movq -0x30(%rbp), %rdx
callq 0x1100
jmp 0xd915
movslq 0x4(%r12), %rax
movl $0x1, (%r15,%rax,4)
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0xd903
testl %ebx, %ebx
jle 0xd930
xorl %ecx, %ecx
xorl %eax, %eax
addl (%r15,%rcx,4), %eax
incq %rcx
cmpq %rcx, %r13
jne 0xd922
jmp 0xd932
xorl %eax, %eax
movl %eax, 0x10(%r14)
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0xd8eb
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: how_manyProbe
void how_manyProbe(struct ExoProbe *head,int common)
{
        struct ExoProbe *p_primer;
        struct Node *p_node;
        int i,num,*list;

        list=(int *)malloc(common*sizeof(int));
        p_primer=head;
        while(p_primer)
        {
                p_node=p_primer->common;
                for(i=0;i<common;i++)
                        list[i]=0;
                while(p_node)
                {
                        list[p_node->gi]=1;
                        p_node=p_node->next;
                }
                num=0;
                for(i=0;i<common;i++)
                        num=num+list[i];
                p_primer->total=num;
                p_primer=p_primer->next;
        }
        free(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %rdi
shlq $0x2, %rdi
callq 0x11a0
movq %rax, %r15
testq %r14, %r14
je 0xd9df
movl %ebx, %r13d
leaq (,%r13,4), %rax
movq %rax, -0x30(%rbp)
movq 0x20(%r14), %r12
testl %ebx, %ebx
jle 0xd9b5
movq %r15, %rdi
xorl %esi, %esi
movq -0x30(%rbp), %rdx
callq 0x1100
jmp 0xd9b5
movslq 0x4(%r12), %rax
movl $0x1, (%r15,%rax,4)
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0xd9a3
testl %ebx, %ebx
jle 0xd9d0
xorl %ecx, %ecx
xorl %eax, %eax
addl (%r15,%rcx,4), %eax
incq %rcx
cmpq %rcx, %r13
jne 0xd9c2
jmp 0xd9d2
xorl %eax, %eax
movl %eax, 0xc(%r14)
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0xd98b
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/jiqingxiaoxi[P]RPA/RPA.c
// Function: check_uniq
int check_uniq(struct Primer *F,struct Primer *R)
{
        struct Node *s_F,*s_R,*b_R;

//plus
	b_R=R->specific;
        for(s_F=F->specific;s_F;s_F=s_F->next)
        {
                if(s_F->plus!=1)
                        continue;
                for(s_R=b_R;s_R;s_R=s_R->next)
                {
			if(s_R->gi<s_F->gi)
			{
				b_R=s_R->next;
				continue;
			}
                        if(s_R->gi>s_F->gi)
                                break;
			if(s_R->pos<s_F->pos)
			{
				b_R=b_R->next;
                                continue;
                        }
			if(s_R->pos-s_F->pos>2000)
				break;
                        if(s_R->minus!=1)
                                continue;
			return 0;
                }
        }
//minus
	b_R=R->specific;
        for(s_F=F->specific;s_F;s_F=s_F->next)
        {
                if(s_F->minus!=1)
                        continue;
                for(s_R=b_R;s_R;s_R=s_R->next)
                {
                        if(s_R->gi<s_F->gi)
			{
				b_R=s_R->next;
                                continue;
			}
			if(s_R->gi>s_F->gi)
				break;
			if(s_R->pos>s_F->pos)
				break;
			if(s_R->pos-s_F->pos<-2000)
			{
                                b_R=b_R->next;
                                continue;
                        }
                        if(s_R->plus!=1)
                                continue;
			return 0;
                }
        }
	return 1;
}

// Assembly:
movq 0x38(%rdi), %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0xdab9
pushq %rbp
movq %rsp, %rbp
movq 0x38(%rsi), %rdx
movq %rcx, %rsi
movq %rdx, %rdi
cmpl $0x1, 0x8(%rsi)
jne 0xda5c
testq %rdi, %rdi
je 0xda5c
movl 0x4(%rsi), %r8d
movq %rdi, %r9
movq %r9, %r10
cmpl %r8d, 0x4(%r9)
jl 0xda3d
jg 0xda5c
movl (%r9), %r10d
subl (%rsi), %r10d
jge 0xda43
movq %rdi, %r10
movq 0x10(%r10), %rdi
jmp 0xda53
cmpl $0x7d0, %r10d           # imm = 0x7D0
jg 0xda5c
cmpl $0x1, 0xc(%r9)
je 0xdab6
movq 0x10(%r9), %r9
testq %r9, %r9
jne 0xda27
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
jne 0xda15
jmp 0xdaaf
cmpl $0x1, 0xc(%rcx)
jne 0xdaab
testq %rdx, %rdx
je 0xdaab
movl 0x4(%rcx), %esi
movq %rdx, %rdi
movq %rdi, %r8
cmpl %esi, 0x4(%rdi)
jl 0xda96
jg 0xdaab
movl (%rdi), %r8d
subl (%rcx), %r8d
jg 0xdaab
cmpl $0xfffff830, %r8d       # imm = 0xFFFFF830
jge 0xda9c
movq %rdx, %r8
movq 0x10(%r8), %rdx
jmp 0xdaa2
cmpl $0x1, 0x8(%rdi)
je 0xdab6
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
jne 0xda78
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0xda67
jmp 0xdab8
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/hash10x.c
// Function: unpackFQB
void unpackFQB (U32 *u, char *s1, char *q1, char *s2, char *q2)
{
  char *s ; int i,j ;
  if ((s = s1))
    for (i =  0 ; i < 10 ; ++i) for (j = 16 ; j-- ; ) *s++ = (u[i] >> (2*j)) & 3 ;
  if ((s = q1))
    for (i = 10 ; i < 15 ; ++i) for (j = 32 ; j-- ; ) *s++ = (u[i] >> j) & 1 ;
  if ((s = s2))
    for (i = 15 ; i < 25 ; ++i) for (j = 16 ; j-- ; ) *s++ = (u[i] >> (2*j)) & 3 ;
  if ((s = q2))
    for (i = 25 ; i < 30 ; ++i) for (j = 32 ; j-- ; ) *s++ = (u[i] >> j) & 1 ;
}

// Assembly:
movq %rcx, %rax
testq %rsi, %rsi
je 0x1ce6
xorl %r9d, %r9d
movl $0x1e, %ecx
movl (%rdi,%r9,4), %r10d
shrl %cl, %r10d
andb $0x3, %r10b
movb %r10b, (%rsi)
incq %rsi
addl $-0x2, %ecx
cmpl $-0x2, %ecx
jne 0x1cc4
incq %r9
cmpq $0xa, %r9
jne 0x1cbf
testq %rdx, %rdx
je 0x1d11
movl $0xa, %ecx
movl $0x1f, %esi
movl (%rdi,%rcx,4), %r9d
btl %esi, %r9d
setb (%rdx)
incq %rdx
addl $-0x1, %esi
jb 0x1cf5
incq %rcx
cmpq $0xf, %rcx
jne 0x1cf0
testq %rax, %rax
je 0x1d40
movl $0xf, %edx
movl $0x1e, %ecx
movl (%rdi,%rdx,4), %esi
shrl %cl, %esi
andb $0x3, %sil
movb %sil, (%rax)
incq %rax
addl $-0x2, %ecx
cmpl $-0x2, %ecx
jne 0x1d20
incq %rdx
cmpq $0x19, %rdx
jne 0x1d1b
testq %r8, %r8
je 0x1d6a
movl $0x19, %eax
movl $0x1f, %ecx
movl (%rdi,%rax,4), %edx
btl %ecx, %edx
setb (%r8)
incq %r8
addl $-0x1, %ecx
jb 0x1d4f
incq %rax
cmpq $0x1e, %rax
jne 0x1d4a
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/hash10x.c
// Function: seqAddHashes
void seqAddHashes (char *s, int len, Array a, int readCount)
{
  SeqhashRCiterator *mi = moshRCiterator (hasher, s, len) ;
  U64 hash ; int pos ;
  while (moshRCnext (mi, &hash, &pos, 0))
    { HashTemp *h = arrayp(a,arrayMax(a),HashTemp) ;
      h->hash = hash ; h->read = readCount ; h->pos = pos ;
    }
  seqhashRCiteratorDestroy (mi) ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %edx
movq %rdi, %rsi
movq 0xe5ef(%rip), %rdi      # 0x10378
callq 0x8014
movq %rax, %r15
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x81bf
testb %al, %al
je 0x1de5
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %r13
movl 0x18(%r14), %esi
movq %r14, %rdi
callq 0x9131
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movl %ebx, 0x8(%rax)
movl 0x4(%rsp), %ecx
movl %ecx, 0xc(%rax)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x81bf
testb %al, %al
jne 0x1db3
movq %r15, %rdi
callq 0x1dfb
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/hash10x.c
// Function: fillHashTable
void fillHashTable (void)
{
  int i, j ;
  long nHashes = 0 ;

  hashCodes = arrayCreate(hashNumber,U32*) ;
  arrayMax(hashCodes) = hashNumber ;
  
  U32 *count = arrp(hashDepth,1,U32) ;
  for (i = 1 ; i < hashNumber ; ++i, ++count)
    if (*count)
      { arr(hashCodes,i,U32*) = new(*count, U32) ;
	nHashes += *count ;
      }

  U32 *hashN = new0 (hashNumber, U32) ;
  for (i = 1 ; i < arrayMax(clusterBlocks) ; ++i)
    { ClusterBlock *b = arrp(clusterBlocks, i, ClusterBlock) ;
      ClusterHash *c = b->clusHash ;
      for (j = 0 ; j < b->nHash ; ++j, ++c)
	arr(hashCodes,c->hash,U32*)[hashN[c->hash]++] = i ;
    }
  fprintf (outFile, "  filled hash table: %ld hashes from %d barcodes in %d bins\n",
	  nHashes, arrayMax(clusterBlocks), hashNumber) ;
#ifdef CHECK
  for (i = 0 ; i < hashNumber ; ++i)
    if (hashN[i] != arr(hashDepth,i,U32))
      die ("hashN[%d] = %d != hashDepth[%d] = %d", i, hashN[i], i, arr(hashDepth,i,U32)) ;
#endif
  free (hashN) ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0xda43(%rip), %edi      # 0x103a8
movl $0x8, %esi
callq 0x8e88
movq %rax, 0xda42(%rip)      # 0x103b8
movl 0xda2c(%rip), %ecx      # 0x103a8
movl %ecx, 0x18(%rax)
cmpl $0x2, %ecx
jb 0x29e3
movq 0xd9f5(%rip), %rax      # 0x10380
movslq 0x14(%rax), %r14
addq 0x8(%rax), %r14
xorl %r12d, %r12d
xorl %ebx, %ebx
leaq 0x1(%r12), %r15
movl (%r14,%r12,4), %edi
testq %rdi, %rdi
je 0x29d6
shlq $0x2, %rdi
callq 0x96c0
movq 0xda02(%rip), %rcx      # 0x103b8
movq 0x8(%rcx), %rdx
movslq 0x14(%rcx), %rcx
movslq %r15d, %rsi
imulq %rcx, %rsi
movq %rax, (%rdx,%rsi)
movl (%r14,%r12,4), %eax
addq %rax, %rbx
movl 0xd9d2(%rip), %ecx      # 0x103a8
leal 0x1(%r15), %eax
movq %r15, %r12
cmpl %ecx, %eax
jb 0x2998
jmp 0x29e5
xorl %ebx, %ebx
movl %ecx, %edi
movl $0x4, %esi
callq 0x96e8
movq %rax, %r14
movq 0xd98d(%rip), %rax      # 0x10388
movl 0x18(%rax), %ecx
cmpl $0x2, %ecx
jl 0x2a66
movq 0x8(%rax), %rdx
movl $0x1, %esi
movq 0xd9a5(%rip), %rdi      # 0x103b8
movslq 0x14(%rax), %r9
movslq %esi, %r8
imulq %r9, %r8
cmpl $0x0, 0x4(%rdx,%r8)
je 0x2a60
movq 0x10(%rdx,%r8), %rcx
movq 0x8(%rdi), %r9
xorl %r10d, %r10d
movl (%rcx,%r10,8), %r11d
movl 0x14(%rdi), %r15d
imull %r11d, %r15d
movq (%r9,%r15), %r15
movl (%r14,%r11,4), %r12d
leal 0x1(%r12), %ebp
movl %ebp, (%r14,%r11,4)
movl %esi, (%r15,%r12,4)
incq %r10
cmpl 0x4(%rdx,%r8), %r10d
jb 0x2a32
movl 0x18(%rax), %ecx
incl %esi
cmpl %ecx, %esi
jl 0x2a13
movq 0xd923(%rip), %rdi      # 0x10390
movl 0xd934(%rip), %r8d      # 0x103a8
leaq 0x79ed(%rip), %rsi      # 0xa468
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1150
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/hash10x.c
// Function: hashDepthHist
void hashDepthHist (void)
{
  if (!arrayMax(hashDepth)) { fprintf (stderr, "  no hash list to print stats for\n") ; return ; }
  Array a = arrayCreate (1024, int) ;
  int i ;
  for (i = 0 ; i < arrayMax(hashDepth) ; ++i)
    ++array(a, arr(hashDepth, i, U32), int) ;
  histogramReport ("HASH_COUNT", a) ;
  arrayDestroy (a) ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xd5ec(%rip), %rax      # 0x10380
cmpl $0x0, 0x18(%rax)
je 0x2e06
movl $0x400, %edi            # imm = 0x400
movl $0x4, %esi
callq 0x8e88
movq %rax, %rbx
movq 0xd5cd(%rip), %rax      # 0x10380
cmpl $0x0, 0x18(%rax)
jle 0x2de8
xorl %r14d, %r14d
movq 0x8(%rax), %rcx
movslq 0x14(%rax), %rax
movslq %r14d, %r14
imulq %r14, %rax
movl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x9131
incl (%rax)
incl %r14d
movq 0xd59e(%rip), %rax      # 0x10380
cmpl 0x18(%rax), %r14d
jl 0x2dbc
leaq 0x7749(%rip), %rdi      # 0xa538
movq %rbx, %rsi
callq 0x2a95
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8fd6
callq 0x1577
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/hash10x.c
// Function: codeSizeHist
void codeSizeHist (void)
{
  if (!clusterBlocks || !arrayMax (clusterBlocks))
    { fprintf (stderr, "  no barcodes to print stats for\n") ; return ; }
  Array hashHist = arrayCreate (1024, int) ;
  Array clusterHist = arrayCreate (1024, int) ;
  int i ;
  for (i = 0 ; i < arrayMax(clusterBlocks) ; ++i)
    { ClusterBlock *b = arrp (clusterBlocks, i, ClusterBlock) ;
      ++array(hashHist, b->nHash, int) ;
      ++array(clusterHist, b->nSubCluster, int) ;
    }
  histogramReport ("CODE_SIZE", hashHist) ;
  if (arrayMax(clusterHist) > 1) histogramReport ("CODE_CLUSTER", clusterHist) ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0xd565(%rip), %rax      # 0x10388
testq %rax, %rax
je 0x2ed4
cmpl $0x0, 0x18(%rax)
je 0x2ed4
movl $0x400, %edi            # imm = 0x400
movl $0x4, %esi
callq 0x8e88
movq %rax, %r14
movl $0x400, %edi            # imm = 0x400
movl $0x4, %esi
callq 0x8e88
movq %rax, %rbx
movq 0xd527(%rip), %rax      # 0x10388
cmpl $0x0, 0x18(%rax)
jle 0x2ea7
xorl %r15d, %r15d
movq 0x8(%rax), %r12
movslq 0x14(%rax), %r13
movslq %r15d, %r15
imulq %r15, %r13
movl 0x4(%r12,%r13), %esi
movq %r14, %rdi
callq 0x9131
incl (%rax)
movl 0x8(%r12,%r13), %esi
movq %rbx, %rdi
callq 0x9131
incl (%rax)
incl %r15d
movq 0xd4e7(%rip), %rax      # 0x10388
cmpl 0x18(%rax), %r15d
jl 0x2e6a
leaq 0x76b7(%rip), %rdi      # 0xa565
movq %r14, %rsi
callq 0x2a95
cmpl $0x2, 0x18(%rbx)
jl 0x2ed9
leaq 0x76ac(%rip), %rdi      # 0xa56f
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2a95
callq 0x1593
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/hash10x.c
// Function: printArrayStats
void printArrayStats (Array a)
{
  int i, *ai = arrp(a,0,int), sum = 0, min = -1, max = arrayMax(a)-1 ;
  double total = 0 ;
  for (i = 0 ; i < arrayMax(a) ; ++i, ++ai)
    if (*ai)
      { sum += *ai ; total += *ai * i ;
	if (min == -1) min = i ;
      }
  fprintf (outFile, "  %d mean %.1f min %d max %d\n", sum, total/sum, min, max) ;
}

// Assembly:
movl 0x18(%rdi), %r8d
testl %r8d, %r8d
jle 0x2f24
movq 0x8(%rdi), %rax
xorl %esi, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorpd %xmm0, %xmm0
xorl %edx, %edx
movl (%rax,%rsi,4), %edi
testl %edi, %edi
je 0x2f1a
addl %edi, %edx
imull %esi, %edi
xorps %xmm1, %xmm1
cvtsi2sd %edi, %xmm1
addsd %xmm1, %xmm0
cmpl $-0x1, %ecx
cmovel %esi, %ecx
incq %rsi
cmpl %esi, %r8d
jne 0x2efd
jmp 0x2f2f
xorpd %xmm0, %xmm0
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %edx, %edx
decl %r8d
movq 0xd457(%rip), %rdi      # 0x10390
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
leaq 0x7631(%rip), %rsi      # 0xa57c
movb $0x1, %al
jmp 0x1150
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/hash10x.c
// Function: cribText
char* cribText (int x)
{ static char text[32] ;
  char *s = text ;
  s += sprintf (s, "%d", x) ;
  if (crib) s += sprintf (s, ":%s", cribTypeName[cribType[x]]) ;
  if (crib && cribType[x] > CRIB_ERR && cribType[x] < CRIB_MUL)
    s += sprintf (s, "_%d.%d", crib[x].chr, crib[x].pos) ;
  sprintf (s, "-%d", arr(hashDepth, x, U32)) ;
  return text ;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
leaq 0xcec0(%rip), %r14      # 0x103e0
leaq 0x6fcb(%rip), %rsi      # 0xa4f2
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1230
movslq %eax, %rbx
addq %r14, %rbx
cmpq $0x0, 0xce7f(%rip)      # 0x103c0
movslq %ebp, %r14
je 0x35b2
movq 0xce7b(%rip), %rax      # 0x103c8
movzbl (%rax,%r14), %eax
leaq 0xb847(%rip), %rcx      # 0xeda0
movq (%rcx,%rax,8), %rdx
leaq 0x70cf(%rip), %rsi      # 0xa633
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1230
cltq
addq %rax, %rbx
movq 0xce46(%rip), %rax      # 0x103c0
testq %rax, %rax
je 0x35b2
movq 0xce42(%rip), %rcx      # 0x103c8
movb (%rcx,%r14), %cl
decb %cl
cmpb $0x2, %cl
ja 0x35b2
movswl (%rax,%r14,4), %edx
movzwl 0x2(%rax,%r14,4), %ecx
leaq 0x7094(%rip), %rsi      # 0xa637
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1230
cltq
addq %rax, %rbx
movq 0xcdc7(%rip), %rax      # 0x10380
movq 0x8(%rax), %rcx
movslq 0x14(%rax), %rax
imulq %r14, %rax
movl (%rcx,%rax), %edx
leaq 0x706f(%rip), %rsi      # 0xa63e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1230
leaq 0xce00(%rip), %rax      # 0x103e0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/hash10x.c
// Function: hashWithinRangeBuild
BOOL hashWithinRangeBuild (int min, int max)
{ 
  if (hashWithinRange && min == hashRangeMin && max == hashRangeMax) return FALSE ;
  if (!hashWithinRange) hashWithinRange = new0 (hashNumber, BOOL) ;
  int i, n ;
  for (i = 0 ; i < hashNumber ; ++i)
    { n = arr(hashDepth, i, U32) ;
      if (n >= min && n < max) hashWithinRange[i] = TRUE ;
    }
  hashRangeMin = min ; hashRangeMax = max ;
  return TRUE ;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movq 0xce0d(%rip), %rax      # 0x10400
testq %rax, %rax
je 0x360c
cmpl %ebp, 0xce0a(%rip)      # 0x10408
jne 0x360c
cmpl %ebx, 0xce06(%rip)      # 0x1040c
jne 0x360c
xorl %eax, %eax
jmp 0x3688
testq %rax, %rax
jne 0x3628
movl 0xcd91(%rip), %edi      # 0x103a8
movl $0x1, %esi
callq 0x96e8
movq %rax, 0xcdd8(%rip)      # 0x10400
movl 0xcd7a(%rip), %ecx      # 0x103a8
testl %ecx, %ecx
je 0x367a
movq 0xcd47(%rip), %rsi      # 0x10380
xorl %edx, %edx
movq 0x8(%rsi), %rdi
movslq 0x14(%rsi), %r8
movslq %edx, %r9
imulq %r8, %r9
movl (%rdi,%r9), %edi
cmpl %ebp, %edi
setl %r8b
cmpl %ebx, %edi
setge %dil
orb %r8b, %dil
jne 0x3670
movb $0x1, (%rax,%rdx)
movq 0xcd16(%rip), %rsi      # 0x10380
movl 0xcd38(%rip), %ecx      # 0x103a8
incq %rdx
movl %ecx, %edi
cmpq %rdi, %rdx
jb 0x363b
movl %ebp, 0xcd88(%rip)      # 0x10408
movl %ebx, 0xcd86(%rip)      # 0x1040c
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/hash10x.c
// Function: countHashNeighbours
Array countHashNeighbours (int x)
{
  U32 xCount = arr(hashDepth,x,U32) ; if (!xCount) return 0 ;
  HASH h = hashCreate (500000) ;
  Array a = arrayCreate (500000, int) ;
  int i,j ;
  for (i = 0 ; i < xCount ; ++i)
    { ClusterBlock *b = arrp(clusterBlocks, arr(hashCodes,x,U32*)[i], ClusterBlock) ;
      ClusterHash *c = b->clusHash ;
      for (j = 0 ; j < b->nHash ; ++j, ++c)
	if (c->hash != x && hashWithinRange[c->hash])
	  ++array (a, hashAdd(h,HASH_INT(c->hash)), int) ;
    }
  Array b = arrayCreate (256, int) ;
  for (i = 1 ; i < arrayMax(a) ; ++i) ++array (b, arr(a,i,int), int) ;
  arrayDestroy (a) ; hashDestroy (h) ;
  return b ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0xcb34(%rip), %rax      # 0x10380
movq 0x8(%rax), %rcx
movslq 0x14(%rax), %rax
movslq %edi, %rdx
movq %rdx, 0x20(%rsp)
imulq %rdx, %rax
movl (%rcx,%rax), %eax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x3980
movl %edi, %ebp
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x82e0
movq %rax, 0x10(%rsp)
movl $0x7a120, %edi          # imm = 0x7A120
movl $0x4, %esi
callq 0x8e88
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
movq 0xcae8(%rip), %rax      # 0x10388
movq 0x8(%rax), %r15
movq 0xcb0d(%rip), %rcx      # 0x103b8
movq 0x8(%rcx), %rdx
movslq 0x14(%rcx), %rcx
imulq 0x20(%rsp), %rcx
movq (%rdx,%rcx), %rcx
movl 0x14(%rax), %r12d
imull (%rcx,%r13,4), %r12d
movl 0x4(%r15,%r12), %eax
testl %eax, %eax
je 0x3917
movq 0x10(%r15,%r12), %rbx
xorl %r14d, %r14d
movl (%rbx,%r14,8), %esi
cmpl %ebp, %esi
je 0x390f
movq 0xcb1a(%rip), %rcx      # 0x10400
cmpb $0x0, (%rcx,%rsi)
je 0x390f
xorl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq 0x10(%rsp), %rdi
callq 0x84a4
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x9131
incl (%rax)
movl 0x4(%r15,%r12), %eax
incq %r14
cmpl %eax, %r14d
jb 0x38d7
incq %r13
cmpq 0x18(%rsp), %r13
jne 0x3899
movl $0x100, %edi            # imm = 0x100
movl $0x4, %esi
callq 0x8e88
movq %rax, %r15
movq 0x8(%rsp), %r14
cmpl $0x2, 0x18(%r14)
jl 0x396c
movl $0x1, %ebx
movq 0x8(%r14), %rax
movslq 0x14(%r14), %rcx
movslq %ebx, %rbx
imulq %rbx, %rcx
movl (%rax,%rcx), %esi
movq %r15, %rdi
callq 0x9131
incl (%rax)
incl %ebx
cmpl 0x18(%r14), %ebx
jl 0x3948
movq %r14, %rdi
callq 0x8fd6
movq 0x10(%rsp), %rdi
callq 0x839c
jmp 0x3983
xorl %r15d, %r15d
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_O3/richarddurbin[P]hash10x/hash10x.c
// Function: exploreHash
void exploreHash (int x)
{
  if (!hashWithinRange)
    { fprintf (stderr, "exploreHash called without hashDepthRange\n") ; return ; }
  Array shared = hashNeighbours (x) ; if (!shared) return ;
  fprintf (outFile, "  %d hashes sharing codes with %s\n", arrayMax(shared), cribText(x)) ;
  arraySort (shared, compareClusterRead) ;
  int i, count = 1, n = 0 ;
  ClusterHash *d = arrp(shared, 0, ClusterHash) ;
  for (i = 0 ; i <= arrayMax(shared) ; ++i, ++d)
    if (d->read != count || i == arrayMax(shared))
      { fprintf (outFile, "    %d sharing %d codes", n, count) ;
	if (n > 7) { fprintf (outFile, "  ...") ; n = 7 ; }
	while (n) { fprintf (outFile, " %s", cribText(d[-n].hash)) ; --n ; }
	fprintf (outFile, "\n") ;
	count = d->read ; n = 1 ;
      }
    else ++n ;
  
  arrayDestroy (shared) ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0xca58(%rip)      # 0x10400
je 0x3b07
movl %edi, %ebp
callq 0x368f
testq %rax, %rax
je 0x3b0c
movq %rax, %rbx
movq 0xc9c8(%rip), %r14      # 0x10390
movl 0x18(%rax), %r15d
movl %ebp, %edi
callq 0x3513
leaq 0x6cca(%rip), %rsi      # 0xa6a4
leaq 0xc9ff(%rip), %rcx      # 0x103e0
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x1150
movq 0x8(%rbx), %rdi
movslq 0x18(%rbx), %rsi
movslq 0x14(%rbx), %rdx
leaq -0x1d63(%rip), %rcx     # 0x1c9e
callq 0x1090
movl 0x18(%rbx), %eax
testl %eax, %eax
js 0x3af1
movq 0x8(%rbx), %r15
movl $0x1, %ecx
leaq 0x6d51(%rip), %r12      # 0xa772
leaq 0xc9b8(%rip), %r13      # 0x103e0
xorl %ebp, %ebp
xorl %r14d, %r14d
movq %rbx, (%rsp)
cmpl %eax, %r14d
je 0x3a46
movzwl 0x4(%r15), %edx
cmpl %edx, %ecx
jne 0x3a46
incl %ebp
jmp 0x3add
movq 0xc943(%rip), %rdi      # 0x10390
leaq 0x6c73(%rip), %rsi      # 0xa6c7
movl %ebp, %edx
xorl %eax, %eax
callq 0x1150
cmpl $0x8, %ebp
jl 0x3a81
movq 0xc927(%rip), %rcx      # 0x10390
movl $0x5, %esi
movl $0x1, %edx
leaq 0x6c65(%rip), %rdi      # 0xa6df
callq 0x1250
jmp 0x3a85
testl %ebp, %ebp
je 0x3abb
cmpl $0x7, %ebp
movl $0x7, %eax
cmovgel %eax, %ebp
movslq %ebp, %rbx
negq %rbx
movq 0xc8f3(%rip), %rbp      # 0x10390
movl (%r15,%rbx,8), %edi
callq 0x3513
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x1150
incq %rbx
jne 0x3a96
movq 0xc8ce(%rip), %rsi      # 0x10390
movl $0xa, %edi
callq 0x1100
movzwl 0x4(%r15), %ecx
movq (%rsp), %rbx
movl 0x18(%rbx), %eax
movl $0x1, %ebp
leal 0x1(%r14), %edx
addq $0x8, %r15
cmpl %eax, %r14d
movl %edx, %r14d
jl 0x3a31
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8fd6
callq 0x15af
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/hash10x.c
// Function: doubleShared
void doubleShared (int x1, int x2)
{
  if (!hashWithinRange)
    { fprintf (stderr, "doubleShared called without hashDepthRange\n") ; return ; }
  Array sh1 = hashNeighbours (x1) ; if (!sh1) return ;
  Array sh2 = hashNeighbours (x2) ; if (!sh2) { arrayDestroy (sh1) ; return ; }

  int i1 = 0, i2 = 0 ;
  ClusterHash *c1 = arrp(sh1, 0, ClusterHash), *c2 = arrp(sh2, 0, ClusterHash) ;
  while (i1 < arrayMax(sh1) && i2 < arrayMax(sh2))
    if (c1->hash == c2->hash && c1->read > 2 && c2->read > 2)
      { fprintf (outFile, "  hash %-8d code %-6d n1 %-3d n2 %-3d crib %s\n", c1->hash,
		*arr(hashCodes,c1->hash,U32*), c1->read, c2->read, cribText(c1->hash)) ;
	++c1 ; ++i1 ; ++c2 ; ++i2 ;
      }
    else if (c1->hash < c2->hash) { ++c1 ; ++i1 ; }
    else { ++c2 ; ++i2 ; }

  arrayDestroy (sh1) ; arrayDestroy (sh2) ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0xc8cf(%rip)      # 0x10400
je 0x3c6c
movl %esi, %ebp
callq 0x368f
testq %rax, %rax
je 0x3c71
movq %rax, 0x8(%rsp)
movl %ebp, %edi
callq 0x368f
testq %rax, %rax
je 0x3c54
movq 0x8(%rsp), %rdi
movl 0x18(%rdi), %edx
testl %edx, %edx
jle 0x3c47
movq 0x8(%rax), %r15
movq 0x8(%rdi), %rbx
xorl %r14d, %r14d
xorl %r13d, %r13d
movq %rax, 0x18(%rsp)
cmpl 0x18(%rax), %r14d
jge 0x3c47
movl (%rbx), %ebp
movl (%r15), %ecx
cmpl %ecx, %ebp
jne 0x3c2a
movzwl 0x4(%rbx), %r12d
cmpl $0x3, %r12d
jb 0x3c2a
movzwl 0x4(%r15), %esi
cmpl $0x3, %esi
jb 0x3c2a
movq 0xc7da(%rip), %rcx      # 0x10390
movq %rcx, 0x20(%rsp)
movq 0xc7f6(%rip), %rdx      # 0x103b8
movq 0x8(%rdx), %rcx
movl 0x14(%rdx), %edx
imull %ebp, %edx
movq (%rcx,%rdx), %rcx
movl (%rcx), %ecx
movl %ecx, 0x14(%rsp)
movl %ebp, %edi
movl %esi, 0x10(%rsp)
callq 0x3513
leaq 0xc7f8(%rip), %rax      # 0x103e0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
leaq 0x6b19(%rip), %rsi      # 0xa711
movl %ebp, %edx
movl 0x14(%rsp), %ecx
movl %r12d, %r8d
movl 0x10(%rsp), %r9d
xorl %eax, %eax
callq 0x1150
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rdi
addq $0x8, %rbx
incl %r13d
addq $0x8, %r15
incl %r14d
movl 0x18(%rdi), %edx
jmp 0x3c3e
cmpl %ecx, %ebp
jae 0x3c37
addq $0x8, %rbx
incl %r13d
jmp 0x3c3e
addq $0x8, %r15
incl %r14d
cmpl %edx, %r13d
jl 0x3b7f
movq %rax, %rbx
callq 0x8fd6
movq %rbx, %rdi
jmp 0x3c59
movq 0x8(%rsp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8fd6
callq 0x15cb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/hash10x.c
// Function: hashInfo
void hashInfo (int hMin, int hMax, int hIncrement)
{
  if (!hashWithinRange)
    { fprintf (stderr, "hashInfo called without hashDepthRange\n") ; return ; }
  int x ;
  for (x = hMin ; x < hMax ; x += hIncrement)
    { fprintf (outFile, "HASH_INFO  %s", cribText(x)) ;
      if (hashWithinRange[x])
	{ Array shared = hashNeighbours (x) ;
	  arraySort (shared, compareClusterRead) ;
	  ClusterHash *ch = arrp(shared, arrayMax(shared)-1, ClusterHash) ;
	  fprintf (outFile, " max share %d with %s", ch->read, cribText (ch->hash)) ; 
	  arrayDestroy (shared) ;
	}
      fputc ('\n', outFile) ;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0xc76d(%rip)      # 0x10400
je 0x3d7a
cmpl %esi, %edi
jge 0x3d6b
movslq %edi, %rbx
movslq %edx, %rax
movq %rax, (%rsp)
movslq %esi, %r15
leaq 0xc72b(%rip), %r14      # 0x103e0
movq 0xc6d4(%rip), %rbp      # 0x10390
movl %ebx, %edi
callq 0x3513
movq %rbp, %rdi
leaq 0x6a9b(%rip), %rsi      # 0xa768
movq %r14, %rdx
xorl %eax, %eax
callq 0x1150
movq 0xc722(%rip), %rax      # 0x10400
cmpb $0x0, (%rax,%rbx)
je 0x3d4d
movl %ebx, %edi
callq 0x368f
movq %rax, %rbp
movq 0x8(%rax), %rdi
movslq 0x18(%rax), %rsi
movslq 0x14(%rax), %rdx
leaq -0x2063(%rip), %rcx     # 0x1c9e
callq 0x1090
movq 0x8(%rbp), %rax
movslq 0x18(%rbp), %rcx
decq %rcx
movslq 0x14(%rbp), %rdx
imulq %rcx, %rdx
movq 0xc670(%rip), %r12      # 0x10390
movzwl 0x4(%rax,%rdx), %r13d
movl (%rax,%rdx), %edi
callq 0x3513
movq %r12, %rdi
leaq 0x6a3e(%rip), %rsi      # 0xa776
movl %r13d, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1150
movq %rbp, %rdi
callq 0x8fd6
movq 0xc63c(%rip), %rsi      # 0x10390
movl $0xa, %edi
callq 0x1100
addq (%rsp), %rbx
cmpq %r15, %rbx
jl 0x3cb5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x15e7
jmp 0x3d6b
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/hash10x.c
// Function: initialise
void initialise (int k, int w, int r, int B)
{
  srandom (r) ;

  if (k <= 0 || w <= 0) die ("k %d, w %d must be > 0; run without args for usage", k, w) ;
  hasher = seqhashCreate (k, w) ;

  hashTableBits = B ;
  if (hashTableBits < 20 || hashTableBits > 30)
    die ("hashTableBits %d out of range 20-30", hashTableBits) ;
  hashTableSize = (size_t)1 << hashTableBits ;
  hashTableMask = hashTableSize - 1 ;
  hashIndex = new0 (hashTableSize, U32) ;
  hashValue = new0 (hashTableSize>>2, U64) ;
  hashNumber = 1 ; // so true indexes != 0
  hashDepth = arrayCreate (1 << 20, U32) ;

  fprintf (outFile, "hash10x initialised with k = %d, w = %d, random seed = %d, hashtable bits = %d\n",
	  k, w, r, B) ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movl %edx, %edi
callq 0x1060
testl %r15d, %r15d
setg %al
testl %r14d, %r14d
setg %cl
testb %cl, %al
jne 0x535f
leaq 0x5e22(%rip), %rdi      # 0xb174
movl %r15d, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x95f8
movl %r15d, %edi
movl %r14d, %esi
callq 0x7984
movq %rax, 0xb007(%rip)      # 0x10378
movl %ebx, 0x9dd9(%rip)      # 0xf150
leal -0x1f(%rbx), %eax
movl %ebx, %ecx
cmpl $-0xc, %eax
ja 0x5397
leaq 0x5e1f(%rip), %rdi      # 0xb1a7
movl %ebx, %esi
xorl %eax, %eax
callq 0x95f8
movl 0x9db9(%rip), %ecx      # 0xf150
movl $0x1, %edi
shlq %cl, %rdi
movq %rdi, 0xaffa(%rip)      # 0x103a0
leaq -0x1(%rdi), %rax
movq %rax, 0xb09f(%rip)      # 0x10450
movl $0x4, %esi
callq 0x96e8
movq %rax, 0xafd6(%rip)      # 0x10398
movq 0xafd7(%rip), %rdi      # 0x103a0
shrq $0x2, %rdi
movl $0x8, %esi
callq 0x96e8
movq %rax, 0xafd2(%rip)      # 0x103b0
movl $0x1, 0xafc0(%rip)      # 0x103a8
movl $0x100000, %edi         # imm = 0x100000
movl $0x4, %esi
callq 0x8e88
movq %rax, 0xaf82(%rip)      # 0x10380
movq 0xaf8b(%rip), %rdi      # 0x10390
leaq 0x5dbf(%rip), %rsi      # 0xb1cb
movl %r15d, %edx
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebx, %r9d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1150
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/hash10x.c
// Function: exploreHash2
void exploreHash2 (int x, int clusterThreshold)
{
  Array hash1 = hashNeighbours (x) ; if (!hash1) return ;
  fprintf (outFile, "  %d hashes sharing codes with %s\n", arrayMax(hash1), cribText (x)) ;

  Array code1Count = arrayCreate (1024, U32) ;
  HASH code1Hash = hashCreate (1024) ;
  int i, j ;
  for (i = 0 ; i < arrayMax(hash1) ; ++i)
    if (arrp(hash1,i,ClusterHash)->read >= clusterThreshold)
      { for (j = 0 ; j < 27 ; ++j) ; }
  
  arrayDestroy (hash1) ; arrayDestroy (code1Count) ; hashDestroy (hash1) ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
callq 0x368f
testq %rax, %rax
je 0x69fd
movq %rax, %rbx
movq 0x99f7(%rip), %r14      # 0x10390
movl 0x18(%rax), %r15d
movl %ebp, %edi
callq 0x3513
leaq 0x3cf9(%rip), %rsi      # 0xa6a4
leaq 0x9a2e(%rip), %rcx      # 0x103e0
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x1150
movl $0x400, %edi            # imm = 0x400
movl $0x4, %esi
callq 0x8e88
movq %rax, %r14
movl $0x400, %edi            # imm = 0x400
callq 0x82e0
movq %rbx, %rdi
callq 0x8fd6
movq %r14, %rdi
callq 0x8fd6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x839c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/readseq.c
// Function: add
static void add (char c, char* *buf, int *buflen, int n)
{
  if (n >= *buflen)
    { 
      int blen = *buflen;
      if (blen < 0)
	{ blen = -blen ;
	  *buf = (char*) messalloc (blen) ;
	}
      else
	{ blen *= 2 ;
	  if ((*buf = realloc(*buf,blen)) == NULL)
             { fprintf (stderr, "REALLOC failure reqesting %d bytes - aborting\n", blen) ;
               exit (-1) ;
             }
	}
      *buflen = blen; 
    }
  (*buf)[n] = c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rsi, %r12
movl %edi, %ebp
movl (%rdx), %r15d
cmpl %ecx, %r15d
jle 0x6d43
movq (%r12), %rax
jmp 0x6d7d
movq %rdx, %r14
testl %r15d, %r15d
js 0x6d6b
addq %r15, %r15
movq (%r12), %rdi
movq %r15, %rsi
callq 0x11c0
movq %rax, (%r12)
testq %rax, %rax
jne 0x6d7a
movl %r15d, %edi
callq 0x19e2
negl %r15d
movl %r15d, %edi
callq 0x796b
movq %rax, (%r12)
movl %r15d, (%r14)
movslq %ebx, %rcx
movb %bpl, (%rax,%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/readseq.c
// Function: seqConvert
int seqConvert (char *seq, int *length, int *conv)
{
  int i, n = 0 ;
  int c ;

  for (i = 0 ; seq[i] ; ++i)
    { c = seq[i] ;
      if (length && i >= *length)
	break ;
      if (conv[c] < -2)
	{ fprintf (stderr, "Bad char 0x%x = '%c' at base %d in seqConvert\n", c, c, n) ;
	  return 0 ;
	}
      if (conv[c] >= 0)
	seq[n++] = conv[c] ;
    }
  if (n < i)
    seq[n] = 0 ;

  if (length)
    *length = n ;
  return n ;
}

// Assembly:
movb (%rdi), %r8b
testb %r8b, %r8b
je 0x72ac
xorl %ecx, %ecx
xorl %eax, %eax
testq %rsi, %rsi
je 0x7276
movslq (%rsi), %r9
cmpq %r9, %rcx
jge 0x729f
movsbq %r8b, %r9
movl (%rdx,%r9,4), %r9d
cmpl $-0x3, %r9d
jle 0x72b6
testl %r9d, %r9d
js 0x7292
movslq %eax, %r8
incl %eax
movb %r9b, (%rdi,%r8)
movb 0x1(%rdi,%rcx), %r8b
incq %rcx
testb %r8b, %r8b
jne 0x7269
cmpl %ecx, %eax
jge 0x72ae
movslq %eax, %rcx
movb $0x0, (%rdi,%rcx)
jmp 0x72ae
xorl %eax, %eax
testq %rsi, %rsi
je 0x72b5
movl %eax, (%rsi)
retq
pushq %rax
movsbl %r8b, %ecx
movq 0x7d2e(%rip), %rdx      # 0xeff0
movq (%rdx), %rdi
leaq 0x44ce(%rip), %rsi      # 0xb79a
movl %ecx, %edx
movl %eax, %r8d
xorl %eax, %eax
callq 0x1150
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/readseq.c
// Function: writeSequence
int writeSequence (FILE *fil, int *conv, 
		   char *seq, char *id, char *desc, int len)
{
  int i ;

  if (!fil)
    { fprintf (stderr, "ERROR: writeSequence requires a file\n") ;
      return 0 ;
    }
    
  if (id && *id)
    { fprintf (fil, ">%s", id) ;
      if (desc && *desc)
	fprintf (fil, " %s", desc) ;
      fprintf (fil, "\n") ;
    }

  for (i = 0 ; i < len ; ++i)
    { if (i && !(i%60))
	fputc ('\n', fil) ;
      if (conv[seq[i]] > 0)
	fputc (conv[seq[i]], fil) ;
      else
	{ fprintf (stderr, "ERROR in writeSequence: %s[%d] = %d does not convert\n",
		   id, i, seq[i]) ;
	  return 0 ;
	}
    }
  fputc ('\n', fil) ;
  return len ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x73cf
movl %r9d, %ebx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
testq %rcx, %rcx
je 0x7353
cmpb $0x0, (%r14)
je 0x7353
movq %r8, %rbp
leaq 0x44d5(%rip), %rsi      # 0xb7ef
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1150
testq %rbp, %rbp
je 0x7346
cmpb $0x0, (%rbp)
je 0x7346
leaq 0x3439(%rip), %rsi      # 0xa772
movq %r15, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x1150
movl $0xa, %edi
movq %r15, %rsi
callq 0x1100
movq %r14, 0x10(%rsp)
movl %ebx, 0xc(%rsp)
testl %ebx, %ebx
jle 0x73ad
movl 0xc(%rsp), %r14d
xorl %ebp, %ebp
movl $0x88888889, %ebx       # imm = 0x88888889
testq %rbp, %rbp
je 0x738f
movl %ebp, %eax
imulq %rbx, %rax
shrq $0x25, %rax
imull $-0x3c, %eax, %eax
addl %ebp, %eax
jne 0x738f
movl $0xa, %edi
movq %r15, %rsi
callq 0x1100
movsbq (%r12,%rbp), %r8
movl (%r13,%r8,4), %edi
testl %edi, %edi
jle 0x73d8
movq %r15, %rsi
callq 0x1100
incq %rbp
cmpq %rbp, %r14
jne 0x736c
movl $0xa, %edi
movq %r15, %rsi
callq 0x1100
movl 0xc(%rsp), %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1a9b
xorl %ebx, %ebx
jmp 0x73be
movq 0x7c11(%rip), %rax      # 0xeff0
movq (%rax), %rdi
leaq 0x440a(%rip), %rsi      # 0xb7f3
xorl %ebx, %ebx
movq 0x10(%rsp), %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1150
jmp 0x73be
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/readseq.c
// Function: writeFastq
int writeFastq (FILE *fil, int *conv, 
		char *seq, unsigned char *qual, char *id, char *desc, int len)
{
  int i ;

  if (!fil) { fprintf (stderr, "ERROR: writeFastq requires a file\n") ; return 0 ; }
  if (!id || !*id) { fprintf (stderr, "ERROR: writeFastq requires an id\n") ; return 0 ; }

  if (desc && *desc) 
    fprintf (fil, "@%s %s\n", id, desc) ;
  else
    fprintf (fil, "@%s\n", id) ;
  for (i = 0 ; i < len ; ++i)
    { if (i && !(i%60))
	fputc ('\n', fil) ;
      if (conv[seq[i]] > 0)
	fputc (conv[seq[i]], fil) ;
      else
	{ fprintf (stderr, "ERROR in writeSequence: %s[%d] = %d does not convert\n",
		   id, i, seq[i]) ;
	  return 0 ;
	}
    }
  fputc ('\n', fil) ;
    
  fprintf (fil, "+%s\n", id) ;
  for (i = 0 ; i < len ; ++i)
    { if (i && !(i%60))
	fputc ('\n', fil) ;
      fputc (qual[i]+33, fil) ;
    }
  fputc ('\n', fil) ;

  return len ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
testq %rdi, %rdi
je 0x758f
movq %r8, %r15
testq %r8, %r8
je 0x7588
cmpb $0x0, (%r15)
je 0x7588
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl 0x50(%rsp), %ebx
testq %r9, %r9
je 0x745e
cmpb $0x0, (%r9)
je 0x745e
leaq 0x4422(%rip), %rsi      # 0xb86e
movq %r14, %rdi
movq %r15, %rdx
movq %r9, %rcx
xorl %eax, %eax
callq 0x1150
jmp 0x7472
leaq 0x4411(%rip), %rsi      # 0xb876
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1150
testl %ebx, %ebx
jle 0x7545
movq %r15, 0x8(%rsp)
movl %ebx, %r12d
xorl %ebx, %ebx
movl $0x88888889, %r15d      # imm = 0x88888889
testq %rbx, %rbx
je 0x74ad
movl %ebx, %eax
imulq %r15, %rax
shrq $0x25, %rax
imull $-0x3c, %eax, %eax
addl %ebx, %eax
jne 0x74ad
movl $0xa, %edi
movq %r14, %rsi
callq 0x1100
movsbq (%r13,%rbx), %r8
movl (%rbp,%r8,4), %edi
testl %edi, %edi
jle 0x7598
movq %r14, %rsi
callq 0x1100
incq %rbx
cmpq %rbx, %r12
jne 0x748a
movl $0xa, %edi
movq %r14, %rsi
callq 0x1100
leaq 0x4397(%rip), %rsi      # 0xb87b
movq %r14, %rdi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x1150
cmpl $0x0, 0x50(%rsp)
movq 0x10(%rsp), %r13
jle 0x7566
xorl %ebx, %ebx
movl $0x88888889, %r15d      # imm = 0x88888889
testq %rbx, %rbx
je 0x752a
movl %ebx, %eax
imulq %r15, %rax
shrq $0x25, %rax
imull $-0x3c, %eax, %eax
addl %ebx, %eax
jne 0x752a
movl $0xa, %edi
movq %r14, %rsi
callq 0x1100
movzbl (%r13,%rbx), %edi
addl $0x21, %edi
movq %r14, %rsi
callq 0x1100
incq %rbx
cmpq %rbx, %r12
jne 0x7507
jmp 0x7566
movl $0xa, %edi
movq %r14, %rsi
callq 0x1100
leaq 0x4322(%rip), %rsi      # 0xb87b
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1150
movl $0xa, %edi
movq %r14, %rsi
callq 0x1100
movl 0x50(%rsp), %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1ab7
jmp 0x7594
callq 0x1ad3
xorl %ebp, %ebp
jmp 0x7577
movq 0x7a51(%rip), %rax      # 0xeff0
movq (%rax), %rdi
leaq 0x424a(%rip), %rsi      # 0xb7f3
xorl %ebp, %ebp
movq 0x8(%rsp), %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1150
jmp 0x7577