LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x10fce(%rip), %rax     # 0x14420
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %edx
leaq 0xb03e(%rip), %rsi      # 0xe4a2
movb $0x0, %al
callq 0x1230
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x10f7d(%rip)     # 0x14400
je 0x34c3
movq -0x10(%rbp), %rdi
movq 0x10f78(%rip), %rax     # 0x14408
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xfcbf(%rip), %rax      # 0x13160
movq (%rax,%rcx,8), %rdx
leaq 0xb137(%rip), %rsi      # 0xe5e3
movb $0x0, %al
callq 0x1230
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x10f35(%rip)     # 0x14400
je 0x3536
movq 0x10f34(%rip), %rax     # 0x14408
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jle 0x3536
movq 0x10f20(%rip), %rax     # 0x14408
movslq -0x4(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x4, %eax
jge 0x3536
movq -0x10(%rbp), %rdi
movq 0x10f00(%rip), %rax     # 0x14400
movslq -0x4(%rbp), %rcx
movswl (%rax,%rcx,4), %edx
movq 0x10ef1(%rip), %rax     # 0x14400
movslq -0x4(%rbp), %rcx
movzwl 0x2(%rax,%rcx,4), %ecx
leaq 0xb0c8(%rip), %rsi      # 0xe5e7
movb $0x0, %al
callq 0x1230
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x10e7f(%rip), %rax     # 0x143c0
movq 0x8(%rax), %rax
movl -0x4(%rbp), %ecx
movq 0x10e71(%rip), %rdx     # 0x143c0
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx), %edx
leaq 0xb08e(%rip), %rsi      # 0xe5ee
movb $0x0, %al
callq 0x1230
leaq 0x10eb2(%rip), %rax     # 0x14420
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, 0x10eaa(%rip)     # 0x14440
je 0x35b7
movl -0x8(%rbp), %eax
cmpl 0x10ea7(%rip), %eax     # 0x14448
jne 0x35b7
movl -0xc(%rbp), %eax
cmpl 0x10ea0(%rip), %eax     # 0x1444c
jne 0x35b7
movb $0x0, -0x1(%rbp)
jmp 0x3650
cmpq $0x0, 0x10e81(%rip)     # 0x14440
jne 0x35da
movl 0x10e21(%rip), %eax     # 0x143e8
movl %eax, %edi
movl $0x1, %esi
callq 0xd1f0
movq %rax, 0x10e66(%rip)     # 0x14440
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x10dfe(%rip), %eax     # 0x143e8
jae 0x363a
movq 0x10dcd(%rip), %rax     # 0x143c0
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movq 0x10dbf(%rip), %rdx     # 0x143c0
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x362d
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x362d
movq 0x10e1b(%rip), %rax     # 0x14440
movslq -0x10(%rbp), %rcx
movb $0x1, (%rax,%rcx)
jmp 0x362f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x35e1
movl -0x8(%rbp), %eax
movl %eax, 0x10e05(%rip)     # 0x14448
movl -0xc(%rbp), %eax
movl %eax, 0x10e00(%rip)     # 0x1444c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpq $0x0, 0x10567(%rip)     # 0x14440
jne 0x3ef8
movq 0xf116(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0xa804(%rip), %rsi      # 0xe6f0
movb $0x0, %al
callq 0x1150
jmp 0x3ffc
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x3ffc
movq 0x104bf(%rip), %rax     # 0x143d0
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %edi
callq 0x3440
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0xa7ed(%rip), %rsi      # 0xe718
movb $0x0, %al
callq 0x1150
movq 0x10507(%rip), %rax     # 0x14440
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x3fdd
movl -0x10(%rbp), %edi
callq 0x3660
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movslq 0x18(%rax), %rsi
movq -0x18(%rbp), %rax
movslq 0x14(%rax), %rdx
leaq -0x2b92(%rip), %rcx     # 0x13e0
callq 0x1090
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rdx
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq 0x1042e(%rip), %rax     # 0x143d0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x3440
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %edx
movq %rax, %rcx
leaq 0xa759(%rip), %rsi      # 0xe726
movb $0x0, %al
callq 0x1150
movq -0x18(%rbp), %rdi
callq 0xc3e0
movq 0x103ec(%rip), %rsi     # 0x143d0
movl $0xa, %edi
callq 0x1100
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x3efe
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0xc(%rbp), %edi
callq 0x1060
cmpl $0x0, -0x4(%rbp)
jle 0x6668
cmpl $0x0, -0x8(%rbp)
jg 0x667c
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
leaq 0x8aaf(%rip), %rdi      # 0xf124
movb $0x0, %al
callq 0xd0c0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0xa020
movq %rax, 0xdd2a(%rip)      # 0x143b8
movl -0x10(%rbp), %eax
movl %eax, 0xcab9(%rip)      # 0x13150
cmpl $0x14, 0xcab2(%rip)     # 0x13150
jl 0x66a9
cmpl $0x1e, 0xcaa9(%rip)     # 0x13150
jle 0x66bd
movl 0xcaa1(%rip), %esi      # 0x13150
leaq 0x8aa1(%rip), %rdi      # 0xf157
movb $0x0, %al
callq 0xd0c0
movl 0xca8d(%rip), %eax      # 0x13150
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0xdd0c(%rip)      # 0x143e0
movq 0xdd05(%rip), %rax      # 0x143e0
subq $0x1, %rax
movq %rax, 0xddaa(%rip)      # 0x14490
movq 0xdcf3(%rip), %rdi      # 0x143e0
movl $0x4, %esi
callq 0xd1f0
movq %rax, 0xdcda(%rip)      # 0x143d8
movq 0xdcdb(%rip), %rdi      # 0x143e0
shrq $0x2, %rdi
movl $0x8, %esi
callq 0xd1f0
movq %rax, 0xdcd6(%rip)      # 0x143f0
movl $0x1, 0xdcc4(%rip)      # 0x143e8
movl $0x100000, %edi         # imm = 0x100000
movl $0x4, %esi
callq 0xc1e0
movq %rax, 0xdc86(%rip)      # 0x143c0
movq 0xdc8f(%rip), %rdi      # 0x143d0
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
movl -0xc(%rbp), %r8d
movl -0x10(%rbp), %r9d
leaq 0x8a25(%rip), %rsi      # 0xf17b
movb $0x0, %al
callq 0x1150
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0x3660
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8736
jmp 0x8803
movq 0xbc93(%rip), %rax      # 0x143d0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x4(%rbp), %edi
callq 0x3440
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %edx
movq %rax, %rcx
leaq 0x5ef0(%rip), %rsi      # 0xe654
movb $0x0, %al
callq 0x1150
movl $0x400, %edi            # imm = 0x400
movl $0x4, %esi
callq 0xc1e0
movq %rax, -0x18(%rbp)
movl $0x400, %edi            # imm = 0x400
callq 0xad00
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x87e8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rdx
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
movzwl 0x4(%rax,%rcx), %eax
cmpl -0x8(%rbp), %eax
jl 0x87db
movl $0x0, -0x28(%rbp)
cmpl $0x1b, -0x28(%rbp)
jge 0x87d9
jmp 0x87ce
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x87c6
jmp 0x87db
jmp 0x87dd
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8793
movq -0x10(%rbp), %rdi
callq 0xc3e0
movq -0x18(%rbp), %rdi
callq 0xc3e0
movq -0x10(%rbp), %rdi
callq 0xae40
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x8cc8
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x8c73
xorl %eax, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x9fd0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x8cbf
movl -0x20(%rbp), %eax
shll %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x20(%rbp), %rsi
callq 0x11c0
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x8cbd
movq 0xa359(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movl -0x20(%rbp), %edx
leaq 0x6c6c(%rip), %rsi      # 0xf918
movb $0x0, %al
callq 0x1150
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1240
jmp 0x8cbf
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb -0x1(%rbp), %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x9440
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x93c7
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x93c7
jmp 0x9440
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpl $-0x2, (%rax,%rcx,4)
jge 0x9400
movq 0x9c1c(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movl -0x2c(%rbp), %edx
movl -0x2c(%rbp), %ecx
movl -0x28(%rbp), %r8d
leaq 0x6374(%rip), %rsi      # 0xf764
movb $0x0, %al
callq 0x1150
movl $0x0, -0x4(%rbp)
jmp 0x946a
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x9430
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x28(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x9432
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9392
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x9454
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, -0x18(%rbp)
je 0x9464
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x94cb
movq 0x9b4a(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x62db(%rip), %rsi      # 0xf793
movb $0x0, %al
callq 0x1150
movl $0x0, -0x4(%rbp)
jmp 0x95f5
cmpq $0x0, -0x28(%rbp)
je 0x952f
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x952f
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x62cc(%rip), %rsi      # 0xf7b9
movb $0x0, %al
callq 0x1150
cmpq $0x0, -0x30(%rbp)
je 0x951d
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x951d
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x520c(%rip), %rsi      # 0xe722
movb $0x0, %al
callq 0x1150
movq -0x10(%rbp), %rdi
leaq 0x5645(%rip), %rsi      # 0xeb6d
movb $0x0, %al
callq 0x1150
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x95e1
cmpl $0x0, -0x38(%rbp)
je 0x9566
movl -0x38(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x9566
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x1100
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x38(%rbp), %rdx
movsbq (%rcx,%rdx), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x959c
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x38(%rbp), %rdx
movsbq (%rcx,%rdx), %rcx
movl (%rax,%rcx,4), %edi
movq -0x10(%rbp), %rsi
callq 0x1100
jmp 0x95d1
movq 0x9a55(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
movl -0x38(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rsi
movsbl (%rax,%rsi), %r8d
leaq 0x61fc(%rip), %rsi      # 0xf7bd
movb $0x0, %al
callq 0x1150
movl $0x0, -0x4(%rbp)
jmp 0x95f5
jmp 0x95d3
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x9536
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x1100
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rdi
callq 0x1190
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xa013
movq 0x9003(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x5945(%rip), %rsi      # 0xf947
movb $0x0, %al
callq 0x1150
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1240
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x200f0
movq %rax, %rdi
callq 0x11560
leaq 0x86afb(%rip), %rax     # 0x97fa8
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x114d4
jmp 0x11551
jmp 0x114d6
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x1153d
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x11521
cmpq $0x0, -0x20(%rbp)
jne 0x11521
jmp 0x11532
movq -0x20(%rbp), %rdi
callq 0x20560
movq %rax, %rdi
callq 0x11560
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x114dd
jmp 0x1153f
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x114d6
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: compile
static int compile(struct symbol_list *list)
{
	struct symbol *sym;
	FOR_EACH_PTR(list, sym) {
		struct entrypoint *ep;
		expand_symbol(sym);
		ep = linearize_symbol(sym);
		if (ep)
			output(ep);
	} END_FOR_EACH_PTR(sym);
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11590
jmp 0x11628
jmp 0x11592
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x11610
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x115dd
cmpq $0x0, -0x10(%rbp)
jne 0x115dd
jmp 0x11605
movq -0x10(%rbp), %rdi
callq 0x17050
movq -0x10(%rbp), %rdi
callq 0x23860
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x11603
movq -0x38(%rbp), %rdi
callq 0x11630
jmp 0x11605
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11599
jmp 0x11612
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x11592
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: output
static void output(struct entrypoint *ep)
{
	unsigned long generation = ++bb_generation;

	last_reg = -1;
	stack_offset = 0;

	/* Get rid of SSA form (phinodes etc) */
	unssa(ep);

	/* Set up initial inter-bb storage links */
	set_up_storage(ep);

	/* Architecture-specific storage rules.. */
	arch_set_up_storage(ep);

	/* Show the results ... */
	output_bb(ep->entry->bb, generation);

	/* Clear the storage hashes for the next function.. */
	free_storage();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x8508d(%rip), %rax     # 0x966d0
movq (%rax), %rax
addq $0x1, %rax
leaq 0x8507f(%rip), %rcx     # 0x966d0
movq %rax, (%rcx)
movq %rax, -0x10(%rbp)
movl $0xffffffff, 0x8376e(%rip) # imm = 0xFFFFFFFF
movl $0x0, 0x83768(%rip)     # 0x94dd4
movq -0x8(%rbp), %rdi
callq 0x502f0
movq -0x8(%rbp), %rdi
callq 0x48c20
movq -0x8(%rbp), %rdi
callq 0x116b0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x117d0
callq 0x488e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: arch_set_up_storage
static void arch_set_up_storage(struct entrypoint *ep)
{
	struct basic_block *bb;

	/* Argument storage etc.. */
	set_up_arch_entry(ep, ep->entry);

	FOR_EACH_PTR(ep->bbs, bb) {
		struct instruction *insn = last_instruction(bb->insns);
		if (!insn)
			continue;
		switch (insn->opcode) {
		case OP_RET:
			set_up_arch_exit(bb, insn);
			break;
		case OP_SWITCH:
			set_up_arch_switch(bb, insn);
			break;
		default:
			/* nothing */;
		}
	} END_FOR_EACH_PTR(bb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x11890
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x116f5
jmp 0x117c5
jmp 0x116f7
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x117ad
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x11746
cmpq $0x0, -0x10(%rbp)
jne 0x11746
jmp 0x1179f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x11b50
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x11760
jmp 0x1179f
movq -0x38(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x3c(%rbp)
subl $0x2, %eax
je 0x1177d
jmp 0x11773
movl -0x3c(%rbp), %eax
subl $0x5, %eax
je 0x1178c
jmp 0x1179b
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11b70
jmp 0x1179d
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11c00
jmp 0x1179d
jmp 0x1179d
jmp 0x1179f
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x116fe
jmp 0x117af
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x116f7
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: output_bb
static void output_bb(struct basic_block *bb, unsigned long generation)
{
	struct bb_state state;

	bb->generation = generation;

	/* Make sure all parents have been generated first */
	generate_list(bb->parents, generation);

	state.pos = bb->pos;
	state.inputs = gather_storage(bb, STOR_IN);
	state.outputs = gather_storage(bb, STOR_OUT);
	state.internal = NULL;
	state.cc_opcode = 0;
	state.cc_target = NULL;

	/* Mark incoming registers used */
	mark_used_registers(bb, &state);

	generate(bb, &state);

	free_ptr_list(&state.inputs);
	free_ptr_list(&state.outputs);

	/* Generate all children... */
	generate_list(bb->children, generation);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x11cd0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x48360
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x48360
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x11da0
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x11f60
leaq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x3aa60
jmp 0x11869
leaq -0x40(%rbp), %rdi
addq $0x10, %rdi
callq 0x3aa60
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x11cd0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: set_up_arch_exit
static void set_up_arch_exit(struct basic_block *bb, struct instruction *ret)
{
	pseudo_t pseudo = ret->src;

	if (pseudo && pseudo != VOID) {
		struct storage *out = lookup_storage(bb, pseudo, STOR_OUT);
		if (!out) {
			out = alloc_storage();
			add_storage(out, bb, pseudo, STOR_OUT);
		}
		out->type = REG_REG;
		out->regno = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x11bf1
leaq 0x85036(%rip), %rax     # 0x96bd0
cmpq %rax, -0x18(%rbp)
je 0x11bf1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x48690
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11bdc
callq 0x11c80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x487f0
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: set_up_arch_switch
static void set_up_arch_switch(struct basic_block *bb, struct instruction *insn)
{
	pseudo_t pseudo = insn->cond;
	struct storage *out = lookup_storage(bb, pseudo, STOR_OUT);
	if (!out) {
		out = alloc_storage();
		add_storage(out, bb, pseudo, STOR_OUT);
	}
	out->type = REG_REG;
	out->regno = SWITCH_REG;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x48690
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11c58
callq 0x11c80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x487f0
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11d04
jmp 0x11d91
jmp 0x11d06
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x11d79
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x11d51
cmpq $0x0, -0x18(%rbp)
jne 0x11d51
jmp 0x11d6e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x11d61
jmp 0x11d6e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x117d0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x11d0d
jmp 0x11d7b
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x11d06
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: mark_used_registers
static void mark_used_registers(struct basic_block *bb, struct bb_state *state)
{
	struct basic_block *parent;

	FOR_EACH_PTR(bb->parents, parent) {
		struct storage_hash_list *outputs = gather_storage(parent, STOR_OUT);
		struct storage_hash *entry;

		FOR_EACH_PTR(outputs, entry) {
			struct storage *s = entry->storage;
			if (s->type == REG_REG) {
				struct hardreg *reg = hardregs + s->regno;
				reg->used = 1;
			}
		} END_FOR_EACH_PTR(entry);
	} END_FOR_EACH_PTR(parent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11ddb
jmp 0x11f4b
jmp 0x11ddd
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x11f33
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x11e2f
cmpq $0x0, -0x18(%rbp)
jne 0x11e2f
jmp 0x11f25
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x48360
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x11e65
jmp 0x11f23
jmp 0x11e67
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
movq -0x58(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x11f0b
movq -0x58(%rbp), %rax
movslq -0x64(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x58(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x11eb6
cmpq $0x0, -0x48(%rbp)
jne 0x11eb6
jmp 0x11efd
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x11efb
movq -0x70(%rbp), %rax
movslq 0x10(%rax), %rcx
leaq 0x7b2c6(%rip), %rax     # 0x8d1a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0xfeffffff, %ecx       # imm = 0xFEFFFFFF
orl $0x1000000, %ecx        # imm = 0x1000000
movl %ecx, 0x10(%rax)
jmp 0x11efd
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x11e6e
jmp 0x11f0d
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq -0x50(%rbp), %rax
jne 0x11e67
jmp 0x11f25
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x11de4
jmp 0x11f35
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x11ddd
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: generate_load
static void generate_load(struct instruction *insn, struct bb_state *state)
{
	const char *input = address(state, insn);
	struct hardreg *dst;

	kill_dead_pseudos(state);
	dst = target_reg(state, insn->target, NULL);
	output_insn(state, "mov.%d %s,%s", insn->size, input, dst->name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x13700
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13660
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x13920
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
shrl $0x8, %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %r8
leaq 0x566dd(%rip), %rsi     # 0x6923f
leaq 0x56963(%rip), %r9      # 0x694cc
movb $0x0, %al
callq 0x135a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: mark_pseudo_dead
static void mark_pseudo_dead(struct bb_state *state, pseudo_t pseudo)
{
	int i;
	struct storage_hash *src;

	if (state->cc_target == pseudo)
		state->cc_dead = 1;
	src = find_pseudo_storage(state, pseudo, NULL);
	if (src)
		src->flags |= TAG_DEAD;
	for (i = 0; i < REGNO; i++)
		mark_reg_dead(state, pseudo, hardregs + i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x12ba9
movq -0x8(%rbp), %rax
movl $0x1, 0x24(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x144a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12bd5
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
orq $0x1, %rcx
movq %rcx, 0x20(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
jge 0x12c0c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rax
leaq 0x7a5ab(%rip), %rdx     # 0x8d1a0
imulq $0x18, %rax, %rax
addq %rax, %rdx
callq 0x14600
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12bdc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: generate_commutative_binop
static void generate_commutative_binop(struct bb_state *state, struct instruction *insn)
{
	pseudo_t src1, src2;
	struct hardreg *reg1, *reg2;

	flush_cc_cache(state);
	src1 = insn->src1;
	src2 = insn->src2;
	reg2 = find_in_reg(state, src2);
	if (!reg2)
		goto dont_switch;
	reg1 = find_in_reg(state, src1);
	if (!reg1)
		goto do_switch;
	if (!is_dead_reg(state, src2, reg2))
		goto dont_switch;
	if (!is_dead_reg(state, src1, reg1))
		goto do_switch;

	/* Both are dead. Is one preferable? */
	if (reg2 != preferred_reg(state, insn->target))
		goto dont_switch;

do_switch:
	src1 = src2;
	src2 = insn->src1;
dont_switch:
	do_binop(state, insn, src1, src2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x150c0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x137c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x12cce
jmp 0x12d55
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x137c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x12ce8
jmp 0x12d41
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x15130
cmpl $0x0, %eax
jne 0x12d00
jmp 0x12d55
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x15130
cmpl $0x0, %eax
jne 0x12d18
jmp 0x12d41
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x13d00
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
je 0x12d3f
jmp 0x12d55
jmp 0x12d41
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x15210
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: generate_compare
static void generate_compare(struct bb_state *state, struct instruction *insn)
{
	struct hardreg *src;
	const char *src2;
	int opcode;

	flush_cc_cache(state);
	opcode = insn->opcode;

	/*
	 * We should try to switch these around if necessary,
	 * and update the opcode to match..
	 */
	src = getreg(state, insn->src1, insn->target);
	src2 = generic(state, insn->src2);

	output_insn(state, "cmp.%d %s,%s", insn->size, src2, src->name);

	add_cc_cache(state, opcode, insn->target);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x150c0
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x13750
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x15800
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
shrl $0x8, %edx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %r8
leaq 0x56775(%rip), %rsi     # 0x6959b
leaq 0x56781(%rip), %r9      # 0x695ae
movb $0x0, %al
callq 0x135a0
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x15990
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: generate_cast
static void generate_cast(struct bb_state *state, struct instruction *insn)
{
	struct hardreg *src = getreg(state, insn->src, insn->target);
	struct hardreg *dst;
	unsigned int old = insn->orig_type ? insn->orig_type->bit_size : 0;
	unsigned int new = insn->size;

	/*
	 * Cast to smaller type? Ignore the high bits, we
	 * just keep both pseudos in the same register.
	 */
	if (old >= new) {
		add_pseudo_reg(state, insn->target, src);
		return;
	}

	dst = target_copy_reg(state, src, insn->target);

	if (insn->orig_type && (insn->orig_type->ctype.modifiers & MOD_SIGNED)) {
		output_insn(state, "sext.%d.%d %s", old, new, dst->name);
	} else {
		unsigned long long mask;
		mask = ~(~0ULL << old);
		mask &= ~(~0ULL << new);
		output_insn(state, "andl.%d $%#llx,%s", insn->size, mask, dst->name);
	}
	add_pseudo_reg(state, insn->target, dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x13750
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x12e98
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x50(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x12e9f
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x12e9f
movl -0x34(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jb 0x12ed3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x126b0
jmp 0x12fab
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x153a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x12f37
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x68(%rax), %rax
andq $0x2000, %rax           # imm = 0x2000
cmpq $0x0, %rax
je 0x12f37
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movq (%rax), %r8
leaq 0x5670c(%rip), %rsi     # 0x69633
leaq 0x56719(%rip), %r9      # 0x69647
movb $0x0, %al
callq 0x135a0
jmp 0x12f96
movl -0x24(%rbp), %eax
movl %eax, %ecx
movq $-0x1, %rax
shlq %cl, %rax
xorq $-0x1, %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
movl %eax, %ecx
movq $-0x1, %rax
shlq %cl, %rax
xorq $-0x1, %rax
andq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
shrl $0x8, %edx
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %r8
leaq 0x566cd(%rip), %rsi     # 0x69655
leaq 0x566b8(%rip), %r9      # 0x69647
movb $0x0, %al
callq 0x135a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x126b0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: generate_select
static void generate_select(struct bb_state *state, struct instruction *insn)
{
	const char *cond;
	struct hardreg *src1, *src2, *dst;

	src1 = getreg(state, insn->src2, NULL);
	dst = copy_reg(state, src1, insn->target);
	add_pseudo_reg(state, insn->target, dst);
	src2 = getreg(state, insn->src3, insn->target);

	if (state->cc_target == insn->src1) {
		cond = conditional[state->cc_opcode];
	} else {
		struct hardreg *reg = getreg(state, insn->src1, NULL);
		output_insn(state, "testl %s,%s", reg->name, reg->name);
		cond = "ne";
	}

	output_insn(state, "sel%s %s,%s", cond, src2->name, dst->name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x13750
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x15620
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x126b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x13750
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x1305f
movq -0x8(%rbp), %rax
movslq 0x20(%rax), %rcx
leaq 0x7a49b(%rip), %rax     # 0x8d4f0
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x130aa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x13750
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rdx
movq -0x38(%rbp), %rax
movq (%rax), %rcx
leaq 0x565dc(%rip), %rsi     # 0x6966d
leaq 0x565e7(%rip), %r8      # 0x6967f
movb $0x0, %al
callq 0x135a0
leaq 0x5c1bf(%rip), %rax     # 0x6f265
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq (%rax), %r8
leaq 0x565c8(%rip), %rsi     # 0x6968f
leaq 0x565b1(%rip), %r9      # 0x6967f
movb $0x0, %al
callq 0x135a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: generate_branch
static void generate_branch(struct bb_state *state, struct instruction *br)
{
	const char *cond = "XXX";
	struct basic_block *target;

	if (br->cond) {
		if (state->cc_target == br->cond) {
			cond = conditional[state->cc_opcode];
		} else {
			struct hardreg *reg = getreg(state, br->cond, NULL);
			output_insn(state, "testl %s,%s", reg->name, reg->name);
			cond = "ne";
		}
	}
	generate_output_storage(state);
	target = br->bb_true;
	if (br->cond) {
		output_insn(state, "j%s .L%p", cond, target);
		target = br->bb_false;
	}
	output_insn(state, "jmp .L%p", target);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x565aa(%rip), %rax     # 0x696a1
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1317e
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x13131
movq -0x8(%rbp), %rax
movslq 0x20(%rax), %rcx
leaq 0x7a3c9(%rip), %rax     # 0x8d4f0
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x1317c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x13750
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rcx
leaq 0x5650a(%rip), %rsi     # 0x6966d
leaq 0x5653b(%rip), %r8      # 0x696a5
movb $0x0, %al
callq 0x135a0
leaq 0x5c0ed(%rip), %rax     # 0x6f265
movq %rax, -0x18(%rbp)
jmp 0x1317e
movq -0x8(%rbp), %rdi
callq 0x15a20
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x131cb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x56504(%rip), %rsi     # 0x696b5
leaq 0x564ed(%rip), %r8      # 0x696a5
movb $0x0, %al
callq 0x135a0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x564ea(%rip), %rsi     # 0x696c4
leaq 0x564c4(%rip), %rcx     # 0x696a5
movb $0x0, %al
callq 0x135a0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/example.c
// Function: generate_switch
static void generate_switch(struct bb_state *state, struct instruction *insn)
{
	struct hardreg *reg = hardregs + SWITCH_REG;

	generate_output_storage(state);
	output_insn(state, "switch on %s", reg->name);
	output_insn(state, "unimplemented: %s", show_instruction(insn));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x79f99(%rip), %rax     # 0x8d1a0
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15a20
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x564f2(%rip), %rsi     # 0x6971c
leaq 0x564fe(%rip), %rcx     # 0x6972f
movb $0x0, %al
callq 0x135a0
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20f90
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x55fbe(%rip), %rsi     # 0x69215
leaq 0x564d1(%rip), %rcx     # 0x6972f
movb $0x0, %al
callq 0x135a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)