LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshset.c
// Function: moshsetPack
BOOL moshsetPack (Moshset *ms)	/* compress per-item arrays */
{ if (ms->size == ms->max+1) return FALSE ;
  resize (ms->value, ms->size, ms->max+1, U64) ;
  resize (ms->depth, ms->size, ms->max+1, U16) ;
  resize (ms->info, ms->size, ms->max+1, U8) ;
  ms->size = ms->max+1 ;
  return TRUE ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x40(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x520a
movb $0x0, -0x1(%rbp)
jmp 0x53c0
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x8260
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x40(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jae 0x525a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
shlq $0x3, %rdx
callq 0x1140
jmp 0x527d
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x3, %rdx
callq 0x1140
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1040
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq %rdi
callq 0x8260
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x40(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jae 0x52e4
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
shlq %rdx
callq 0x1140
jmp 0x5306
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq %rdx
callq 0x1140
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1040
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0x8260
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
movl 0x40(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jae 0x536f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
shlq $0x0, %rdx
callq 0x1140
jmp 0x5392
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x0, %rdx
callq 0x1140
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x1040
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshset.c
// Function: moshsetIndexFind
U32 moshsetIndexFind (Moshset *ms, U64 hash, int isAdd)
{
  U64 diff = 0 ;
  U64 offset = hash & ms->tableMask ;
  U32 index = ms->index[offset] ;
  while (index && (ms->value[index] != hash))
    { if (!diff) diff = ((hash >> ms->tableBits) & ms->tableMask) | 1 ; /* odd so comprime */
      offset = (offset + diff) & ms->tableMask ;
      index = ms->index[offset] ;
    }
  if (!index && isAdd)
    { index = ms->index[offset] = ++ms->max ;
      if (ms->max >= ms->size) die ("hashTableSize %u is too small for %u", ms->size, ms->max) ;
      ms->value[index] = hash ;
    }
  return index ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
andq 0x18(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x2c(%rbp)
movb %al, -0x2d(%rbp)
je 0x5431
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x2c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x543a
jmp 0x5487
cmpq $0x0, -0x20(%rbp)
jne 0x545f
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
shrq %cl, %rax
movq -0x8(%rbp), %rcx
andq 0x18(%rcx), %rax
orq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
andq 0x18(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
jmp 0x540d
cmpl $0x0, -0x2c(%rbp)
jne 0x54f1
cmpl $0x0, -0x14(%rbp)
je 0x54f1
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x40(%rcx)
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq -0x28(%rbp), %rdx
movl %eax, (%rcx,%rdx,4)
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x54de
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edx
leaq 0x46d8(%rip), %rdi      # 0x9baf
movb $0x0, %al
callq 0x8180
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x2c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshset.c
// Function: moshsetDepthPrune
void moshsetDepthPrune (Moshset *ms, int min, int max)
{
  U32 i ;
  U32 N = ms->max ; ms->max = 0 ;
  memset (ms->index, 0, ms->tableSize*sizeof(U32)) ;
  for (i = 1 ; i <= N ; ++i)	/* NB index runs from 1..max */
    if (ms->depth[i] >= min && (!max || ms->depth[i] < max))
      { moshsetIndexFind (ms, ms->value[i], TRUE) ;
	ms->info[ms->max] = ms->info[i] ;
	ms->depth[ms->max] = ms->depth[i] ;
      }
  fprintf (stderr, "  pruned Moshset from %d to %d with min %d <= depth < max %d\n",
	   N, ms->max, min, max) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x10d0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
ja 0x55f2
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
cmpl -0xc(%rbp), %eax
jl 0x55e2
cmpl $0x0, -0x10(%rbp)
je 0x5583
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
cmpl -0x10(%rbp), %eax
jge 0x55e2
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
movl $0x1, %edx
callq 0x53d0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x14(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %ecx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
movw (%rax,%rcx,2), %dx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %ecx
movw %dx, (%rax,%rcx,2)
jmp 0x55e4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5549
movq 0x79ff(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
movl -0xc(%rbp), %r8d
movl -0x10(%rbp), %r9d
leaq 0x45bf(%rip), %rsi      # 0x9bd4
movb $0x0, %al
callq 0x1120
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshset.c
// Function: moshsetWrite
void moshsetWrite (Moshset *ms, FILE *f)
{ if (fwrite ("MSHSTv1",8,1,f) != 1) die ("failed to write moshset header") ;
  if (fwrite (&ms->tableBits,sizeof(int),1,f) != 1) die ("failed to write bits") ;
  U32 size = ms->max+1 ; if (fwrite (&size,sizeof(U32),1,f) != 1) die ("failed to write size") ;
  seqhashWrite (ms->hasher, f) ;
  if (fwrite (ms->index,sizeof(U32),ms->tableSize,f) != ms->tableSize) die ("fail write index") ;
  if (fwrite (ms->value,sizeof(U64),ms->max+1,f) != ms->max+1) die ("failed to write value") ;
  if (fwrite (ms->depth,sizeof(U16),ms->max+1,f) != ms->max+1) die ("failed to write depth") ;
  if (fwrite (ms->info,sizeof(U8),ms->max+1,f) != ms->max+1) die ("failed to write info") ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
leaq 0x45c7(%rip), %rdi      # 0x9c12
movl $0x8, %esi
movl $0x1, %edx
callq 0x1220
cmpq $0x1, %rax
je 0x566e
leaq 0x45b3(%rip), %rdi      # 0x9c1a
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1220
cmpq $0x1, %rax
je 0x569d
leaq 0x45a3(%rip), %rdi      # 0x9c39
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x1220
cmpq $0x1, %rax
je 0x56d5
leaq 0x4580(%rip), %rdi      # 0x9c4e
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x44b0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rcx
movl $0x4, %esi
callq 0x1220
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x571b
leaq 0x454f(%rip), %rdi      # 0x9c63
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movq -0x10(%rbp), %rcx
movl $0x8, %esi
callq 0x1220
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
je 0x575e
leaq 0x451d(%rip), %rdi      # 0x9c74
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movq -0x10(%rbp), %rcx
movl $0x2, %esi
callq 0x1220
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
je 0x57a1
leaq 0x44f0(%rip), %rdi      # 0x9c8a
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x1220
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
je 0x57e4
leaq 0x44c3(%rip), %rdi      # 0x9ca0
movb $0x0, %al
callq 0x8180
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshset.c
// Function: moshsetRead
Moshset *moshsetRead (FILE *f)
{ char name[8] ;
  if (fread (name,8,1,f) != 1) die ("failed to read moshset header") ;
  if (strcmp (name, "MSHSTv1")) die ("bad reference header") ;
  int bits ; if (fread (&bits,sizeof(int),1,f) != 1) die ("failed to read bits") ;
  U32 size ; if (fread (&size,sizeof(U32),1,f) != 1) die ("failed to read size") ;
  Seqhash *sh = seqhashRead (f) ;
  Moshset *ms = moshsetCreate (sh, bits, size) ;
  if (fread (ms->index,sizeof(U32),ms->tableSize,f) != ms->tableSize) die ("failed read index") ;
  if (fread (ms->value,sizeof(U64),size,f) != size) die ("failed to read value") ;
  if (fread (ms->depth,sizeof(U16),size,f) != size) die ("failed to read depth") ;
  if (fread (ms->info,sizeof(U8),size,f) != size) die ("failed to read info") ;
  ms->max = size - 1 ;
  return ms ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x5827
leaq 0x4495(%rip), %rdi      # 0x9cb5
movb $0x0, %al
callq 0x8180
leaq -0x10(%rbp), %rdi
leaq 0x43e0(%rip), %rsi      # 0x9c12
callq 0x1100
cmpl $0x0, %eax
je 0x584a
leaq 0x4490(%rip), %rdi      # 0x9cd3
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rcx
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x5875
leaq 0x447a(%rip), %rdi      # 0x9ce8
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x58a0
leaq 0x4463(%rip), %rdi      # 0x9cfc
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rdi
callq 0x4520
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x5030
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x4, %esi
callq 0x1070
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x58f6
leaq 0x4421(%rip), %rdi      # 0x9d10
movb $0x0, %al
callq 0x8180
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0x18(%rbp), %eax
movl %eax, %edx
movq -0x8(%rbp), %rcx
movl $0x8, %esi
callq 0x1070
movl -0x18(%rbp), %ecx
cmpq %rcx, %rax
je 0x5927
leaq 0x4402(%rip), %rdi      # 0x9d22
movb $0x0, %al
callq 0x8180
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x18(%rbp), %eax
movl %eax, %edx
movq -0x8(%rbp), %rcx
movl $0x2, %esi
callq 0x1070
movl -0x18(%rbp), %ecx
cmpq %rcx, %rax
je 0x5958
leaq 0x43e6(%rip), %rdi      # 0x9d37
movb $0x0, %al
callq 0x8180
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0x18(%rbp), %eax
movl %eax, %edx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x1070
movl -0x18(%rbp), %ecx
cmpq %rcx, %rax
je 0x5989
leaq 0x43ca(%rip), %rdi      # 0x9d4c
movb $0x0, %al
callq 0x8180
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshset.c
// Function: moshsetMerge
BOOL moshsetMerge (Moshset *ms1, Moshset *ms2)
{
  U32 i, index ;
  /* first check that the hashers are identical */
  Seqhash *sh1 = ms1->hasher, *sh2 = ms2->hasher ;
  if (sh1->w != sh2->w || sh1->k != sh2->k || sh1->factor1 != sh2->factor1) return FALSE ;
  /* then pass through ms2 adding into ms1 */
  for (i = 1 ; i <= ms2->max ; ++i)
    { index = moshsetIndexFind (ms1, ms2->value[i], TRUE) ;
      U32 d = ms1->depth[index] + (U32) ms2->depth[i] ; if (d > U16MAX) d = U16MAX ;
      ms1->depth[index] = d ;
      int c = msCopy(ms1,index) + msCopy(ms2,i) ; if (c > 3) c = 3 ;
      ms1->info[index] &= 0x3 ; ms1->info[index] |= c ;
    }
  return TRUE ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x59f6
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x59f6
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x59ff
movb $0x0, -0x1(%rbp)
jmp 0x5aee
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x40(%rcx), %eax
ja 0x5aea
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
movl $0x1, %edx
callq 0x53d0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x20(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl -0x1c(%rbp), %edx
movzwl (%rcx,%rdx,2), %ecx
addl %ecx, %eax
movl %eax, -0x34(%rbp)
cmpl $0xffff, -0x34(%rbp)    # imm = 0xFFFF
jbe 0x5a69
movl $0xffff, -0x34(%rbp)    # imm = 0xFFFF
movl -0x34(%rbp), %eax
movw %ax, %dx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x20(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x5b00
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5b00
movl %eax, %ecx
movl -0x3c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x38(%rbp)
cmpl $0x3, -0x38(%rbp)
jle 0x5ab0
movl $0x3, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x20(%rbp), %ecx
movzbl (%rax,%rcx), %edx
andl $0x3, %edx
movb %dl, (%rax,%rcx)
movl -0x38(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x20(%rbp), %ecx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5a06
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/hash.c
// Function: hashCreate
HASH hashCreate (int n)
{
  TRUE_HASH *h = (TRUE_HASH *) myalloc (sizeof (TRUE_HASH)) ;

  if (n < 64) n = 64 ;
  --n ;
  h->nbits = 1 ;	       /* make room, be twice as big as needed */
  while (n >>= 1) ++h->nbits ; /* number of left most bit + 1 */
  h->mask = (1 << h->nbits) - 1 ;
  h->guard = (1 << (h->nbits - 1)) ;
  h->keys = (int*) myalloc (sizeof(int)*(1 << h->nbits)) ;
  memset (h->keys, 0, sizeof(int)*(1 << h->nbits)) ;
  h->values = (int*) myalloc (sizeof(int)*(1 << h->nbits)) ;
  h->n = 0 ;
  h->freeList = arrayCreate (32, int) ;
  h->nFree = 0 ;
  ++nCreated ;
  return (HASH) h ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x30, %edi
callq 0x8260
movq %rax, -0x10(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0x5de6
movl $0x40, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movl -0x4(%rbp), %eax
sarl %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
je 0x5e13
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x5df9
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x8260
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x10d0
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x8260
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x20, %edi
movl $0x4, %esi
callq 0x72a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movl 0x847a(%rip), %eax      # 0xe360
addl $0x1, %eax
movl %eax, 0x8471(%rip)      # 0xe360
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/hash.c
// Function: hashDestroy
void hashDestroy (HASH hx)
{
  TRUE_HASH *h = (TRUE_HASH*) hx ;
  free (h->keys) ;
  free (h->values) ;
  arrayDestroy (h->freeList) ;
  free (h) ;
  ++nDestroyed ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x74a0
movq -0x10(%rbp), %rdi
callq 0x1040
movl 0x841a(%rip), %eax      # 0xe364
addl $0x1, %eax
movl %eax, 0x8411(%rip)      # 0xe364
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/hash.c
// Function: hashClear
void hashClear (HASH hx)
{ 
  TRUE_HASH *h = (TRUE_HASH*) hx ;
  h->n = 0 ;
  memset (h->keys, 0, sizeof(int)*(1 << h->nbits)) ;
  h->freeList = arrayReCreate (h->freeList, 32, int) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x10d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x20, %esi
movl $0x4, %edx
callq 0x7370
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/hash.c
// Function: hashFind
int hashFind (HASH hx, HASHKEY k)
/* if found, returns index, else returns 0 */
{
  TRUE_HASH *h = (TRUE_HASH*) hx ;
  long int hash, delta = 0 ;

  HASH_FUNC(k) ;
  while (TRUE)
    if (h->keys[hash] == k.i)
      { nFound++ ;
	return h->values[hash] ;
      }
    else if (!h->keys[hash])
      { nNotFound++ ;
	return 0 ;
      }
    else 
      { nBounced++ ;
	if (!delta) DELTA(k) ;
	hash = (hash + delta) & h->mask ;
      }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movl $0xc, -0x34(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x38(%rbp)
movslq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x38(%rbp), %eax
sarl $0x5, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x34(%rbp)
cmpl $0x0, %eax
je 0x6032
movslq -0x38(%rbp), %rax
xorq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x38(%rbp), %eax
sarl $0x5, %eax
movl %eax, -0x38(%rbp)
jmp 0x600b
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
andq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
cmpq -0x10(%rbp), %rax
jne 0x6080
movq 0x830a(%rip), %rax      # 0xe368
addq $0x1, %rax
movq %rax, 0x82ff(%rip)      # 0xe368
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x6142
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x60b0
movq 0x82d7(%rip), %rax      # 0xe370
addq $0x1, %rax
movq %rax, 0x82cc(%rip)      # 0xe370
movl $0x0, -0x4(%rbp)
jmp 0x6142
movq 0x82c1(%rip), %rax      # 0xe378
addq $0x1, %rax
movq %rax, 0x82b6(%rip)      # 0xe378
cmpq $0x0, -0x30(%rbp)
jne 0x6125
movl $0x9, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x40(%rbp)
movslq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x40(%rbp), %eax
sarl $0x7, %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x610f
movslq -0x40(%rbp), %rax
xorq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x40(%rbp), %eax
sarl $0x7, %eax
movl %eax, -0x40(%rbp)
jmp 0x60e8
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
andq %rcx, %rax
orq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
andq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x613d
jmp 0x6041
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/hash.c
// Function: hashRemove
BOOL hashRemove (HASH hx, HASHKEY k)
{
  TRUE_HASH *h = (TRUE_HASH*) hx ;
  long int hash, delta = 0 ;

  HASH_FUNC(k) ;
  while (TRUE)
    if (h->keys[hash] == k.i)
      { h->keys[hash] = REMOVED ;
	array(h->freeList, ++h->nFree, int) = h->values[hash] ;
	++nFound ;
	return TRUE ;
      }
    else if (!h->keys[hash])
      { nNotFound++ ;
	return FALSE ;
      }
    else 
      { nBounced++ ;
	if (!delta) DELTA(k) ;
	hash = (hash + delta) & h->mask ;
      }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movl $0xc, -0x34(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x38(%rbp)
movslq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x38(%rbp), %eax
sarl $0x5, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x34(%rbp)
cmpl $0x0, %eax
je 0x66a6
movslq -0x38(%rbp), %rax
xorq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x38(%rbp), %eax
sarl $0x5, %eax
movl %eax, -0x38(%rbp)
jmp 0x667f
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
andq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
cmpq -0x10(%rbp), %rax
jne 0x672a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x28(%rax), %esi
addl $0x1, %esi
movl %esi, 0x28(%rax)
callq 0x7700
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
movq 0x7c52(%rip), %rax      # 0xe368
addq $0x1, %rax
movq %rax, 0x7c47(%rip)      # 0xe368
movb $0x1, -0x1(%rbp)
jmp 0x67e9
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x6757
movq 0x7c2d(%rip), %rax      # 0xe370
addq $0x1, %rax
movq %rax, 0x7c22(%rip)      # 0xe370
movb $0x0, -0x1(%rbp)
jmp 0x67e9
movq 0x7c1a(%rip), %rax      # 0xe378
addq $0x1, %rax
movq %rax, 0x7c0f(%rip)      # 0xe378
cmpq $0x0, -0x30(%rbp)
jne 0x67cc
movl $0x9, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x40(%rbp)
movslq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x40(%rbp), %eax
sarl $0x7, %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x67b6
movslq -0x40(%rbp), %rax
xorq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x40(%rbp), %eax
sarl $0x7, %eax
movl %eax, -0x40(%rbp)
jmp 0x678f
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
andq %rcx, %rax
orq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
andq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x67e4
jmp 0x66b5
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/hash.c
// Function: hashNextKeyValue
int hashNextKeyValue (HASH hx, HASHKEY *kp, int *ip)
{
  TRUE_HASH *h = (TRUE_HASH*) hx ;
  int size = 1 << h->nbits ;

  while (++h->iter < size)
    if (h->keys[h->iter] && h->keys[h->iter] != REMOVED)
      { kp->i = h->keys[h->iter] ;
	*ip = h->values[h->iter] ;
	return *ip ;
      }

  return 0 ;			/* done if reached end of table */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl 0x2c(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rcx)
cmpl -0x2c(%rbp), %eax
jge 0x68c7
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movslq 0x2c(%rcx), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x68c5
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movslq 0x2c(%rcx), %rcx
cmpl $0x1, (%rax,%rcx,4)
je 0x68c5
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movslq 0x2c(%rcx), %rcx
movslq (%rax,%rcx,4), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movslq 0x2c(%rcx), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x68ce
jmp 0x6848
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/hash.c
// Function: hashStats
void hashStats (void)
{
  printf ("%d hashes (%d created, %d destroyed)\n", 
	  nCreated - nDestroyed, nCreated, nDestroyed) ;
  printf ("%ld added, %ld found, %ld bounced, %ld not found\n",
	  nAdded, nFound, nBounced, nNotFound) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x7a56(%rip), %esi      # 0xe360
subl 0x7a54(%rip), %esi      # 0xe364
movl 0x7a4a(%rip), %edx      # 0xe360
movl 0x7a48(%rip), %ecx      # 0xe364
leaq 0x34bf(%rip), %rdi      # 0x9de2
movb $0x0, %al
callq 0x10b0
movq 0x7a4f(%rip), %rsi      # 0xe380
movq 0x7a30(%rip), %rdx      # 0xe368
movq 0x7a39(%rip), %rcx      # 0xe378
movq 0x7a2a(%rip), %r8       # 0xe370
leaq 0x34bb(%rip), %rdi      # 0x9e08
movb $0x0, %al
callq 0x10b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/dict.c
// Function: dictCreate
DICT *dictCreate (int size)
{
  DICT *dict = (DICT*) mycalloc (1, sizeof(DICT)) ;

  for (dict->dim = 10, dict->size = 1024 ; dict->size < size ; ++dict->dim, dict->size *= 2) ;
  dict->table = (int*) mycalloc (dict->size, sizeof(int)) ;
  dict->names = (char**) mycalloc (dict->size/2, sizeof(char*)) ;
  return dict ; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x82b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0xa, 0x14(%rax)
movq -0x10(%rbp), %rax
movl $0x400, 0x18(%rax)      # imm = 0x400
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x4(%rbp), %eax
jge 0x69bd
jmp 0x69a2
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
shll %ecx
movl %ecx, 0x18(%rax)
jmp 0x6994
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rdi
movl $0x4, %esi
callq 0x82b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movslq %eax, %rdi
movl $0x8, %esi
callq 0x82b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/dict.c
// Function: dictDestroy
void dictDestroy (DICT *dict)
{
  int i ;
  for (i = 1 ; i <= dict->max ; ++i) free (dict->names[i]) ;
  free (dict->names) ;
  free (dict->table) ;
  free (dict) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jg 0x6a4e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6a23
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/dict.c
// Function: dictWrite
BOOL dictWrite (DICT *dict, FILE *f)
{
  if (fwrite (&dict->dim,sizeof(int),1,f) != 1) return FALSE ;
  if (fwrite (&dict->max,sizeof(int),1,f) != 1) return FALSE ;
  if (fwrite (dict->table,sizeof(int),dict->size,f) != dict->size) return FALSE ;
  if (fwrite (dict->names,sizeof(char*),dict->max+1,f) != dict->max+1) return FALSE ;
  int i ;
  for (i = 1 ; i <= dict->max ; ++i)
    { int len = strlen(dict->names[i]) ;
      if (fwrite (&len,sizeof(int),1,f) != 1) return FALSE ;
      if (fwrite (dict->names[i],1,len,f) != len) return FALSE ;
    }
  return TRUE ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x14, %rdi
movq -0x18(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1220
cmpq $0x1, %rax
je 0x6aba
movb $0x0, -0x1(%rbp)
jmp 0x6be6
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1220
cmpq $0x1, %rax
je 0x6ae4
movb $0x0, -0x1(%rbp)
jmp 0x6be6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x18(%rax), %rdx
movq -0x18(%rbp), %rcx
movl $0x4, %esi
callq 0x1220
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
cmpq %rcx, %rax
je 0x6b18
movb $0x0, -0x1(%rbp)
jmp 0x6be6
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdx
movq -0x18(%rbp), %rcx
movl $0x8, %esi
callq 0x1220
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
je 0x6b55
movb $0x0, -0x1(%rbp)
jmp 0x6be6
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jg 0x6be2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10a0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
leaq -0x20(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x1220
cmpq $0x1, %rax
je 0x6ba2
movb $0x0, -0x1(%rbp)
jmp 0x6be6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movslq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x1220
movslq -0x20(%rbp), %rcx
cmpq %rcx, %rax
je 0x6bd2
movb $0x0, -0x1(%rbp)
jmp 0x6be6
jmp 0x6bd4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6b5c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/dict.c
// Function: dictRead
DICT *dictRead (FILE *f)
{
  int dim ; if (fread (&dim,sizeof(int),1,f) != 1) return 0 ;
  DICT *dict = dictCreate (1 << dim) ;
  if (fread (&dict->max,sizeof(int),1,f) != 1) return 0 ;
  if (fread (dict->table,sizeof(int),dict->size,f) != dict->size) return 0 ;
  if (fread (dict->names,sizeof(char*),dict->max+1,f) != dict->max+1) return 0 ;
  int i ;
  for (i = 1 ; i <= dict->max ; ++i)
    { int len ;
      if (fread (&len,sizeof(int),1,f) != 1) return 0 ;
      dict->names[i] = new0 (len+1, char) ;
      if (fread (dict->names[i],1,len,f) != len) return 0 ;
    }
  return dict ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x6c26
movq $0x0, -0x8(%rbp)
jmp 0x6d8f
movl -0x14(%rbp), %ecx
movl $0x1, %edi
shll %cl, %edi
callq 0x6960
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x6c67
movq $0x0, -0x8(%rbp)
jmp 0x6d8f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movslq 0x18(%rax), %rdx
movq -0x10(%rbp), %rcx
movl $0x4, %esi
callq 0x1070
movq -0x20(%rbp), %rcx
movslq 0x18(%rcx), %rcx
cmpq %rcx, %rax
je 0x6c9f
movq $0x0, -0x8(%rbp)
jmp 0x6d8f
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdx
movq -0x10(%rbp), %rcx
movl $0x8, %esi
callq 0x1070
movq -0x20(%rbp), %rcx
movl 0x10(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
je 0x6ce0
movq $0x0, -0x8(%rbp)
jmp 0x6d8f
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jg 0x6d87
movq -0x10(%rbp), %rcx
leaq -0x28(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x6d1e
movq $0x0, -0x8(%rbp)
jmp 0x6d8f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x82b0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movslq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x1070
movslq -0x28(%rbp), %rcx
cmpq %rcx, %rax
je 0x6d77
movq $0x0, -0x8(%rbp)
jmp 0x6d8f
jmp 0x6d79
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6ce7
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/dict.c
// Function: dictFind
int dictFind (DICT *dict, char *s, int *ip)
{
  int i, x, d ;

  if (!dict) die ("dictAdd received null dict\n") ;
  if (!s) die ("dictAdd received null string\n") ;

  x = hashString (s, dict->dim, 0) ;
  if (!(i = dict->table[x]))
    { newPos = x ; 
      return 0 ; 
    }
  else if (!strcmp (s, dict->names[i]))
    { if (ip) *ip = i-1 ; 
      return 1 ; 
    }
  else
    { d = hashString (s, dict->dim, 1) ;
      while (1)
	{ x = (x + d) & ((1 << dict->dim) - 1) ;
	  if (!(i = dict->table[x]))
	    { newPos = x ; 
	      return 0 ; 
	    }
	  else if (!strcmp (s, dict->names[i]))
	    { if (ip) *ip = i-1 ; 
	      return 1 ; 
	    }
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6dc9
leaq 0x3086(%rip), %rdi      # 0x9e48
movb $0x0, %al
callq 0x8180
cmpq $0x0, -0x18(%rbp)
jne 0x6dde
leaq 0x308d(%rip), %rdi      # 0x9e64
movb $0x0, %al
callq 0x8180
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
xorl %edx, %edx
callq 0x6f10
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jne 0x6e1f
movl -0x28(%rbp), %eax
movl %eax, 0x7575(%rip)      # 0xe388
movl $0x0, -0x4(%rbp)
jmp 0x6efa
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1100
cmpl $0x0, %eax
jne 0x6e5b
cmpq $0x0, -0x20(%rbp)
je 0x6e4f
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6efa
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
movl $0x1, %edx
callq 0x6f10
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
addl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jne 0x6eba
movl -0x28(%rbp), %eax
movl %eax, 0x74d7(%rip)      # 0xe388
movl $0x0, -0x4(%rbp)
jmp 0x6efa
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1100
cmpl $0x0, %eax
jne 0x6ef3
cmpq $0x0, -0x20(%rbp)
je 0x6eea
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6efa
jmp 0x6ef5
jmp 0x6e73
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/dict.c
// Function: hashString
static int hashString (char *cp, int n, int isDiff)
{
  int i ;
  unsigned int j, x = 0 ;
  int rotate = isDiff ? 21 : 13 ;
  int leftover = 8 * sizeof(int) - rotate ;

  while (*cp)
    x = (*cp++) ^ ((x >> leftover) | (x << rotate)) ;

  for (j = x, i = n ; i < sizeof(int) ; i += n)
    j ^= (x >> i) ;
  j &= (1 << n) - 1 ;

  if (isDiff)
    j |= 1 ;

  return j ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x10(%rbp), %edx
movl $0xd, %eax
movl $0x15, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x20(%rbp)
movslq -0x20(%rbp), %rcx
movl $0x20, %eax
subq %rcx, %rax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6f84
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
movl -0x1c(%rbp), %edx
movl -0x24(%rbp), %ecx
shrl %cl, %edx
movl %edx, -0x28(%rbp)
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
shll %cl, %edx
movl -0x28(%rbp), %ecx
orl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6f4a
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x4, %rax
jae 0x6fb3
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
shrl %cl, %eax
xorl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x6f90
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
andl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x6fd5
movl -0x18(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/dict.c
// Function: remap
static void* remap (void *old, int oldSize, int newSize)
{
  void* new = mycalloc (newSize, 1) ;
  memcpy (new, old, oldSize) ;
  free (old) ;
  return new ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movslq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x82b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x1140
movq -0x8(%rbp), %rdi
callq 0x1040
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/array.c
// Function: uArrayCreate
Array uArrayCreate (int n, int size)
{
  Array a = (Array) mycalloc (1, sizeof (struct ArrayStruct)) ;
  static int isFirst ;

  if (isFirst)
    { isFirst = 0 ;
#ifdef ARRAY_REPORT
      if (ARRAY_REPORT_MAX) reportArray = arrayCreate (512, Array) ;
#endif
    }
  if (size <= 0) die ("negative size %d in uArrayCreate", size) ;
  if (n < 1)
    n = 1 ;
  totalAllocatedMemory += n * size ;

  a->magic = ARRAY_MAGIC ;
  a->base = mycalloc (n, size) ;
  a->dim = n ;
  a->max = 0 ;
  a->size = size ;
  ++totalNumberActive ;
#ifdef ARRAY_REPORT
  a->id = ++totalNumberCreated ;
  if (reportArray)
    { if (a->id < ARRAY_REPORT_MAX)
	array (reportArray, a->id, Array) = a ;
      else
	{ arrayDestroy (reportArray) ;
	  reportArray = 0 ;
	}
    }
#endif
  return a ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x82b0
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x70c8(%rip)      # 0xe390
je 0x72d4
movl $0x0, 0x70bc(%rip)      # 0xe390
cmpl $0x0, -0x8(%rbp)
jg 0x72eb
movl -0x8(%rbp), %esi
leaq 0x2b9e(%rip), %rdi      # 0x9e82
movb $0x0, %al
callq 0x8180
cmpl $0x1, -0x4(%rbp)
jge 0x72f8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
imull -0x8(%rbp), %eax
addl 0x708f(%rip), %eax      # 0xe394
movl %eax, 0x7089(%rip)      # 0xe394
movq -0x10(%rbp), %rax
movl $0x881502, (%rax)       # imm = 0x881502
movslq -0x4(%rbp), %rdi
movslq -0x8(%rbp), %rsi
callq 0x82b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movl 0x7046(%rip), %eax      # 0xe398
addl $0x1, %eax
movl %eax, 0x703d(%rip)      # 0xe398
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/array.c
// Function: uArrayReCreate
Array uArrayReCreate (Array a, int n, int size)
{
  if (!arrayExists(a))
    return  uArrayCreate (n, size) ;

  if (a->size != size)
    die ("type size mismatch in arrayReCreate: size %d != a->size %d", size, a->size) ;

  if (n < 1) n = 1 ;

  if (a->dim < n || (a->dim - n)*size > (1 << 20) ) /* free if save > 1 MB */
    { totalAllocatedMemory -= a->dim * size ;
      free (a->base) ;
      a->dim = n ;
      totalAllocatedMemory += a->dim * size ;
      /* base-mem isn't alloc'd on handle, it's free'd by finalisation */
      a->base = mycalloc (n, size) ;
    }
  else
    memset (a->base, 0, n*size) ;

  a->max = 0 ;
  return a ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7395
movq -0x10(%rbp), %rax
cmpl $0x881502, (%rax)       # imm = 0x881502
je 0x73a9
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x72a0
movq %rax, -0x8(%rbp)
jmp 0x7488
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x18(%rbp), %eax
je 0x73cd
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
leaq 0x2add(%rip), %rdi      # 0x9ea3
movb $0x0, %al
callq 0x8180
cmpl $0x1, -0x14(%rbp)
jge 0x73da
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rbp), %eax
jl 0x73fb
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
subl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
cmpl $0x100000, %eax         # imm = 0x100000
jle 0x745c
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
imull -0x18(%rbp), %ecx
movl 0x6f88(%rip), %eax      # 0xe394
subl %ecx, %eax
movl %eax, 0x6f80(%rip)      # 0xe394
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
imull -0x18(%rbp), %eax
addl 0x6f58(%rip), %eax      # 0xe394
movl %eax, 0x6f52(%rip)      # 0xe394
movslq -0x14(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x82b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x7475
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x10d0
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/array.c
// Function: arrayDestroy
void arrayDestroy (Array a)
{
  if (!arrayExists (a))
    die ("arrayDestroy called on bad array %lx", (long unsigned int) a) ;

  totalAllocatedMemory -= a->dim * a->size ;
  totalNumberActive-- ;
#ifdef ARRAY_REPORT
  if (reportArray)
    arr(reportArray, a->id, Array) = 0 ;
#endif
  a->magic = 0 ;
  free (a->base) ;
  free (a) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x74bf
movq -0x8(%rbp), %rax
cmpl $0x881502, (%rax)       # imm = 0x881502
je 0x74d1
movq -0x8(%rbp), %rsi
leaq 0x2a14(%rip), %rdi      # 0x9ede
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x14(%rax), %ecx
movl 0x6eae(%rip), %eax      # 0xe394
subl %ecx, %eax
movl %eax, 0x6ea6(%rip)      # 0xe394
movl 0x6ea4(%rip), %eax      # 0xe398
addl $-0x1, %eax
movl %eax, 0x6e9b(%rip)      # 0xe398
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/array.c
// Function: arrayCopy
Array arrayCopy (Array a) 
{
  Array new ;

  if (!arrayExists (a)) 
    die ("arrayCopy called on bad array %lx", (long unsigned int) a) ;
 
  new = uArrayCreate (a->dim, a->size) ;
  memcpy (new->base, a->base, a->dim * a->size) ;
  new->max = a->max ;
  return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x754f
movq -0x8(%rbp), %rax
cmpl $0x881502, (%rax)       # imm = 0x881502
je 0x7561
movq -0x8(%rbp), %rsi
leaq 0x29a9(%rip), %rdi      # 0x9f03
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x72a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x14(%rcx), %eax
movslq %eax, %rdx
callq 0x1140
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)