LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x13e8
pushq $0x1e
popq %r9
xorl %r10d, %r10d
cmpq $0xa, %r10
je 0x13e8
movl %r9d, %ecx
cmpl $-0x2, %ecx
je 0x13e3
movl (%rdi,%r10,4), %r11d
shrl %cl, %r11d
andb $0x3, %r11b
movb %r11b, (%rsi)
incq %rsi
addl $-0x2, %ecx
jmp 0x13c8
incq %r10
jmp 0x13bf
testq %rdx, %rdx
je 0x141a
pushq $0x1f
popq %rcx
pushq $0xa
popq %rsi
cmpq $0xf, %rsi
je 0x141a
movl %ecx, %r9d
cmpl $-0x1, %r9d
je 0x1415
movl (%rdi,%rsi,4), %r10d
btl %r9d, %r10d
setb (%rdx)
incq %rdx
decl %r9d
jmp 0x13fc
incq %rsi
jmp 0x13f3
testq %rax, %rax
je 0x144d
pushq $0xf
popq %rdx
pushq $0x1e
popq %rsi
cmpq $0x19, %rdx
je 0x144d
movl %esi, %ecx
cmpl $-0x2, %ecx
je 0x1448
movl (%rdi,%rdx,4), %r9d
shrl %cl, %r9d
andb $0x3, %r9b
movb %r9b, (%rax)
incq %rax
addl $-0x2, %ecx
jmp 0x142d
incq %rdx
jmp 0x1425
testq %r8, %r8
je 0x147b
pushq $0x19
popq %rax
pushq $0x1f
popq %rcx
cmpq $0x1e, %rax
je 0x147b
movl %ecx, %edx
cmpl $-0x1, %edx
je 0x1476
movl (%rdi,%rax,4), %esi
btl %edx, %esi
setb (%r8)
incq %r8
decl %edx
jmp 0x1460
incq %rax
jmp 0x1458
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xeeee(%rip), %rdi      # 0x10388
callq 0x761d
movq %rax, %r15
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x7745
testb %al, %al
je 0x14e0
movl 0x18(%r14), %esi
movq %r14, %rdi
callq 0x8560
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movl %ebx, 0x8(%rax)
movl 0x4(%rsp), %ecx
movl %ecx, 0xc(%rax)
jmp 0x14ac
movq %r15, %rdi
callq 0x14f6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/richarddurbin[P]hash10x/hash10x.c
// Function: hashIndexFind
static inline U32 hashIndexFind (U64 hash, int isAdd)
{
  U32 index ;
  U64 offset = hash & hashTableMask ;
  U64 diff = ((hash >> hashTableBits) & hashTableMask) | 1 ; /* odd number so coprime to size */
  while ((index = hashIndex[offset]) && (hashValue[index] != hash))
    offset = (offset + diff) & hashTableMask ;
  if (!index && isAdd)
    { index = hashIndex[offset] = hashNumber++ ;
      hashValue[index] = hash ;
      if (hashNumber > (hashTableSize >> 2)-2) die ("hashTableSize is too small") ;
    }
  return index ;
}

// Assembly:
pushq %rbx
movq 0xeda7(%rip), %rdx      # 0x10460
movq %rdx, %rax
andq %rdi, %rax
movb 0xda9b(%rip), %cl       # 0xf160
movq %rdi, %r9
shrq %cl, %r9
andq %rdx, %r9
orq $0x1, %r9
movq 0xeccf(%rip), %rcx      # 0x103a8
movq 0xece0(%rip), %r8       # 0x103c0
movl (%rcx,%rax,4), %ebx
testq %rbx, %rbx
je 0x16f6
cmpq %rdi, (%r8,%rbx,8)
je 0x173c
addq %r9, %rax
andq %rdx, %rax
jmp 0x16e0
testl %esi, %esi
je 0x173a
movl 0xecb8(%rip), %ebx      # 0x103b8
leal 0x1(%rbx), %edx
movl %edx, 0xecaf(%rip)      # 0x103b8
movl %ebx, (%rcx,%rax,4)
movq %rdi, (%r8,%rbx,8)
movl 0xeca2(%rip), %eax      # 0x103b8
movq 0xec93(%rip), %rcx      # 0x103b0
shrq $0x2, %rcx
addq $-0x2, %rcx
cmpq %rax, %rcx
jae 0x173c
leaq 0x8eca(%rip), %rdi      # 0xa5fb
xorl %eax, %eax
callq 0x8a3c
jmp 0x173c
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe3cd(%rip), %edi      # 0x103b8
pushq $0x8
popq %rsi
callq 0x82c8
movq %rax, 0xe3ce(%rip)      # 0x103c8
movl 0xe3b8(%rip), %ecx      # 0x103b8
movl %ecx, 0x18(%rax)
movq 0xe386(%rip), %rax      # 0x10390
movslq 0x14(%rax), %r14
addq 0x8(%rax), %r14
xorl %r12d, %r12d
xorl %ebx, %ebx
leaq 0x1(%r12), %r15
cmpl %ecx, %r15d
jae 0x205f
movl (%r14,%r12,4), %edi
testq %rdi, %rdi
je 0x205a
shlq $0x2, %rdi
callq 0x8afc
movq 0xe38e(%rip), %rcx      # 0x103c8
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 0xe35e(%rip), %ecx      # 0x103b8
movq %r15, %r12
jmp 0x2017
movl %ecx, %edi
pushq $0x4
popq %rsi
callq 0x8b24
movq %rax, %r14
pushq $0x1
popq %rax
movq 0xe322(%rip), %rdx      # 0x10398
movl 0x18(%rdx), %ecx
cmpl %ecx, %eax
jge 0x20cf
movq 0x8(%rdx), %rcx
movslq 0x14(%rdx), %rdi
movslq %eax, %rsi
imulq %rdi, %rsi
movq 0x10(%rcx,%rsi), %rdi
movq 0xe330(%rip), %r8       # 0x103c8
xorl %r9d, %r9d
cmpl 0x4(%rcx,%rsi), %r9d
jae 0x20cb
movq 0x8(%r8), %r10
movl (%rdi,%r9,8), %r11d
movl 0x14(%r8), %r15d
imull %r11d, %r15d
movq (%r10,%r15), %r10
movl (%r14,%r11,4), %r15d
leal 0x1(%r15), %ebp
movl %ebp, (%r14,%r11,4)
movl %eax, (%r10,%r15,4)
incq %r9
jmp 0x209b
incl %eax
jmp 0x2076
movq 0xe2ca(%rip), %rdi      # 0x103a0
movl 0xe2db(%rip), %r8d      # 0x103b8
leaq 0x7344(%rip), %rsi      # 0x9428
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_O2/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:
movq 0xdfaa(%rip), %rax      # 0x10390
cmpl $0x0, 0x18(%rax)
je 0x244a
pushq %rbp
pushq %rbx
pushq %rax
pushq $0x4
popq %rsi
movl $0x400, %edi            # imm = 0x400
callq 0x82c8
movq %rax, %rbx
xorl %ebp, %ebp
movq 0xdf88(%rip), %rax      # 0x10390
cmpl 0x18(%rax), %ebp
jge 0x242d
movq 0x8(%rax), %rcx
movslq 0x14(%rax), %rax
movslq %ebp, %rdx
imulq %rax, %rdx
movl (%rcx,%rdx), %esi
movq %rbx, %rdi
callq 0x8560
incl (%rax)
incl %ebp
jmp 0x2401
leaq 0x70c4(%rip), %rdi      # 0x94f8
movq %rbx, %rsi
callq 0x20fe
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8408
movq 0xcb9f(%rip), %rax      # 0xeff0
movq (%rax), %rcx
leaq 0x707a(%rip), %rdi      # 0x94d5
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
jmp 0x1260
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0xdf23(%rip), %rax      # 0x10398
testq %rax, %rax
je 0x251d
cmpl $0x0, 0x18(%rax)
je 0x251d
pushq $0x4
popq %rbx
movl $0x400, %edi            # imm = 0x400
movl %ebx, %esi
callq 0x82c8
movq %rax, %r14
movl $0x400, %edi            # imm = 0x400
movl %ebx, %esi
callq 0x82c8
movq %rax, %rbx
xorl %ebp, %ebp
movq 0xdee6(%rip), %rax      # 0x10398
cmpl 0x18(%rax), %ebp
jge 0x24e8
movq 0x8(%rax), %r15
movslq 0x14(%rax), %rax
movslq %ebp, %r12
imulq %rax, %r12
movl 0x4(%r15,%r12), %esi
movq %r14, %rdi
callq 0x8560
incl (%rax)
movl 0x8(%r15,%r12), %esi
movq %rbx, %rdi
callq 0x8560
incl (%rax)
incl %ebp
jmp 0x24ab
leaq 0x7036(%rip), %rdi      # 0x9525
movq %r14, %rsi
callq 0x20fe
cmpl $0x2, 0x18(%rbx)
jl 0x2514
leaq 0x702b(%rip), %rdi      # 0x952f
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20fe
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xcacc(%rip), %rax      # 0xeff0
movq (%rax), %rcx
leaq 0x6fd5(%rip), %rdi      # 0x9503
pushq $0x21
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1260
// File: /workspace/github_c_makefile_star2_O2/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
xorl %eax, %eax
testl %r8d, %r8d
movl $0x0, %esi
cmovgl %r8d, %esi
movq 0x8(%rdi), %rdi
xorpd %xmm0, %xmm0
pushq $-0x1
popq %rcx
xorl %edx, %edx
cmpl %eax, %esi
je 0x2588
movl (%rdi,%rax,4), %r9d
testl %r9d, %r9d
je 0x2583
addl %r9d, %edx
imull %eax, %r9d
cvtsi2sd %r9d, %xmm1
addsd %xmm1, %xmm0
cmpl $-0x1, %ecx
cmovel %eax, %ecx
incq %rax
jmp 0x2560
decl %r8d
movq 0xde0e(%rip), %rdi      # 0x103a0
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
leaq 0x6f9b(%rip), %rsi      # 0x953c
movb $0x1, %al
jmp 0x1150
// File: /workspace/github_c_makefile_star2_O2/richarddurbin[P]hash10x/hash10x.c
// Function: cribAddGenome
static void cribAddGenome (FILE *f, CribInfo *crib)
{
  char *seq ;
  int len, chr = 0, pos ;
  int nAbsent = 0, nPresent = 0 ;
  U32 index ;
  dna2indexConv['N'] = dna2indexConv['n'] = 0 ; /* to get 2-bit encoding */
  while (readSequence (f, dna2indexConv, &seq, 0, 0, &len))
    { SeqhashRCiterator *mi = moshRCiterator (hasher, seq, len) ;
      U64 hash ; int pos ;
      ++chr ; if (chr >= cribChrMax) cribChrMax = chr+1 ;
      while (moshRCnext (mi, &hash, &pos, 0))
	if ((index = hashIndexFind (hash, FALSE)))
	  { CribInfo *c = &crib[index] ;
	    if (!c->chr) { c->chr = chr ; c->pos = pos >> 10 ; }
	    else if (c->chr > 0) c->chr = -1 ;
	    else --c->chr ;
	    ++nPresent ;
	  }
	else
	  ++nAbsent ;
      seqhashRCiteratorDestroy (mi) ;
    }
  fclose (f) ;

  fprintf (outFile, "  read %d known and %d unknown hashes from %d sequences in crib genome\n",
	  nPresent, nAbsent, chr) ;
  if (outFile != stdout)
    printf ("  read %d known and %d unknown hashes from %d sequences in crib genome\n",
	    nPresent, nAbsent, chr) ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0xce39(%rip), %rax      # 0xf770
andl $0x0, 0x1b8(%rax)
movq %rsi, 0x20(%rsp)
andl $0x0, 0x138(%rax)
movq %rdi, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
leaq 0x28(%rsp), %r13
leaq 0x10(%rsp), %r14
xorl %ebp, %ebp
xorl %ebx, %ebx
movq 0x18(%rsp), %rdi
leaq 0xcdfe(%rip), %rsi      # 0xf770
leaq 0x30(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
leaq 0x14(%rsp), %r9
callq 0x6278
testl %eax, %eax
je 0x2a34
movq 0xd9f3(%rip), %rdi      # 0x10388
movq 0x30(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0x761d
movq %rax, %r15
leal 0x1(%rbx), %r12d
cmpl 0xda2f(%rip), %r12d     # 0x103e0
jl 0x2a10
addl $0x2, %ebx
movl %ebx, 0xda24(%rip)      # 0x103e0
jmp 0x2a10
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x16b1
testl %eax, %eax
jne 0x29d2
incl %ebp
jmp 0x2a10
movl %eax, %eax
movq 0x20(%rsp), %rdx
movzwl (%rdx,%rax,4), %ecx
testw %cx, %cx
je 0x29eb
jle 0x29fe
orw $-0x1, (%rdx,%rax,4)
jmp 0x2a04
movw %r12w, (%rdx,%rax,4)
movl 0x10(%rsp), %ecx
shrl $0xa, %ecx
movw %cx, 0x2(%rdx,%rax,4)
jmp 0x2a04
decl %ecx
movw %cx, (%rdx,%rax,4)
movq 0x8(%rsp), %rax
incl %eax
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x7745
testb %al, %al
jne 0x29be
movq %r15, %rdi
callq 0x14f6
movl %r12d, %ebx
jmp 0x2966
movq 0x18(%rsp), %rdi
callq 0x10b0
movq 0xd95b(%rip), %rdi      # 0x103a0
leaq 0x7bca(%rip), %rsi      # 0xa616
movq 0x8(%rsp), %r14
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x1150
movq 0xd939(%rip), %rax      # 0x103a0
movq 0xc55a(%rip), %rcx      # 0xefc8
cmpq (%rcx), %rax
je 0x2a88
leaq 0x7b9c(%rip), %rdi      # 0xa616
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd94c(%rip), %r14      # 0x103f0
leaq 0x6a07(%rip), %rsi      # 0x94b2
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1240
movslq %eax, %rbx
addq %r14, %rbx
cmpq $0x0, 0xd90b(%rip)      # 0x103d0
movslq %ebp, %r14
je 0x2b36
movq 0xd907(%rip), %rax      # 0x103d8
movzbl (%rax,%r14), %eax
leaq 0xc2c3(%rip), %rcx      # 0xeda0
movq (%rcx,%rax,8), %rdx
leaq 0x6b0b(%rip), %rsi      # 0x95f3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1240
cltq
addq %rax, %rbx
movq 0xd8d2(%rip), %rax      # 0x103d0
testq %rax, %rax
je 0x2b36
movq 0xd8ce(%rip), %rcx      # 0x103d8
movb (%rcx,%r14), %cl
decb %cl
cmpb $0x2, %cl
ja 0x2b36
movswl (%rax,%r14,4), %edx
movzwl 0x2(%rax,%r14,4), %ecx
leaq 0x6ad0(%rip), %rsi      # 0x95f7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1240
cltq
addq %rax, %rbx
movq 0xd853(%rip), %rax      # 0x10390
movq 0x8(%rax), %rcx
movslq 0x14(%rax), %rax
imulq %r14, %rax
movl (%rcx,%rax), %edx
leaq 0x6aab(%rip), %rsi      # 0x95fe
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1240
leaq 0xd88c(%rip), %rax      # 0x103f0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd899(%rip), %rax      # 0x10410
testq %rax, %rax
je 0x2b90
cmpl %ebp, 0xd896(%rip)      # 0x10418
jne 0x2b90
cmpl %ebx, 0xd892(%rip)      # 0x1041c
jne 0x2b90
xorl %eax, %eax
jmp 0x2c01
testq %rax, %rax
jne 0x2baa
movl 0xd81d(%rip), %edi      # 0x103b8
pushq $0x1
popq %rsi
callq 0x8b24
movq %rax, 0xd866(%rip)      # 0x10410
movl 0xd808(%rip), %edx      # 0x103b8
xorl %ecx, %ecx
movl %edx, %esi
cmpq %rsi, %rcx
jae 0x2bf3
movq 0xd7d0(%rip), %rsi      # 0x10390
movq 0x8(%rsi), %rdi
movslq 0x14(%rsi), %rsi
movslq %ecx, %r8
imulq %rsi, %r8
movl (%rdi,%r8), %esi
cmpl %ebp, %esi
setl %dil
cmpl %ebx, %esi
setge %sil
orb %dil, %sil
jne 0x2bee
movb $0x1, (%rax,%rcx)
movl 0xd7ca(%rip), %edx      # 0x103b8
incq %rcx
jmp 0x2bb2
movl %ebp, 0xd81f(%rip)      # 0x10418
movl %ebx, 0xd81d(%rip)      # 0x1041c
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd5ed(%rip), %rax      # 0x10390
movq 0x8(%rax), %rcx
movslq 0x14(%rax), %rax
movslq %edi, %rdx
movq %rdx, 0x10(%rsp)
imulq %rdx, %rax
movl (%rcx,%rax), %eax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x2ec7
movl %edi, %ebp
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x77e8
movq %rax, 0x8(%rsp)
pushq $0x4
popq %rsi
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x82c8
movq %rax, %r14
xorl %esi, %esi
cmpq 0x18(%rsp), %rsi
je 0x2e7a
movq 0xd59b(%rip), %rax      # 0x10398
movq 0x8(%rax), %r15
movq 0xd5c0(%rip), %rcx      # 0x103c8
movq 0x8(%rcx), %rdx
movslq 0x14(%rcx), %rcx
imulq 0x10(%rsp), %rcx
movq (%rdx,%rcx), %rcx
movl 0x14(%rax), %r12d
movq %rsi, 0x20(%rsp)
imull (%rcx,%rsi,4), %r12d
movq 0x10(%r15,%r12), %r13
xorl %ebx, %ebx
cmpl 0x4(%r15,%r12), %ebx
jae 0x2e6d
movl (%r13,%rbx,8), %esi
cmpl %ebp, %esi
je 0x2e68
movq 0xd5ca(%rip), %rax      # 0x10410
cmpb $0x0, (%rax,%rsi)
je 0x2e68
xorl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq 0x8(%rsp), %rdi
callq 0x798f
movq %r14, %rdi
movl %eax, %esi
callq 0x8560
incl (%rax)
incq %rbx
jmp 0x2e2f
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0x2deb
pushq $0x4
popq %rsi
movl $0x100, %edi            # imm = 0x100
callq 0x82c8
movq %rax, %r15
pushq $0x1
popq %rbx
cmpl 0x18(%r14), %ebx
jge 0x2eb3
movq 0x8(%r14), %rax
movslq 0x14(%r14), %rcx
movslq %ebx, %rdx
imulq %rcx, %rdx
movl (%rax,%rdx), %esi
movq %r15, %rdi
callq 0x8560
incl (%rax)
incl %ebx
jmp 0x2e8d
movq %r14, %rdi
callq 0x8408
movq 0x8(%rsp), %rdi
callq 0x7894
jmp 0x2eca
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_O2/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, 0xd521(%rip)      # 0x10410
je 0x3039
movl %edi, %ebp
callq 0x2c08
testq %rax, %rax
je 0x302a
movq %rax, %rbx
movq 0xd491(%rip), %r15      # 0x103a0
movl 0x18(%rax), %r12d
movl %ebp, %edi
callq 0x2a97
leaq 0x6743(%rip), %rsi      # 0x9664
leaq 0xd4c8(%rip), %r14      # 0x103f0
movq %r15, %rdi
movl %r12d, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1150
movq 0x8(%rbx), %rdi
movslq 0x18(%rbx), %rsi
movslq 0x14(%rbx), %rdx
leaq -0x1baf(%rip), %rcx     # 0x139c
callq 0x1090
movq 0x8(%rbx), %r15
pushq $0x1
popq %rcx
leaq 0x67d4(%rip), %r13      # 0x9732
xorl %r12d, %r12d
xorl %ebp, %ebp
movq %rbx, (%rsp)
cmpl 0x18(%rbx), %r12d
jg 0x3014
je 0x2f83
movzwl 0x4(%r15), %eax
cmpl %eax, %ecx
jne 0x2f83
incl %ebp
jmp 0x3008
movq 0xd416(%rip), %rdi      # 0x103a0
leaq 0x66f6(%rip), %rsi      # 0x9687
movl %ebp, %edx
xorl %eax, %eax
callq 0x1150
cmpl $0x8, %ebp
jl 0x2fb8
movq 0xd3fa(%rip), %rcx      # 0x103a0
leaq 0x66f2(%rip), %rdi      # 0x969f
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
callq 0x1260
cmpl $0x7, %ebp
pushq $0x7
popq %rax
cmovgel %eax, %ebp
movslq %ebp, %rbx
negq %rbx
movq 0xd3d2(%rip), %rbp      # 0x103a0
testq %rbx, %rbx
je 0x2ff1
movl (%r15,%rbx,8), %edi
callq 0x2a97
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1150
incq %rbx
jmp 0x2fc7
pushq $0xa
popq %rdi
movq %rbp, %rsi
callq 0x1100
movzwl 0x4(%r15), %ecx
pushq $0x1
popq %rbp
movq (%rsp), %rbx
incl %r12d
addq $0x8, %r15
jmp 0x2f67
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8408
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xbfb0(%rip), %rax      # 0xeff0
movq (%rax), %rcx
leaq 0x65ef(%rip), %rdi      # 0x9639
pushq $0x2a
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1260
// File: /workspace/github_c_makefile_star2_O2/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, 0xd397(%rip)      # 0x10410
je 0x31ac
movl %esi, %ebp
callq 0x2c08
testq %rax, %rax
je 0x3185
movq %rax, 0x8(%rsp)
movl %ebp, %edi
callq 0x2c08
testq %rax, %rax
je 0x3194
movq 0x8(%rsp), %rdi
movq 0x8(%rdi), %r15
movq 0x8(%rax), %rbx
xorl %esi, %esi
xorl %r14d, %r14d
movl 0x18(%rdi), %edx
cmpl %edx, %esi
jge 0x3178
cmpl 0x18(%rax), %r14d
jge 0x3178
movl (%r15), %ebp
movl (%rbx), %ecx
cmpl %ecx, %ebp
jne 0x30ea
movzwl 0x4(%r15), %r12d
cmpl $0x3, %r12d
jb 0x30ea
movzwl 0x4(%rbx), %r13d
cmpl $0x3, %r13d
jae 0x30f7
cmpl %ecx, %ebp
jb 0x316d
addq $0x8, %rbx
incl %r14d
jmp 0x30b9
movq 0xd2a2(%rip), %rcx      # 0x103a0
movq %rcx, 0x18(%rsp)
movq 0xd2be(%rip), %rdx      # 0x103c8
movq 0x8(%rdx), %rcx
movl 0x14(%rdx), %edx
imull %ebp, %edx
movq (%rcx,%rdx), %rcx
movl (%rcx), %ecx
movl %ecx, 0x10(%rsp)
movl %ebp, %edi
movq %rax, 0x20(%rsp)
movl %esi, 0x14(%rsp)
callq 0x2a97
leaq 0xd2bb(%rip), %rax      # 0x103f0
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
leaq 0x658c(%rip), %rsi      # 0x96d1
movl %ebp, %edx
movl 0x10(%rsp), %ecx
movl %r12d, %r8d
movl %r13d, %r9d
xorl %eax, %eax
callq 0x1150
movl 0x14(%rsp), %esi
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rdi
addq $0x8, %rbx
incl %r14d
addq $0x8, %r15
incl %esi
jmp 0x30b6
movq %rax, %rbx
callq 0x8408
movq %rbx, %rdi
jmp 0x3199
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8408
movq 0xbe3d(%rip), %rax      # 0xeff0
movq (%rax), %rcx
leaq 0x64e8(%rip), %rdi      # 0x96a5
pushq $0x2b
popq %rsi
pushq $0x1
popq %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1260
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0x0, 0xd232(%rip)      # 0x10410
je 0x32ce
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %rbx
movslq %edx, %rax
movq %rax, (%rsp)
movslq %esi, %r15
leaq 0xd1ed(%rip), %rbp      # 0x103f0
cmpq %r15, %rbx
jge 0x32bf
movq 0xd18d(%rip), %r12      # 0x103a0
movl %ebx, %edi
callq 0x2a97
movq %r12, %rdi
leaq 0x6504(%rip), %rsi      # 0x9728
movq %rbp, %rdx
xorl %eax, %eax
callq 0x1150
movq 0xd1db(%rip), %rax      # 0x10410
cmpb $0x0, (%rax,%rbx)
je 0x32a7
movl %ebx, %edi
callq 0x2c08
movq %rax, %r12
movq 0x8(%rax), %rdi
movslq 0x18(%rax), %rsi
movslq 0x14(%rax), %rdx
leaq -0x1ebc(%rip), %rcx     # 0x139c
callq 0x1090
movq 0x8(%r12), %rax
movslq 0x18(%r12), %rcx
decq %rcx
movslq 0x14(%r12), %rdx
imulq %rcx, %rdx
movq 0xd126(%rip), %r13      # 0x103a0
movzwl 0x4(%rax,%rdx), %r14d
movl (%rax,%rdx), %edi
callq 0x2a97
movq %r13, %rdi
leaq 0x64a4(%rip), %rsi      # 0x9736
movl %r14d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1150
movq %r12, %rdi
callq 0x8408
movq 0xd0f2(%rip), %rsi      # 0x103a0
pushq $0xa
popq %rdi
callq 0x1100
addq (%rsp), %rbx
jmp 0x3203
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xbd1b(%rip), %rax      # 0xeff0
movq (%rax), %rcx
leaq 0x6421(%rip), %rdi      # 0x9700
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
jmp 0x1260
// File: /workspace/github_c_makefile_star2_O2/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 0x4cd4
leaq 0x546d(%rip), %rdi      # 0xa134
movl %r15d, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x8a3c
movl %r15d, %edi
movl %r14d, %esi
callq 0x7130
movq %rax, 0xb6a2(%rip)      # 0x10388
movl %ebx, 0xa474(%rip)      # 0xf160
leal -0x1f(%rbx), %eax
movl %ebx, %ecx
cmpl $-0xc, %eax
ja 0x4d0c
leaq 0x546a(%rip), %rdi      # 0xa167
movl %ebx, %esi
xorl %eax, %eax
callq 0x8a3c
movl 0xa454(%rip), %ecx      # 0xf160
pushq $0x1
popq %rdi
shlq %cl, %rdi
movq %rdi, 0xb697(%rip)      # 0x103b0
leaq -0x1(%rdi), %rax
movq %rax, 0xb73c(%rip)      # 0x10460
pushq $0x4
popq %rsi
callq 0x8b24
movq %rax, 0xb675(%rip)      # 0x103a8
movq 0xb676(%rip), %rdi      # 0x103b0
shrq $0x2, %rdi
pushq $0x8
popq %rsi
callq 0x8b24
movq %rax, 0xb673(%rip)      # 0x103c0
movl $0x1, 0xb661(%rip)      # 0x103b8
pushq $0x4
popq %rsi
movl $0x100000, %edi         # imm = 0x100000
callq 0x82c8
movq %rax, 0xb625(%rip)      # 0x10390
movq 0xb62e(%rip), %rdi      # 0x103a0
leaq 0x5412(%rip), %rsi      # 0xa18b
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_O2/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 0x2c08
testq %rax, %rax
je 0x6266
movq %rax, %rbx
movq 0xa19c(%rip), %r14      # 0x103a0
movl 0x18(%rax), %r15d
movl %ebp, %edi
callq 0x2a97
leaq 0x344e(%rip), %rsi      # 0x9664
leaq 0xa1d3(%rip), %rcx      # 0x103f0
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x1150
pushq $0x4
popq %rsi
movl $0x400, %edi            # imm = 0x400
callq 0x82c8
movq %rax, %r14
movl $0x400, %edi            # imm = 0x400
callq 0x77e8
movq %rbx, %rdi
callq 0x8408
movq %r14, %rdi
callq 0x8408
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7894
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r14d
cmpl %ecx, %r14d
jle 0x6545
movq (%r12), %rax
jmp 0x659a
movq %rdx, %r15
testl %r14d, %r14d
js 0x6588
addq %r14, %r14
movq (%r12), %rdi
movq %r14, %rsi
callq 0x11d0
movq %rax, (%r12)
testq %rax, %rax
jne 0x6597
movq 0x8a84(%rip), %rax      # 0xeff0
movq (%rax), %rdi
leaq 0x4398(%rip), %rsi      # 0xa90e
movl %r14d, %edx
xorl %eax, %eax
callq 0x1150
pushq $-0x1
popq %rdi
callq 0x1250
negl %r14d
movl %r14d, %edi
callq 0x70fa
movq %rax, (%r12)
movl %r14d, (%r15)
movslq %ebx, %rcx
movb %bpl, (%rax,%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %r8d, %r8d
xorl %eax, %eax
movsbq (%rdi,%r8), %rcx
movslq %eax, %r9
testq %rcx, %rcx
je 0x6a53
testq %rsi, %rsi
je 0x6a37
movslq (%rsi), %r10
cmpq %r10, %r8
jge 0x6a53
movl (%rdx,%rcx,4), %r10d
cmpl $-0x3, %r10d
jle 0x6a65
testl %r10d, %r10d
js 0x6a4e
leal 0x1(%r9), %eax
movb %r10b, (%rdi,%r9)
incq %r8
jmp 0x6a1d
cmpl %r8d, %eax
jge 0x6a5d
movb $0x0, (%rdi,%r9)
testq %rsi, %rsi
je 0x6a64
movl %eax, (%rsi)
retq
pushq %rax
movq 0x8583(%rip), %rdx      # 0xeff0
movq (%rdx), %rdi
leaq 0x3ce3(%rip), %rsi      # 0xa75a
movl %ecx, %edx
movl %eax, %r8d
xorl %eax, %eax
callq 0x1150
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6b77
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
testq %rcx, %rcx
je 0x6aff
cmpb $0x0, (%rbp)
je 0x6aff
movq %r8, %r14
movl %r9d, %ebx
leaq 0x3cea(%rip), %rsi      # 0xa7af
movq %r15, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x1150
testq %r14, %r14
je 0x6af1
cmpb $0x0, (%r14)
je 0x6af1
leaq 0x2c4e(%rip), %rsi      # 0x9732
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1150
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0x1100
movl %ebx, %r9d
movq %rbp, 0x10(%rsp)
xorl %ebp, %ebp
testl %r9d, %r9d
movl $0x0, %ebx
movl %r9d, 0xc(%rsp)
cmovgl %r9d, %ebx
pushq $0x3c
popq %r14
movl %ebp, %eax
xorl %edx, %edx
divl %r14d
cmpq %rbp, %rbx
je 0x6b59
testq %rbp, %rbp
je 0x6b3e
imull $-0x3c, %eax, %eax
addl %ebp, %eax
jne 0x6b3e
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0x1100
movsbq (%r12,%rbp), %r8
movl (%r13,%r8,4), %edi
testl %edi, %edi
jle 0x6b95
movq %r15, %rsi
callq 0x1100
incq %rbp
jmp 0x6b1b
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0x1100
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8472(%rip), %rax      # 0xeff0
movq (%rax), %rcx
leaq 0x3c01(%rip), %rdi      # 0xa789
pushq $0x25
popq %rsi
pushq $0x1
popq %rdx
callq 0x1260
jmp 0x6bb4
movq 0x8454(%rip), %rax      # 0xeff0
movq (%rax), %rdi
leaq 0x3c0d(%rip), %rsi      # 0xa7b3
movq 0x10(%rsp), %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1150
xorl %eax, %eax
jmp 0x6b68
// File: /workspace/github_c_makefile_star2_O2/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 0x6d22
testq %r8, %r8
je 0x6d0d
cmpb $0x0, (%r8)
je 0x6d0d
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl 0x50(%rsp), %r15d
testq %r9, %r9
movq %r8, 0x8(%rsp)
je 0x6c1e
cmpb $0x0, (%r9)
je 0x6c1e
leaq 0x3c22(%rip), %rsi      # 0xa82e
movq %r14, %rdi
movq %r8, %rdx
movq %r9, %rcx
xorl %eax, %eax
callq 0x1150
jmp 0x6c32
leaq 0x3c11(%rip), %rsi      # 0xa836
movq %r14, %rdi
movq %r8, %rdx
xorl %eax, %eax
callq 0x1150
xorl %ebx, %ebx
testl %r15d, %r15d
movl $0x0, %r12d
cmovgl %r15d, %r12d
pushq $0x3c
popq %r15
movl %ebx, %eax
xorl %edx, %edx
divl %r15d
cmpq %rbx, %r12
je 0x6c88
testq %rbx, %rbx
je 0x6c68
imull $-0x3c, %eax, %eax
addl %ebx, %eax
jne 0x6c68
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x1100
movsbq (%r13,%rbx), %r8
movl (%rbp,%r8,4), %edi
testl %edi, %edi
jle 0x6d42
movq %r14, %rsi
callq 0x1100
incq %rbx
jmp 0x6c45
pushq $0xa
popq %rbx
movl %ebx, %edi
movq %r14, %rsi
callq 0x1100
leaq 0x3b9f(%rip), %rsi      # 0xa83b
xorl %r13d, %r13d
movq %r14, %rdi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x1150
movq 0x10(%rsp), %rbp
movl %r13d, %eax
xorl %edx, %edx
divl %r15d
cmpq %r13, %r12
je 0x6ced
testq %r13, %r13
je 0x6cd7
imull $-0x3c, %eax, %eax
addl %r13d, %eax
jne 0x6cd7
movl %ebx, %edi
movq %r14, %rsi
callq 0x1100
movzbl (%rbp,%r13), %edi
addl $0x21, %edi
movq %r14, %rsi
callq 0x1100
incq %r13
jmp 0x6cb3
pushq $0xa
popq %rdi
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
movq 0x82dc(%rip), %rax      # 0xeff0
movq (%rax), %rcx
leaq 0x3aee(%rip), %rdi      # 0xa80c
pushq $0x21
jmp 0x6d35
movq 0x82c7(%rip), %rax      # 0xeff0
movq (%rax), %rcx
leaq 0x3ab6(%rip), %rdi      # 0xa7e9
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
callq 0x1260
xorl %ebp, %ebp
jmp 0x6cfc
movq 0x82a7(%rip), %rax      # 0xeff0
movq (%rax), %rdi
leaq 0x3a60(%rip), %rsi      # 0xa7b3
xorl %ebp, %ebp
movq 0x8(%rsp), %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1150
jmp 0x6cfc
// File: /workspace/github_c_makefile_star2_O2/richarddurbin[P]hash10x/readseq.c
// Function: messalloc
static char *messalloc (int n)
{
  char *result ;

  if (!(result = (char*) malloc (n)))
    { fprintf (stderr, "MALLOC failure reqesting %d bytes - aborting\n", n) ;
      exit (-1) ;
    }
  return result ;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movslq %edi, %rdi
callq 0x1190
testq %rax, %rax
je 0x710c
popq %rbx
retq
movq 0x7edd(%rip), %rax      # 0xeff0
movq (%rax), %rdi
leaq 0x3820(%rip), %rsi      # 0xa93d
movl %ebx, %edx
xorl %eax, %eax
callq 0x1150
pushq $-0x1
popq %rdi
callq 0x1250
nop
// File: /workspace/github_c_makefile_star2_O2/saulvargas[P]re-C-sys/test_ib.c
// Function: main
int main(int argc, char** argv) {
    FILE* user_data;
    FILE* item_data;
    int N_users;
    int N_items;
    int N_prefs;
    int binary;
    recdata_t* recdata;
    recdata_t* cerdata;
    int uid;
    int i;
    similarity_t* similarity;
    recommender_t* recommender;
    idpairs_t* pairs;

    if (!read_args(argc, argv, &user_data, &item_data, &N_users, &N_items, &N_prefs, &binary)) {
        return EXIT_FAILURE;
    }

    recdata = recdata_simple_create(user_data, item_data, N_users, N_items, N_prefs, binary);
    cerdata = recdata_transposed_create(recdata);
    
    fclose(user_data);
    fclose(item_data);

    if (!binary) {
        similarity = similarity_veccosine_create(cerdata);
    } else {
        similarity = similarity_setcosine_create(cerdata);
    }

    recommender = recommender_ib_create(recdata, similarity, 10, binary);

    for (uid = 0; uid < recdata->N_users; uid++) {
        pairs = recommender_recommend(recommender, uid, 100);

        for (i = 0; i < idpairs_size(pairs); i++) {
            printf("%d\t%d\t%.4f\n", uid, idpairs_keys(pairs)[i], idpairs_values(pairs)[i]);
        }
        
        idpairs_close_deep(pairs);
    }
 
    recommender_close(recommender);
 
    similarity_close(similarity);
    
    recdata_close(recdata);
    recdata_close(cerdata);
    
    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0xc(%rsp), %rax
leaq 0x1c(%rsp), %r10
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x24(%rsp), %r8
leaq 0x20(%rsp), %r9
pushq %rax
pushq %r10
callq 0x24b4
popq %rcx
popq %rdx
testl %eax, %eax
je 0x12a1
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
movl 0x20(%rsp), %ecx
movl 0x1c(%rsp), %r8d
movl 0xc(%rsp), %r9d
callq 0x16b2
movq %rax, 0x10(%rsp)
movq %rax, %rdi
callq 0x1791
movq %rax, %rbx
movq 0x30(%rsp), %rdi
callq 0x1060
movq 0x28(%rsp), %rdi
callq 0x1060
cmpl $0x0, 0xc(%rsp)
movq %rbx, 0x40(%rsp)
movq %rbx, %rdi
je 0x12a9
callq 0x1946
jmp 0x12ae
pushq $0x1
popq %rax
jmp 0x1361
callq 0x1bd9
movl 0xc(%rsp), %ecx
pushq $0xa
popq %rdx
movq 0x10(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq %rax, %rsi
callq 0x236e
movq %rax, %r12
xorl %r13d, %r13d
leaq 0x1d30(%rip), %r14      # 0x3004
movq 0x10(%rsp), %rax
cmpl (%rax), %r13d
jge 0x1339
movq %r12, %rdi
movl %r13d, %esi
pushq $0x64
popq %rdx
callq 0x1f9c
movq %rax, %r15
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x242b
cltq
cmpq %rax, %rbx
jge 0x132c
movq %r15, %rdi
callq 0x242e
movl (%rax,%rbx,4), %ebp
movq %r15, %rdi
callq 0x2433
movsd (%rax,%rbx,8), %xmm0
movq %r14, %rdi
movl %r13d, %esi
movl %ebp, %edx
movb $0x1, %al
callq 0x1080
incq %rbx
jmp 0x12f1
movq %r15, %rdi
callq 0x2407
incl %r13d
jmp 0x12d4
movq %r12, %rdi
callq 0x206d
movq 0x38(%rsp), %rdi
callq 0x17f4
movq 0x10(%rsp), %rdi
callq 0x13a8
movq 0x40(%rsp), %rdi
callq 0x13a8
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/example.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	char *file;

	compile(sparse_initialize(argc, argv, &filelist));
	dbg_dead = 1;
	FOR_EACH_PTR(filelist, file) {
		compile(sparse(file));
	} END_FOR_EACH_PTR(file);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rbx, %rdx
callq 0x16e50
movq %rax, %rdi
callq 0xf4ac
leaq 0x59353(%rip), %rax     # 0x687a8
movl $0x1, (%rax)
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xf4a0
movq %rbx, %r14
xorl %r15d, %r15d
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jge 0xf497
movq 0x18(%r14,%r15,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0xf485
testq %rdi, %rdi
je 0xf492
callq 0x17174
movq %rax, %rdi
callq 0xf4ac
incq %r15
jmp 0xf469
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xf466
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/example.c
// Function: generate_list
static void generate_list(struct basic_block_list *list, unsigned long generation)
{
	struct basic_block *bb;
	FOR_EACH_PTR(list, bb) {
		if (bb->generation == generation)
			continue;
		output_bb(bb, generation);
	} END_FOR_EACH_PTR(bb);
}

// Assembly:
testq %rdi, %rdi
je 0x109c0
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jge 0x109ac
movq 0x18(%r15,%r12,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0x10999
testq %rdi, %rdi
je 0x109a7
cmpq %rbx, 0x8(%rdi)
je 0x109a7
movq %rbx, %rsi
callq 0xf850
incq %r12
jmp 0x1097d
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x1097a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/example.c
// Function: address
static const char *address(struct bb_state *state, struct instruction *memop)
{
	struct operand *op = get_address_operand(state, memop);
	const char *str = show_op(state, op);
	put_operand(state, op);
	return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rsi), %rsi
callq 0x11737
movq %rax, %rbx
cmpl $0x4, (%rax)
jne 0x10cf3
movl 0x38(%r14), %eax
addl %eax, 0x8(%rbx)
jmp 0x10d23
movq %rbx, %rdi
callq 0x11708
movq 0x30(%r14), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x10d3f
movl $0x4, (%rbx)
movq %rax, 0x18(%rbx)
incw 0x10(%rax)
movl 0x38(%r14), %eax
movl %eax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rdi
callq 0x115aa
movq %rax, %r14
movq %rbx, %rdi
callq 0x11708
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/example.c
// Function: getreg
static struct hardreg *getreg(struct bb_state *state, pseudo_t pseudo, pseudo_t target)
{
	struct hardreg *reg;

	reg = find_in_reg(state, pseudo);
	if (reg)
		return reg;
	reg = target_reg(state, pseudo, target);
	return fill_reg(state, reg, pseudo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x10d8b
movq %rax, %r12
testq %rax, %rax
jne 0x10d7c
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x10e53
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x10f0d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/example.c
// Function: find_in_reg
static struct hardreg *find_in_reg(struct bb_state *state, pseudo_t pseudo)
{
	int i;
	struct hardreg *reg;

	for (i = 0; i < REGNO; i++) {
		pseudo_t p;

		reg = hardregs + i;
		FOR_EACH_PTR_TAG(reg->contains, p) {
			if (p == pseudo) {
				last_reg = i;
				output_comment(state, "found pseudo %s in reg %s (busy=%d)", show_pseudo(pseudo), reg->name, reg->busy);
				return reg;
			}
		} END_FOR_EACH_PTR(p);
	}
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x4f412(%rip), %rcx     # 0x601b0
cmpq $0x6, %rax
je 0x10e4e
imulq $0x18, %rax, %r14
movq 0x8(%r14,%rcx), %rdx
testq %rdx, %rdx
je 0x10e11
addq %rcx, %r14
movq %rdx, %rdi
movzwl (%rdi), %r8d
movsbl %r8b, %r9d
testw %r9w, %r9w
movl $0x0, %r10d
cmovgl %r9d, %r10d
movzwl %r10w, %r9d
xorl %r10d, %r10d
cmpq %r10, %r9
je 0x10e08
cmpw $0x100, %r8w            # imm = 0x100
setb %bpl
movq 0x18(%rdi,%r10,8), %r11
andq $-0x4, %r11
setne %r15b
orb %bpl, %r15b
incq %r10
cmpb $0x1, %r15b
jne 0x10dd9
cmpq %rsi, %r11
jne 0x10dd9
jmp 0x10e16
movq 0x10(%rdi), %rdi
cmpq %rdx, %rdi
jne 0x10dbc
incq %rax
jmp 0x10d9e
movl %eax, 0x547a4(%rip)     # 0x655c0
movq %rsi, %rdi
callq 0x1734a
movq (%r14), %rcx
movzwl 0x10(%r14), %r8d
leaq 0x2c44a(%rip), %rsi     # 0x3d27d
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x109c1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x10e40
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/example.c
// Function: target_reg
static struct hardreg *target_reg(struct bb_state *state, pseudo_t pseudo, pseudo_t target)
{
	int i;
	int unable_to_find_reg = 0;
	struct hardreg *reg;

	/* First, see if we have a preferred target register.. */
	reg = preferred_reg(state, target);
	if (reg && !reg->contains)
		goto found;

	reg = empty_reg(state);
	if (reg)
		goto found;

	i = last_reg;
	do {
		i++;
		if (i >= REGNO)
			i = 0;
		reg = hardregs + i;
		if (!reg->busy) {
			flush_reg(state, reg);
			last_reg = i;
			goto found;
		}
	} while (i != last_reg);
	assert(unable_to_find_reg);

found:
	add_pseudo_reg(state, pseudo, reg);
	return reg;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x110c0
testq %rax, %rax
je 0x10e78
movq %rax, %r15
cmpq $0x0, 0x8(%rax)
je 0x10ef0
callq 0x110f6
movq %rax, %r15
testq %rax, %rax
jne 0x10ef0
movl 0x54735(%rip), %eax     # 0x655c0
xorl %ecx, %ecx
leaq 0x4f31c(%rip), %r15     # 0x601b0
movl %eax, %r12d
cmpl $0x5, %r12d
leal 0x1(%r12), %edx
movl %edx, %r12d
cmovgel %ecx, %r12d
movslq %r12d, %rdx
imulq $0x18, %rdx, %rdx
cmpw $0x0, 0x10(%rdx,%r15)
je 0x10edb
cmpl %eax, %r12d
jne 0x10e97
leaq 0x2c3de(%rip), %rdi     # 0x3d2a1
leaq 0x2c3ea(%rip), %rsi     # 0x3d2b4
leaq 0x2c3ed(%rip), %rcx     # 0x3d2be
movl $0x202, %edx            # imm = 0x202
callq 0xf120
addq %rdx, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1111e
movl %r12d, 0x546d0(%rip)    # 0x655c0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x10a7d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq