LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xcb1e(%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 0x3992
movl %edi, %ebp
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x80c8
movq %rax, 0x10(%rsp)
movl $0x7a120, %edi          # imm = 0x7A120
movl $0x4, %esi
callq 0x8c70
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
movq 0xcad2(%rip), %rax      # 0x10388
movq 0x8(%rax), %r15
movq 0xcaf7(%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
cmpl $0x0, 0x4(%r15,%r12)
je 0x3929
movq 0x10(%r15,%r12), %rbx
xorl %r14d, %r14d
movl (%rbx,%r14,8), %esi
cmpl %ebp, %esi
je 0x391f
movq 0xcb05(%rip), %rax      # 0x10400
cmpb $0x0, (%rax,%rsi)
je 0x391f
xorl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq 0x10(%rsp), %rdi
callq 0x828c
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x8f2b
incl (%rax)
incq %r14
cmpl 0x4(%r15,%r12), %r14d
jb 0x38ec
incq %r13
cmpq 0x18(%rsp), %r13
jne 0x38af
movl $0x100, %edi            # imm = 0x100
movl $0x4, %esi
callq 0x8c70
movq %rax, %r15
movq 0x8(%rsp), %r14
cmpl $0x2, 0x18(%r14)
jl 0x397e
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 0x8f2b
incl (%rax)
incl %ebx
cmpl 0x18(%r14), %ebx
jl 0x395a
movq %r14, %rdi
callq 0x8dc9
movq 0x10(%rsp), %rdi
callq 0x8184
jmp 0x3995
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_O1/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, 0xca46(%rip)      # 0x10400
je 0x3b1e
movl %edi, %ebp
callq 0x36b3
testq %rax, %rax
je 0x3b23
movq %rax, %rbx
movq 0xc9b6(%rip), %r14      # 0x10390
movl 0x18(%rax), %r15d
movl %ebp, %edi
callq 0x353c
leaq 0x6c78(%rip), %rsi      # 0xa664
leaq 0xc9ed(%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 -0x1d85(%rip), %rcx     # 0x1c8e
callq 0x1090
movl 0x18(%rbx), %eax
testl %eax, %eax
js 0x3b08
movq 0x8(%rbx), %r15
movl $0x1, %ecx
leaq 0x6cff(%rip), %r12      # 0xa732
leaq 0xc9a6(%rip), %r13      # 0x103e0
xorl %ebp, %ebp
xorl %r14d, %r14d
movq %rbx, (%rsp)
cmpl %eax, %r14d
je 0x3a58
movzwl 0x4(%r15), %eax
cmpl %eax, %ecx
jne 0x3a58
incl %ebp
jmp 0x3af1
movq 0xc931(%rip), %rdi      # 0x10390
leaq 0x6c21(%rip), %rsi      # 0xa687
movl %ebp, %edx
xorl %eax, %eax
callq 0x1150
movl %ebp, %eax
cmpl $0x8, %ebp
jl 0x3a98
movq 0xc913(%rip), %rcx      # 0x10390
movl $0x5, %esi
movl $0x1, %edx
leaq 0x6c11(%rip), %rdi      # 0xa69f
callq 0x1250
movl $0x7, %eax
testl %eax, %eax
je 0x3ad2
cmpl $0x7, %ebp
movl $0x7, %eax
cmovgel %eax, %ebp
movslq %ebp, %rbx
negq %rbx
movq 0xc8dc(%rip), %rbp      # 0x10390
movl (%r15,%rbx,8), %edi
callq 0x353c
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x1150
incq %rbx
jne 0x3aad
movq 0xc8b7(%rip), %rsi      # 0x10390
movl $0xa, %edi
callq 0x1100
movzwl 0x4(%r15), %ecx
movl $0x1, %ebp
movq (%rsp), %rbx
leal 0x1(%r14), %edx
addq $0x8, %r15
movl 0x18(%rbx), %eax
cmpl %eax, %r14d
movl %edx, %r14d
jl 0x3a43
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8dc9
callq 0x15af
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xc8b8(%rip)      # 0x10400
je 0x3c73
movl %esi, %ebp
callq 0x36b3
testq %rax, %rax
je 0x3c78
movq %rax, 0x8(%rsp)
movl %ebp, %edi
callq 0x36b3
testq %rax, %rax
je 0x3c5b
movq 0x8(%rsp), %rdi
cmpl $0x0, 0x18(%rdi)
jle 0x3c4e
movq 0x8(%rax), %r15
movq 0x8(%rdi), %r14
xorl %ebx, %ebx
xorl %r13d, %r13d
movq %rax, 0x18(%rsp)
cmpl 0x18(%rax), %ebx
jge 0x3c4e
movl (%r14), %ebp
movl (%r15), %ecx
cmpl %ecx, %ebp
jne 0x3c31
movzwl 0x4(%r14), %r12d
cmpl $0x3, %r12d
jb 0x3c31
movzwl 0x4(%r15), %esi
cmpl $0x3, %esi
jb 0x3c31
movq 0xc7c9(%rip), %rcx      # 0x10390
movq %rcx, 0x20(%rsp)
movq 0xc7e5(%rip), %rdx      # 0x103b8
movq 0x8(%rdx), %rcx
movl 0x14(%rdx), %eax
imull %ebp, %eax
movq (%rcx,%rax), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movl %ebp, %edi
movl %esi, 0x10(%rsp)
callq 0x353c
leaq 0xc7e7(%rip), %rax      # 0x103e0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
leaq 0x6ac8(%rip), %rsi      # 0xa6d1
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, %r14
incl %r13d
jmp 0x3c3e
cmpl %ecx, %ebp
jae 0x3c3e
addq $0x8, %r14
incl %r13d
jmp 0x3c44
addq $0x8, %r15
incl %ebx
cmpl 0x18(%rdi), %r13d
jl 0x3b94
movq %rax, %rbx
callq 0x8dc9
movq %rbx, %rdi
jmp 0x3c60
movq 0x8(%rsp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8dc9
callq 0x15cb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xc766(%rip)      # 0x10400
je 0x3d81
cmpl %esi, %edi
jge 0x3d72
movslq %edi, %rbx
movslq %edx, %rax
movq %rax, (%rsp)
movslq %esi, %r15
leaq 0xc724(%rip), %r14      # 0x103e0
movq 0xc6cd(%rip), %rbp      # 0x10390
movl %ebx, %edi
callq 0x353c
movq %rbp, %rdi
leaq 0x6a54(%rip), %rsi      # 0xa728
movq %r14, %rdx
xorl %eax, %eax
callq 0x1150
movq 0xc71b(%rip), %rax      # 0x10400
cmpb $0x0, (%rax,%rbx)
je 0x3d54
movl %ebx, %edi
callq 0x36b3
movq %rax, %rbp
movq 0x8(%rax), %rdi
movslq 0x18(%rax), %rsi
movslq 0x14(%rax), %rdx
leaq -0x207a(%rip), %rcx     # 0x1c8e
callq 0x1090
movq 0x8(%rbp), %rax
movslq 0x18(%rbp), %rcx
decq %rcx
movslq 0x14(%rbp), %rdx
imulq %rcx, %rdx
movq 0xc669(%rip), %r12      # 0x10390
movzwl 0x4(%rax,%rdx), %r13d
movl (%rax,%rdx), %edi
callq 0x353c
movq %r12, %rdi
leaq 0x69f7(%rip), %rsi      # 0xa736
movl %r13d, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1150
movq %rbp, %rdi
callq 0x8dc9
movq 0xc635(%rip), %rsi      # 0x10390
movl $0xa, %edi
callq 0x1100
addq (%rsp), %rbx
cmpq %r15, %rbx
jl 0x3cbc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x15e7
jmp 0x3d72
// File: /workspace/github_c_makefile_star2_O1/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 0x52a2
leaq 0x5e9f(%rip), %rdi      # 0xb134
movl %r15d, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x9408
movl %r15d, %edi
movl %r14d, %esi
callq 0x77cc
movq %rax, 0xb0c4(%rip)      # 0x10378
movl %ebx, 0x9e96(%rip)      # 0xf150
leal -0x1f(%rbx), %eax
cmpl $-0xc, %eax
ja 0x52d2
leaq 0x5e9e(%rip), %rdi      # 0xb167
movl %ebx, %esi
xorl %eax, %eax
callq 0x9408
movb 0x9e78(%rip), %cl       # 0xf150
movl $0x1, %edi
shlq %cl, %rdi
movq %rdi, 0xb0b9(%rip)      # 0x103a0
leaq -0x1(%rdi), %rax
movq %rax, 0xb156(%rip)      # 0x10448
movl $0x4, %esi
callq 0x94f8
movq %rax, 0xb095(%rip)      # 0x10398
movq 0xb096(%rip), %rdi      # 0x103a0
shrq $0x2, %rdi
movl $0x8, %esi
callq 0x94f8
movq %rax, 0xb091(%rip)      # 0x103b0
movl $0x1, 0xb07f(%rip)      # 0x103a8
movl $0x100000, %edi         # imm = 0x100000
movl $0x4, %esi
callq 0x8c70
movq %rax, 0xb041(%rip)      # 0x10380
movq 0xb04a(%rip), %rdi      # 0x10390
leaq 0x5e3e(%rip), %rsi      # 0xb18b
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_O1/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 0x36b3
testq %rax, %rax
je 0x6884
movq %rax, %rbx
movq 0x9b70(%rip), %r14      # 0x10390
movl 0x18(%rax), %r15d
movl %ebp, %edi
callq 0x353c
leaq 0x3e32(%rip), %rsi      # 0xa664
leaq 0x9ba7(%rip), %rcx      # 0x103e0
movq %r14, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x1150
movl $0x400, %edi            # imm = 0x400
movl $0x4, %esi
callq 0x8c70
movq %rax, %r14
movl $0x400, %edi            # imm = 0x400
callq 0x80c8
movq %rbx, %rdi
callq 0x8dc9
movq %r14, %rdi
callq 0x8dc9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8184
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movl %edi, %ebp
movl (%rdx), %r12d
cmpl %ecx, %r12d
jg 0x6bfc
movq %rdx, %r15
testl %r12d, %r12d
js 0x6beb
addq %r12, %r12
movq (%r14), %rdi
movq %r12, %rsi
callq 0x11c0
movq %rax, (%r14)
testq %rax, %rax
jne 0x6bf9
movl %r12d, %edi
callq 0x19e1
negl %r12d
movl %r12d, %edi
callq 0x77b1
movq %rax, (%r14)
movl %r12d, (%r15)
movq (%r14), %rax
movslq %ebx, %rcx
movb %bpl, (%rax,%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorl %ecx, %ecx
xorl %eax, %eax
testb %r8b, %r8b
je 0x711b
testq %rsi, %rsi
je 0x70f5
movslq (%rsi), %r9
cmpq %r9, %rcx
jge 0x711b
movsbq %r8b, %r9
movl (%rdx,%r9,4), %r9d
cmpl $-0x3, %r9d
jle 0x712e
testl %r9d, %r9d
js 0x7111
movslq %eax, %r8
incl %eax
movb %r9b, (%rdi,%r8)
movb 0x1(%rdi,%rcx), %r8b
incq %rcx
jmp 0x70e3
cmpl %ecx, %eax
jge 0x7126
movslq %eax, %rcx
movb $0x0, (%rdi,%rcx)
testq %rsi, %rsi
je 0x712d
movl %eax, (%rsi)
retq
pushq %rax
movsbl %r8b, %ecx
movq 0x7eb6(%rip), %rdx      # 0xeff0
movq (%rdx), %rdi
leaq 0x4630(%rip), %rsi      # 0xb774
movl %ecx, %edx
movl %eax, %r8d
xorl %eax, %eax
callq 0x1150
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7247
movl %r9d, %ebx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
testq %rcx, %rcx
je 0x71cb
cmpb $0x0, (%r14)
je 0x71cb
movq %r8, %rbp
leaq 0x4637(%rip), %rsi      # 0xb7c9
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1150
testq %rbp, %rbp
je 0x71be
cmpb $0x0, (%rbp)
je 0x71be
leaq 0x3581(%rip), %rsi      # 0xa732
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 0x7225
movl 0xc(%rsp), %r14d
xorl %ebp, %ebp
movl $0x88888889, %ebx       # imm = 0x88888889
testq %rbp, %rbp
je 0x7207
movl %ebp, %eax
imulq %rbx, %rax
shrq $0x25, %rax
imull $-0x3c, %eax, %eax
addl %ebp, %eax
jne 0x7207
movl $0xa, %edi
movq %r15, %rsi
callq 0x1100
movsbq (%r12,%rbp), %r8
movl (%r13,%r8,4), %edi
testl %edi, %edi
jle 0x7250
movq %r15, %rsi
callq 0x1100
incq %rbp
cmpq %rbp, %r14
jne 0x71e4
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 0x1a9a
xorl %ebx, %ebx
jmp 0x7236
movq 0x7d99(%rip), %rax      # 0xeff0
movq (%rax), %rdi
leaq 0x456c(%rip), %rsi      # 0xb7cd
xorl %ebx, %ebx
movq 0x10(%rsp), %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1150
jmp 0x7236
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
testq %rdi, %rdi
je 0x73cf
testq %r8, %r8
je 0x73c8
cmpb $0x0, (%r8)
je 0x73c8
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl 0x40(%rsp), %ebx
testq %r9, %r9
movq %r8, (%rsp)
je 0x72d2
cmpb $0x0, (%r9)
je 0x72d2
leaq 0x4588(%rip), %rsi      # 0xb848
movq %r14, %rdi
movq %r8, %rdx
movq %r9, %rcx
xorl %eax, %eax
callq 0x1150
jmp 0x72e6
leaq 0x4577(%rip), %rsi      # 0xb850
movq %r14, %rdi
movq %r8, %rdx
xorl %eax, %eax
callq 0x1150
movl %ebx, %r12d
testl %ebx, %ebx
jle 0x733a
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x7317
movl %ebx, %eax
movl $0x88888889, %ecx       # imm = 0x88888889
imulq %rcx, %rax
shrq $0x25, %rax
imull $-0x3c, %eax, %eax
addl %ebx, %eax
jne 0x7317
movl $0xa, %edi
movq %r14, %rsi
callq 0x1100
movsbq (%r13,%rbx), %r8
movl (%rbp,%r8,4), %edi
testl %edi, %edi
jle 0x73d8
movq %r14, %rsi
callq 0x1100
incq %rbx
cmpq %rbx, %r12
jne 0x72ef
movl $0xa, %edi
movq %r14, %rsi
callq 0x1100
leaq 0x4507(%rip), %rsi      # 0xb855
movq %r14, %rdi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1150
cmpl $0x0, 0x40(%rsp)
jle 0x73a6
xorl %ebx, %ebx
movl $0x88888889, %r13d      # imm = 0x88888889
testq %rbx, %rbx
je 0x738e
movl %ebx, %eax
imulq %r13, %rax
shrq $0x25, %rax
imull $-0x3c, %eax, %eax
addl %ebx, %eax
jne 0x738e
movl $0xa, %edi
movq %r14, %rsi
callq 0x1100
movzbl (%r15,%rbx), %edi
addl $0x21, %edi
movq %r14, %rsi
callq 0x1100
incq %rbx
cmpq %rbx, %r12
jne 0x736b
movl $0xa, %edi
movq %r14, %rsi
callq 0x1100
movl 0x40(%rsp), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1ab6
jmp 0x73d4
callq 0x1ad2
xorl %ebx, %ebx
jmp 0x73b7
movq 0x7c11(%rip), %rax      # 0xeff0
movq (%rax), %rdi
leaq 0x43e4(%rip), %rsi      # 0xb7cd
movq (%rsp), %rdx
movl %ebx, %ecx
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1150
jmp 0x73b7
// File: /workspace/github_c_makefile_star2_O1/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 0x2658
addq $0x10, %rsp
testl %eax, %eax
je 0x12a3
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 0x16be
movq %rax, 0x10(%rsp)
movq %rax, %rdi
callq 0x17a1
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 0x12ad
callq 0x1978
jmp 0x12b2
movl $0x1, %eax
jmp 0x137b
callq 0x1c31
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, 0x38(%rsp)
movq %rax, %rsi
movl $0xa, %edx
callq 0x24b2
movq %rax, %r12
cmpl $0x0, (%rbx)
jle 0x1353
xorl %r13d, %r13d
leaq 0x1d22(%rip), %rbp      # 0x3004
movq %r12, %rdi
movl %r13d, %esi
movl $0x64, %edx
callq 0x209c
movq %rax, %r14
movq %rax, %rdi
callq 0x2575
testl %eax, %eax
jle 0x133e
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x2578
movl (%rax,%rbx,4), %r15d
movq %r14, %rdi
callq 0x257d
movsd (%rax,%rbx,8), %xmm0
movq %rbp, %rdi
movl %r13d, %esi
movl %r15d, %edx
movb $0x1, %al
callq 0x1080
incq %rbx
movq %r14, %rdi
callq 0x2575
cltq
cmpq %rax, %rbx
jl 0x1303
movq %r14, %rdi
callq 0x2551
incl %r13d
movq 0x10(%rsp), %rax
cmpl (%rax), %r13d
jl 0x12e2
movq %r12, %rdi
callq 0x217e
movq 0x38(%rsp), %rdi
callq 0x1804
movq 0x10(%rsp), %rdi
callq 0x13c4
movq 0x40(%rsp), %rdi
callq 0x13c4
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movq $0x0, (%rbx)
movq %rbx, %rdx
callq 0x17c46
movq %rax, %rdi
callq 0xfa49
leaq 0x60dc0(%rip), %rax     # 0x707a8
movl $0x1, (%rax)
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xfa3d
movq %rbx, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0xfa34
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xfa18
testq %rdi, %rdi
je 0xfa25
callq 0x17f86
movq %rax, %rdi
callq 0xfa49
incq %r15
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jl 0xfa04
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xf9f9
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x110fd
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0x110e9
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x110cc
testq %rdi, %rdi
je 0x110da
cmpq %rbx, 0x8(%rdi)
je 0x110da
movq %rbx, %rsi
callq 0xfe24
incq %r12
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jl 0x110b8
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x110ad
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11ea9
movq %rax, %rbx
cmpl $0x4, (%rax)
jne 0x11405
movl 0x38(%r14), %eax
addl %eax, 0x8(%rbx)
jmp 0x11438
movq %rbx, %rdi
callq 0x11e7a
movq 0x30(%r14), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x11454
movl $0x4, (%rbx)
movq %rax, 0x18(%rbx)
incw 0x10(%rax)
movl 0x38(%r14), %eax
movl %eax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rdi
callq 0x11cfb
movq %rax, %r14
movq %rbx, %rdi
callq 0x11e7a
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x114a0
movq %rax, %r12
testq %rax, %rax
jne 0x11491
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x11595
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1166c
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x56cf8(%rip), %r12     # 0x681b0
leaq 0x34dbe(%rip), %r15     # 0x4627d
xorl %r13d, %r13d
leaq (,%r13,2), %rdx
addq %r13, %rdx
movq 0x8(%r12,%rdx,8), %rcx
testq %rcx, %rcx
je 0x11563
leaq (%r12,%rdx,8), %rbp
movq %rcx, %rdx
movzwl (%rdx), %edi
movsbl %dil, %esi
testw %si, %si
jle 0x11524
movzwl %si, %esi
movzwl %di, %edi
xorl %r8d, %r8d
cmpl $0x100, %edi            # imm = 0x100
setb %r10b
movq 0x18(%rdx,%r8,8), %r9
andq $-0x4, %r9
setne %r11b
orb %r10b, %r11b
cmpb $0x1, %r11b
jne 0x1151c
cmpq %rbx, %r9
je 0x11531
incq %r8
cmpq %r8, %rsi
jne 0x114f7
movq 0x10(%rdx), %rdx
cmpq %rcx, %rdx
jne 0x114e2
xorl %ecx, %ecx
jmp 0x11568
movl %r13d, 0x5c088(%rip)    # 0x6d5c0
movq %rbx, %rdi
callq 0x18180
movq (%rbp), %rcx
movzwl 0x10(%rbp), %r8d
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x110fe
movl $0x1, %ecx
movq %rbp, %rax
jmp 0x11568
movl $0x5, %ecx
cmpl $0x5, %ecx
je 0x11571
testl %ecx, %ecx
jne 0x11573
xorl %ecx, %ecx
testl %ecx, %ecx
jne 0x11586
incq %r13
cmpq $0x6, %r13
jne 0x114c2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11847
testq %rax, %rax
je 0x115be
movq %rax, %r15
cmpq $0x0, 0x8(%rax)
je 0x1164f
xorl %r15d, %r15d
leaq 0x56be8(%rip), %rax     # 0x681b0
xorl %ecx, %ecx
cmpq $0x0, 0x8(%rcx,%rax)
je 0x115e0
addq $0x18, %rcx
cmpl $0x90, %ecx
jne 0x115ca
jmp 0x115e6
addq %rax, %rcx
movq %rcx, %r15
testq %r15, %r15
jne 0x1164f
movl 0x5bfcf(%rip), %ecx     # 0x6d5c0
xorl %edx, %edx
movl %ecx, %r12d
cmpl $0x5, %r12d
leal 0x1(%r12), %esi
movl %esi, %r12d
cmovgel %edx, %r12d
movslq %r12d, %rsi
leaq (%rsi,%rsi,2), %rsi
cmpw $0x0, 0x10(%rax,%rsi,8)
je 0x11639
cmpl %ecx, %r12d
jne 0x115f6
leaq 0x34c80(%rip), %rdi     # 0x462a1
leaq 0x34c8c(%rip), %rsi     # 0x462b4
leaq 0x34c8f(%rip), %rcx     # 0x462be
movl $0x202, %edx            # imm = 0x202
callq 0xf120
leaq (%rax,%rsi,8), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x11883
movl %r12d, 0x5bf71(%rip)    # 0x6d5c0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x111ba
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/example.c
// Function: preferred_reg
static struct hardreg *preferred_reg(struct bb_state *state, pseudo_t target)
{
	struct storage_hash *dst;

	dst = find_storage_hash(target, state->outputs);
	if (dst) {
		struct storage *storage = dst->storage;
		if (storage->type == REG_REG)
			return hardregs + storage->regno;
	}
	return NULL;
}

// Assembly:
pushq %rax
movq %rsi, %rax
movq 0x10(%rdi), %rsi
movq %rax, %rdi
callq 0x11a56
testq %rax, %rax
je 0x1187f
movq 0x18(%rax), %rdx
movl (%rdx), %ecx
cmpl $0x1, %ecx
jne 0x1187a
movslq 0x10(%rdx), %rax
leaq (%rax,%rax,2), %rax
leaq 0x5693a(%rip), %rdx     # 0x681b0
leaq (%rdx,%rax,8), %rax
cmpl $0x1, %ecx
je 0x11881
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/example.c
// Function: find_storage_hash
static struct storage_hash *find_storage_hash(pseudo_t pseudo, struct storage_hash_list *list)
{
	struct storage_hash *entry;
	FOR_EACH_PTR(list, entry) {
		if (entry->pseudo == pseudo)
			return entry;
	} END_FOR_EACH_PTR(entry);
	return NULL;
}

// Assembly:
testq %rsi, %rsi
je 0x11aa8
movq %rsi, %rcx
movzwl (%rcx), %eax
movsbl %al, %edx
testw %dx, %dx
jle 0x11a94
movzwl %dx, %edx
movzwl %ax, %r8d
xorl %r9d, %r9d
movq 0x18(%rcx,%r9,8), %rax
cmpl $0x100, %r8d            # imm = 0x100
jb 0x11a86
testq %rax, %rax
je 0x11a8c
cmpq %rdi, 0x8(%rax)
je 0x11aa1
incq %r9
cmpq %r9, %rdx
jne 0x11a73
movq 0x10(%rcx), %rcx
cmpq %rsi, %rcx
jne 0x11a5e
xorl %ecx, %ecx
jmp 0x11aad
movl $0x1, %ecx
jmp 0x11aad
movl $0x2, %ecx
testb $0x1, %cl
jne 0x11ab4
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/example.c
// Function: find_or_create_hash
static struct storage_hash *find_or_create_hash(pseudo_t pseudo, struct storage_hash_list **listp)
{
	struct storage_hash *entry;

	entry = find_storage_hash(pseudo, *listp);
	if (!entry) {
		entry = alloc_storage_hash(alloc_storage());
		entry->pseudo = pseudo;
		add_ptr_list(listp, entry);
	}
	return entry;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
callq 0x11a56
movq %rax, %r15
testq %rax, %rax
jne 0x11b0a
xorl %edi, %edi
callq 0x313b0
movq %rax, %r12
xorl %edi, %edi
callq 0x31401
movq %rax, %r15
leaq 0x18(%rax), %rsi
movq %r12, 0x18(%rax)
addq $0x8, %r12
movq %r12, %rdi
callq 0x2871f
movq %r14, 0x8(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2871f
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/example.c
// Function: find_pseudo_storage
static struct storage_hash *find_pseudo_storage(struct bb_state *state, pseudo_t pseudo, struct hardreg *reg)
{
	struct storage_hash *src;

	src = find_storage_hash(pseudo, state->internal);
	if (!src) {
		src = find_storage_hash(pseudo, state->inputs);
		if (!src) {
			src = find_storage_hash(pseudo, state->outputs);
			/* Undefined? Screw it! */
			if (!src)
				return NULL;

			/*
			 * If we found output storage, it had better be local stack
			 * that we flushed to earlier..
			 */
			if (src->storage->type != REG_STACK)
				return NULL;
		}
	}

	/*
	 * Incoming pseudo with out any pre-set storage allocation?
	 * We can make up our own, and obviously prefer to get it
	 * in the register we already selected (if it hasn't been
	 * used yet).
	 */
	if (src->storage->type == REG_UDEF) {
		if (reg && !reg->used) {
			src->storage->type = REG_REG;
			src->storage->regno = reg - hardregs;
			return NULL;
		}
		alloc_stack(state, src->storage);
	}
	return src;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdi), %rsi
movq %r14, %rdi
callq 0x11a56
testq %rax, %rax
jne 0x11bb7
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x11a56
testq %rax, %rax
je 0x11c07
movq 0x18(%rax), %rcx
cmpl $0x0, (%rcx)
jne 0x11c23
testq %rbx, %rbx
je 0x11bed
testb $0x1, 0x13(%rbx)
jne 0x11bed
movl $0x1, (%rcx)
leaq 0x565d8(%rip), %rcx     # 0x681b0
subq %rcx, %rbx
shrq $0x3, %rbx
imull $0xaaaaaaab, %ebx, %edx # imm = 0xAAAAAAAB
movq 0x18(%rax), %rcx
xorl %eax, %eax
jmp 0x11c02
movl $0x2, (%rcx)
movl 0x5b9cb(%rip), %edx     # 0x6d5c4
leal 0x4(%rdx), %esi
movl %esi, 0x5b9c2(%rip)     # 0x6d5c4
movl %edx, 0x10(%rcx)
jmp 0x11c23
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x11a56
testq %rax, %rax
je 0x11c21
movq 0x18(%rax), %rcx
cmpl $0x2, (%rcx)
je 0x11bb7
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/example.c
// Function: mark_reg_dead
static void mark_reg_dead(struct bb_state *state, pseudo_t pseudo, struct hardreg *reg)
{
	pseudo_t p;

	FOR_EACH_PTR_TAG(reg->contains, p) {
		if (p != pseudo)
			continue;
		if (CURRENT_TAG(p) & TAG_DEAD)
			continue;
		output_comment(state, "marking pseudo %s in reg %s dead", show_pseudo(pseudo), reg->name);
		TAG_CURRENT(p, TAG_DEAD);
		reg->dead++;
	} END_FOR_EACH_PTR(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdx), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x11cec
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x3485e(%rip), %r12     # 0x464b3
movq (%rsp), %r13
movzwl (%r13), %eax
testb %al, %al
jle 0x11cde
xorl %ebp, %ebp
movq 0x18(%r13,%rbp,8), %rcx
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
setb %dl
movq %rcx, %rax
andq $-0x4, %rax
setne %sil
orb %dl, %sil
cmpb $0x1, %sil
jne 0x11cce
cmpq %r14, %rax
jne 0x11cce
andl $0x1, %ecx
jne 0x11cce
movq %r14, %rdi
callq 0x18180
movq (%rbx), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x110fe
movq 0x18(%r13,%rbp,8), %rax
andq $-0x4, %rax
incq %rax
movq %rax, 0x18(%r13,%rbp,8)
movl 0x10(%rbx), %eax
movl $0x10000, %ecx          # imm = 0x10000
addl %ecx, %eax
shrl $0x10, %eax
movb %al, 0x12(%rbx)
incq %rbp
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbp
jl 0x11c64
movq 0x10(%r13), %r13
cmpq (%rsp), %r13
jne 0x11c59
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/example.c
// Function: show_op
static const char *show_op(struct bb_state *state, struct operand *op)
{
	static char buf[256][4];
	static int bufnr;
	char *p, *ret;
	int nr;

	nr = (bufnr + 1) & 3;
	bufnr = nr;
	ret = p = buf[nr];

	switch (op->type) {
	case OP_UNDEF:
		return "undef";
	case OP_REG:
		return op->reg->name;
	case OP_VAL:
		sprintf(p, "$%lld", op->value);
		break;
	case OP_MEM:
	case OP_ADDR:
		if (op->offset)
			p += sprintf(p, "%d", op->offset);
		if (op->sym)
			p += sprintf(p, "%s%s",
				op->offset ? "+" : "",
				show_ident(op->sym->ident));
		if (op->base || op->index) {
			p += sprintf(p, "(%s%s%s",
				op->base ? op->base->name : "",
				(op->base && op->index) ? "," : "",
				op->index ? op->index->name : "");
			if (op->scale > 1)
				p += sprintf(p, ",%d", op->scale);
			*p++ = ')';
			*p = '\0';
		}
		break;
	}
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x5c4b7(%rip), %eax     # 0x6e1c0
incl %eax
andl $0x3, %eax
movl %eax, 0x5c4ac(%rip)     # 0x6e1c0
leaq 0x5c0a5(%rip), %rcx     # 0x6ddc0
leaq (%rcx,%rax,4), %rbx
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x11e6b
movq %rdi, %r14
leaq 0x3442f(%rip), %rcx     # 0x46164
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%r14), %edx
movq %rbx, %r15
testl %edx, %edx
je 0x11d60
leaq 0x34893(%rip), %rsi     # 0x465e3
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf2e0
movslq %eax, %r15
addq %rbx, %r15
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x11da5
cmpl $0x0, 0x8(%r14)
leaq 0x355d4(%rip), %rcx     # 0x47349
leaq 0x36d22(%rip), %r12     # 0x48a9e
cmoveq %rcx, %r12
movq 0x18(%rax), %rdi
callq 0x34c49
leaq 0x38118(%rip), %rsi     # 0x49ea8
movq %r15, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xf2e0
cltq
addq %rax, %r15
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x11e4f
movq (%rax), %rdx
leaq 0x3558d(%rip), %r8      # 0x47349
movq %r8, %rcx
testq %rax, %rax
je 0x11ddb
cmpq $0x0, 0x20(%r14)
leaq 0x35579(%rip), %rax     # 0x47349
leaq 0x3470b(%rip), %rcx     # 0x464e2
cmoveq %rax, %rcx
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x11de7
movq (%rax), %r8
leaq 0x346ec(%rip), %rsi     # 0x464da
movq %r15, %rdi
xorl %eax, %eax
callq 0xf2e0
movslq %eax, %r12
addq %r15, %r12
movl 0xc(%r14), %edx
cmpl $0x2, %edx
jb 0x11e1d
leaq 0x346d6(%rip), %rsi     # 0x464e4
movq %r12, %rdi
xorl %eax, %eax
callq 0xf2e0
cltq
addq %rax, %r12
movw $0x29, (%r12)
jmp 0x11e6b
movq 0x8(%r14), %rdx
leaq 0x346a3(%rip), %rsi     # 0x464d4
movq %rbx, %rdi
xorl %eax, %eax
callq 0xf2e0
jmp 0x11e6b
leaq 0x3aa7f(%rip), %rbx     # 0x4c8c3
jmp 0x11e6b
movq 0x8(%r14), %rax
movq (%rax), %rbx
jmp 0x11e6b
cmpq $0x0, 0x20(%r14)
je 0x11e6b
testq %rax, %rax
jne 0x11db2
leaq 0x354e3(%rip), %rdx     # 0x47349
jmp 0x11db5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/example.c
// Function: put_operand
static void put_operand(struct bb_state *state, struct operand *op)
{
	switch (op->type) {
	case OP_REG:
		op->reg->busy--;
		break;
	case OP_ADDR:
	case OP_MEM:
		if (op->base)
			op->base->busy--;
		if (op->index)
			op->index->busy--;
		break;
	default:
		break;
	}
}

// Assembly:
movl (%rdi), %eax
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0x11e9b
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x11e91
decw 0x10(%rax)
movq 0x20(%rdi), %rax
testq %rax, %rax
jne 0x11ea4
retq
cmpl $0x1, %eax
jne 0x11e9a
movq 0x8(%rdi), %rax
decw 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/example.c
// Function: get_generic_operand
static struct operand *get_generic_operand(struct bb_state *state, pseudo_t pseudo)
{
	struct hardreg *reg;
	struct storage *src;
	struct storage_hash *hash;
	struct operand *op = malloc(sizeof(*op));

	memset(op, 0, sizeof(*op));
	switch (pseudo->type) {
	case PSEUDO_VAL:
		op->type = OP_VAL;
		op->value = pseudo->value;
		break;

	case PSEUDO_SYM: {
		struct symbol *sym = pseudo->sym;
		op->type = OP_ADDR;
		if (sym->ctype.modifiers & MOD_NONLOCAL) {
			op->sym = sym;
			break;
		}
		op->base = hardregs + REG_EBP;
		op->offset = get_sym_frame_offset(state, pseudo);
		break;
	}

	default:
		reg = find_in_reg(state, pseudo);
		if (reg) {
			op->type = OP_REG;
			op->reg = reg;
			reg->busy++;
			break;
		}
		hash = find_pseudo_storage(state, pseudo, NULL);
		if (!hash)
			break;
		src = hash->storage;
		switch (src->type) {
		case REG_REG:
			op->type = OP_REG;
			op->reg = hardregs + src->regno;
			op->reg->busy++;
			break;
		case REG_FRAME:
			op->type = OP_MEM;
			op->offset = src->offset;
			op->base = hardregs + REG_EBP;
			break;
		case REG_STACK:
			op->type = OP_MEM;
			op->offset = src->offset;
			op->base = hardregs + REG_ESP;
			break;
		default:
			break;
		}
	}
	return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x28, %edi
callq 0xf200
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movl 0x4(%r14), %eax
cmpl $0x5, %eax
je 0x11ef4
cmpl $0x6, %eax
jne 0x11f0d
movl $0x2, (%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x8(%rbx)
jmp 0x11fc7
movq 0x18(%r14), %rax
movl $0x4, (%rbx)
testb $0x18, 0x68(%rax)
je 0x11f30
movq %rax, 0x10(%rbx)
jmp 0x11fc7
movq %r15, %rdi
movq %r14, %rsi
callq 0x114a0
testq %rax, %rax
je 0x11f59
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
incw 0x10(%rax)
jmp 0x11fc7
leaq 0x56309(%rip), %rax     # 0x68240
movq %rax, 0x18(%rbx)
movl (%r14), %eax
testl %eax, %eax
jns 0x11f54
movl 0x5b67c(%rip), %eax     # 0x6d5c4
leal 0x4(%rax), %ecx
movl %ecx, 0x5b673(%rip)     # 0x6d5c4
movl %eax, (%r14)
movl %eax, 0x8(%rbx)
jmp 0x11fc7
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x11b87
testq %rax, %rax
je 0x11fc7
movq 0x18(%rax), %rax
movl (%rax), %ecx
cmpl $0x3, %ecx
je 0x11fb0
cmpl $0x2, %ecx
je 0x11f9b
cmpl $0x1, %ecx
jne 0x11fc7
movl $0x1, (%rbx)
movslq 0x10(%rax), %rax
leaq (%rax,%rax,2), %rax
leaq 0x5621b(%rip), %rcx     # 0x681b0
leaq (%rcx,%rax,8), %rax
jmp 0x11f23
movl $0x3, (%rbx)
movl 0x10(%rax), %eax
movl %eax, 0x8(%rbx)
leaq 0x562aa(%rip), %rax     # 0x68258
jmp 0x11fc3
movl $0x3, (%rbx)
movl 0x10(%rax), %eax
movl %eax, 0x8(%rbx)
leaq 0x5627d(%rip), %rax     # 0x68240
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/example.c
// Function: flush_cc_cache
static void flush_cc_cache(struct bb_state *state)
{
	pseudo_t pseudo = state->cc_target;

	if (pseudo) {
		struct hardreg *dst;

		state->cc_target = NULL;

		if (!state->cc_dead) {
			dst = target_reg(state, pseudo, pseudo);
			flush_cc_cache_to_reg(state, pseudo, dst);
		}
	}
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rdx
testq %rdx, %rdx
je 0x11feb
movq %rdi, %rbx
movq $0x0, 0x28(%rdi)
cmpl $0x0, 0x24(%rdi)
je 0x11fed
popq %rbx
retq
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x11595
movslq 0x20(%rbx), %rcx
movl $0x0, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
leaq 0x4d69e(%rip), %rdx     # 0x5f6b0
movq (%rdx,%rcx,8), %rdx
movq (%rax), %rcx
leaq 0x3439f(%rip), %rsi     # 0x463bf
leaq 0x343a4(%rip), %r8      # 0x463cb
xorl %eax, %eax
popq %rbx
jmp 0x11334
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/example.c
// Function: is_dead_reg
static int is_dead_reg(struct bb_state *state, pseudo_t pseudo, struct hardreg *reg)
{
	pseudo_t p;
	FOR_EACH_PTR_TAG(reg->contains, p) {
		if (p == pseudo)
			return CURRENT_TAG(p) & TAG_DEAD;
	} END_FOR_EACH_PTR(p);
	return 0;
}

// Assembly:
pushq %rbx
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x12097
movq %rcx, %rdx
movzwl (%rdx), %eax
movsbl %al, %esi
testw %si, %si
jle 0x12080
movzwl %si, %esi
movzwl %ax, %r8d
xorl %r9d, %r9d
cmpl $0x100, %r8d            # imm = 0x100
setb %r11b
movq 0x18(%rdx,%r9,8), %rax
movq %rax, %r10
andq $-0x4, %r10
setne %bl
orb %r11b, %bl
cmpb $0x1, %bl
jne 0x12078
cmpq %rdi, %r10
je 0x1208d
incq %r9
cmpq %r9, %rsi
jne 0x12051
movq 0x10(%rdx), %rdx
cmpq %rcx, %rdx
jne 0x1203c
xorl %ecx, %ecx
jmp 0x1209c
andl $0x1, %eax
movl $0x1, %ecx
jmp 0x1209c
movl $0x2, %ecx
testb $0x1, %cl
jne 0x120a3
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/example.c
// Function: do_binop
static void do_binop(struct bb_state *state, struct instruction *insn, pseudo_t val1, pseudo_t val2)
{
	const char *op = opcodes[insn->opcode];
	struct operand *src = get_register_operand(state, val1, insn->target);
	struct operand *src2 = get_generic_operand(state, val2);
	struct hardreg *dst;

	dst = target_copy_reg(state, src->reg, insn->target);
	output_insn(state, "%s.%d %s,%s", op, insn->size, show_op(state, src2), dst->name);
	put_operand(state, src);
	put_operand(state, src2);
	add_pseudo_reg(state, insn->target, dst);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
andl $0x7f, %eax
leaq 0x4d5e5(%rip), %rcx     # 0x5f6b0
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsi), %r12
movl $0x28, %edi
callq 0xf200
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movl $0x1, (%rax)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x11454
movq %rax, %r12
movq %rax, 0x8(%r15)
incw 0x10(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x11ea9
movq %rax, %r13
movq 0x20(%r14), %rbp
movq %r12, %rdi
callq 0x121a5
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x122ad
movq %rax, %rbp
movl (%r14), %r12d
shrl $0x8, %r12d
movq %r13, %rdi
callq 0x11cfb
movq (%rbp), %r9
leaq 0x343de(%rip), %rcx     # 0x46539
movq %rcx, (%rsp)
leaq 0x343c1(%rip), %rsi     # 0x46527
movq 0x10(%rsp), %rdx
movl %r12d, %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0x11334
movq %r15, %rdi
callq 0x11e7a
movq %r13, %rdi
callq 0x11e7a
movq 0x20(%r14), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x111ba
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/example.c
// Function: kill_dead_reg
static void kill_dead_reg(struct hardreg *reg)
{
	if (reg->dead) {
		pseudo_t p;
		
		FOR_EACH_PTR_TAG(reg->contains, p) {
			if (CURRENT_TAG(p) & TAG_DEAD) {
				DELETE_CURRENT_PTR(p);
				reg->dead--;
			}
		} END_FOR_EACH_PTR(p);
		PACK_PTR_LIST(&reg->contains);
		assert(!reg->dead);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x0, 0x12(%rdi)
je 0x12285
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1227a
movl $0xf0f0f0f0, %ecx       # imm = 0xF0F0F0F0
movl $0xff0000, %edx         # imm = 0xFF0000
movq %rax, %rsi
movzwl (%rsi), %ebp
movsbl %bpl, %r11d
testw %r11w, %r11w
jle 0x1226d
leaq 0x18(%rsi), %r8
leaq 0x10(%rsi), %r9
xorl %r10d, %r10d
movslq %r10d, %r14
movq (%r8,%r14,8), %r15
movzwl %bp, %ebp
cmpl $0x100, %ebp            # imm = 0x100
setae %bpl
cmpq $0x4, %r15
setb %r12b
testb %r12b, %bpl
jne 0x1225b
andl $0x1, %r15d
je 0x1225b
leaq (%r8,%r14,8), %r14
movswq %r11w, %r11
leaq (%r9,%r11,8), %r11
cmpq %r11, %r14
jae 0x12241
leaq 0x8(%r14), %r15
movq 0x8(%r14), %r12
movq %r12, (%r14)
movq %r15, %r14
cmpq %r11, %r15
jb 0x1222c
jmp 0x12244
movq %r14, %r15
movq %rcx, (%r15)
decb (%rsi)
decl %r10d
movl 0x10(%rbx), %r11d
addl %edx, %r11d
shrl $0x10, %r11d
movb %r11b, 0x12(%rbx)
incl %r10d
movl (%rsi), %ebp
movsbl %bpl, %r11d
movsbl %bpl, %r14d
cmpl %r14d, %r10d
jl 0x121f4
movq 0x10(%rsi), %rsi
cmpq %rax, %rsi
jne 0x121d8
callq 0x285f5
cmpb $0x0, 0x12(%rbx)
jne 0x1228e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x342ad(%rip), %rdi     # 0x46542
leaq 0x34018(%rip), %rsi     # 0x462b4
leaq 0x342aa(%rip), %rcx     # 0x4654d
movl $0x36d, %edx            # imm = 0x36D
callq 0xf120