LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/dict.c
// Function: dictAdd
int dictAdd (DICT *dict, char *s, int *ip)
{
  int i, x ;

  if (dictFind (dict, s, ip)) return 0 ;

  i = ++dict->max ;
  dict->table[newPos] = i ;
  dict->names[i] = (char*) myalloc (strlen(s) + 1) ;
  strcpy (dict->names[i], s) ;
  if (ip) *ip = i-1 ;

  if (dict->max > 0.3 * dict->size) /* double table size and remap */
    { int *newTable ;
      ++dict->dim ; dict->size *= 2 ;
      dict->names = (char**) remap (dict->names, (dict->max+1)*sizeof(char*), (dict->size/2)*sizeof(char*)) ;
      newTable = (int*) mycalloc (dict->size, sizeof(int)) ;
      for (i = 1 ; i <= dict->max ; ++i)
	{ s = dict->names[i] ;
	  x = hashString (s, dict->dim, 0) ;
	  if (!newTable[x])
	    newTable[x] = i ;
	  else
	    { int d = hashString (s, dict->dim, 1) ;
	      while (1)
		{ x = (x + d) & ((1 << dict->dim) - 1) ;
		  if (!newTable[x])
		    { newTable[x] = i ; break ; }
		}
	    }
	}
      free (dict->table) ; dict->table = newTable ;
    }

  return 1 ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x4ee9
xorl %edx, %edx
testl %eax, %eax
jne 0x51e6
movslq 0x10(%rbx), %r12
leaq 0x1(%r12), %rax
movl %eax, 0x10(%rbx)
movq 0x8(%rbx), %rcx
movslq 0x62d2(%rip), %rdx      # 0xb380
movl %eax, (%rcx,%rdx,4)
movq %r15, %rdi
callq 0x10a0
leaq 0x1(%rax), %rdi
callq 0x5a3c
movq (%rbx), %rcx
movq %rax, 0x8(%rcx,%r12,8)
movq (%rbx), %rax
movq 0x8(%rax,%r12,8), %rdi
movq %r15, %rsi
callq 0x1060
testq %r14, %r14
je 0x50e2
movl %r12d, (%r14)
movl 0x10(%rbx), %ecx
movl 0x18(%rbx), %eax
cvtsi2sd %ecx, %xmm0
cvtsi2sd %eax, %xmm1
mulsd 0x1d68(%rip), %xmm1     # 0x6e60
movl $0x1, %edx
ucomisd %xmm1, %xmm0
jbe 0x51e6
incl 0x14(%rbx)
leal (%rax,%rax), %edx
movl %edx, 0x18(%rbx)
movq (%rbx), %r14
leal 0x8(,%rcx,8), %r12d
shll $0x3, %eax
movslq %eax, %rdi
movl $0x1, %ebp
movl $0x1, %esi
callq 0x5a64
movq %rax, %r15
movslq %r12d, %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1140
movq %r14, %rdi
callq 0x1040
movq %r15, (%rbx)
movslq 0x18(%rbx), %rdi
movl $0x4, %esi
callq 0x5a64
movq %rax, %r14
cmpl $0x0, 0x10(%rbx)
jle 0x51d4
movq (%rbx), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax,%rbp,8), %r13
movl 0x14(%rbx), %r12d
movq %r13, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x500b
movl %eax, %r15d
cltq
cmpl $0x0, (%r14,%rax,4)
je 0x51be
movq %r13, %rdi
movl %r12d, %esi
movl $0x1, %edx
callq 0x500b
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %r12d, %ecx
shll %cl, %edx
notl %edx
addl %eax, %r15d
andl %edx, %r15d
cmpl $0x0, (%r14,%r15,4)
jne 0x51ab
leaq (%r14,%r15,4), %rax
jmp 0x51c2
leaq (%r14,%rax,4), %rax
movl %ebp, (%rax)
leaq 0x1(%rbp), %rax
movslq 0x10(%rbx), %rcx
cmpq %rcx, %rbp
movq %rax, %rbp
jl 0x516a
movq 0x8(%rbx), %rdi
callq 0x1040
movq %r14, 0x8(%rbx)
movl $0x1, %edx
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl $0x1, %edi
movl $0x20, %esi
callq 0x5a64
movq %rax, %r14
testl %ebx, %ebx
jg 0x5235
leaq 0x1c76(%rip), %rdi      # 0x6ea2
movl %ebx, %esi
xorl %eax, %eax
callq 0x5974
cmpl $0x2, %ebp
movl $0x1, %r15d
cmovgel %ebp, %r15d
movl %r15d, %eax
imull %ebx, %eax
addl %eax, 0x6136(%rip)      # 0xb384
movl $0x881502, (%r14)       # imm = 0x881502
movslq %ebx, %rsi
movq %r15, %rdi
callq 0x5a64
movq %rax, 0x8(%r14)
movl %r15d, 0x10(%r14)
movl $0x0, 0x18(%r14)
movl %ebx, 0x14(%r14)
incl 0x610e(%rip)            # 0xb388
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
testq %rdi, %rdi
je 0x5317
movq %rdi, %rbx
cmpl $0x881502, (%rdi)       # imm = 0x881502
jne 0x5317
movl 0x14(%rbx), %edx
cmpl %ebp, %edx
je 0x52bb
leaq 0x1c11(%rip), %rdi      # 0x6ec3
movl %ebp, %esi
xorl %eax, %eax
callq 0x5974
cmpl $0x2, %r14d
movl $0x1, %r15d
cmovgel %r14d, %r15d
movl 0x10(%rbx), %eax
movl %eax, %ecx
subl %r15d, %ecx
jl 0x52de
imull %ebp, %ecx
cmpl $0x100001, %ecx         # imm = 0x100001
jl 0x532b
imull %ebp, %eax
movl 0x609c(%rip), %r14d     # 0xb384
subl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x1040
movl %r15d, 0x10(%rbx)
movl %r15d, %edi
imull %ebp, %r15d
addl %r14d, %r15d
movl %r15d, 0x607b(%rip)     # 0xb384
movslq %ebp, %rsi
callq 0x5a64
movq %rax, 0x8(%rbx)
jmp 0x533d
movl %r14d, %edi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5204
movq 0x8(%rbx), %rdi
imull %ebp, %r15d
movslq %r15d, %rdx
xorl %esi, %esi
callq 0x10d0
movl $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5363
cmpl $0x881502, (%rbx)       # imm = 0x881502
je 0x5374
leaq 0x1b94(%rip), %rdi      # 0x6efe
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5974
movl 0x14(%rbx), %eax
imull 0x10(%rbx), %eax
subl %eax, 0x6003(%rip)      # 0xb384
decl 0x6001(%rip)            # 0xb388
movl $0x0, (%rbx)
movq 0x8(%rbx), %rdi
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x53b3
cmpl $0x881502, (%rbx)       # imm = 0x881502
je 0x53c4
leaq 0x1b69(%rip), %rdi      # 0x6f23
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5974
movl 0x10(%rbx), %edi
movl 0x14(%rbx), %esi
callq 0x5204
movq %rax, %r14
movq 0x8(%rax), %rdi
movq 0x8(%rbx), %rsi
movslq 0x10(%rbx), %rax
movslq 0x14(%rbx), %rdx
imulq %rax, %rdx
callq 0x1140
movl 0x18(%rbx), %eax
movl %eax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/array.c
// Function: arrayExtend
void arrayExtend (Array a, int n) 
{
  char *new ;

  if (!arrayExists (a))
    die ("arrayExtend called on bad array %lx", (long unsigned int) a) ;

  if (n < a->dim)
    return ;

  totalAllocatedMemory -= a->dim * a->size ;
  if (a->dim*a->size < 1 << 23)	/* 8MB */
    a->dim *= 2 ;
  else
    a->dim += 1024 + ((1 << 23) / a->size) ;
  if (n >= a->dim)
    a->dim = n + 1 ;

  totalAllocatedMemory += a->dim * a->size ;

  new = mycalloc (a->dim, a->size) ;
  memcpy (new,a->base,a->size*a->max) ;
  free (a->base) ;
  a->base = new ;

  return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5414
cmpl $0x881502, (%rbx)       # imm = 0x881502
je 0x5425
leaq 0x1b2a(%rip), %rdi      # 0x6f45
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5974
movl 0x10(%rbx), %ecx
cmpl %r14d, %ecx
jg 0x54a5
movslq 0x14(%rbx), %rsi
movl %esi, %eax
imull %ecx, %eax
movl 0x5f47(%rip), %r8d      # 0xb384
subl %eax, %r8d
cmpl $0x7fffff, %eax         # imm = 0x7FFFFF
jg 0x544b
addl %ecx, %ecx
jmp 0x545c
movl $0x800000, %eax         # imm = 0x800000
xorl %edx, %edx
idivl %esi
addl %eax, %ecx
addl $0x400, %ecx            # imm = 0x400
leal 0x1(%r14), %eax
cmpl %r14d, %ecx
cmovgl %ecx, %eax
movl %eax, 0x10(%rbx)
movslq %eax, %rdi
imull %esi, %eax
addl %r8d, %eax
movl %eax, 0x5f0c(%rip)      # 0xb384
callq 0x5a64
movq %rax, %r14
movq 0x8(%rbx), %rsi
movslq 0x14(%rbx), %rax
movslq 0x18(%rbx), %rdx
imulq %rax, %rdx
movq %r14, %rdi
callq 0x1140
movq 0x8(%rbx), %rdi
callq 0x1040
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/array.c
// Function: uArray
char *uArray (Array a, int i)
{
#ifdef ARRAY_CHECK
  if (!arrayExists (a)) die ("array() called on bad array %lx", (long unsigned int) a) ;
  if (i < 0) die("referencing array element %d < 0", i) ;
#endif
  if (i >= a->max)
    { if (i >= a->dim) arrayExtend (a,i) ;
      a->max = i+1 ;
    }
  return a->base + i*a->size ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpl %esi, 0x18(%rdi)
jg 0x54d4
cmpl %r14d, 0x10(%rbx)
jg 0x54cd
movq %rbx, %rdi
movl %r14d, %esi
callq 0x53fd
leal 0x1(%r14), %eax
movl %eax, 0x18(%rbx)
movslq 0x14(%rbx), %rcx
movslq %r14d, %rax
imulq %rcx, %rax
addq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/array.c
// Function: uArrCheck
char *uArrCheck (Array a, int i)
{
  if (!arrayExists (a)) die ("array() called on bad array %lx", (long unsigned int) a) ;
  if (i < 0) die("referencing array element %d < 0", i) ;
  if (i >= a->max) die ("referencing array element %d >= max %d", i, a->max) ;

  return a->base + i*a->size ;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5500
cmpl $0x881502, (%rbx)       # imm = 0x881502
je 0x5511
leaq 0x1a62(%rip), %rdi      # 0x6f69
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5974
testl %ebp, %ebp
jns 0x5525
leaq 0x1a6d(%rip), %rdi      # 0x6f89
movl %ebp, %esi
xorl %eax, %eax
callq 0x5974
movl 0x18(%rbx), %edx
cmpl %ebp, %edx
jg 0x553c
leaq 0x1a77(%rip), %rdi      # 0x6faa
movl %ebp, %esi
xorl %eax, %eax
callq 0x5974
movslq 0x14(%rbx), %rcx
movslq %ebp, %rax
imulq %rcx, %rax
addq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/array.c
// Function: uArrayBlock
char    *uArrayBlock (Array a, int i, int n)
{
#ifdef ARRAY_CHECK
  if (!arrayExists (a)) die ("arrayBlock() called on bad array %lx", (long unsigned int)a) ;
  if (i < 0) die ("arrayBlock() referencing array element %d < 0", i) ;
#endif
  if (i+n >= a->max)
    { if (i+n >= a->dim) arrayExtend (a,i+n) ;
      a->max = i+n+1 ;
    }
  return a->base + i*a->size ;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
addl %esi, %r14d
cmpl 0x18(%rdi), %r14d
jl 0x557f
cmpl 0x10(%rbx), %r14d
jl 0x5578
movq %rbx, %rdi
movl %r14d, %esi
callq 0x53fd
incl %r14d
movl %r14d, 0x18(%rbx)
movslq 0x14(%rbx), %rcx
movslq %ebp, %rax
imulq %rcx, %rax
addq 0x8(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/array.c
// Function: arrayRead
Array   arrayRead (FILE *f)
{
  Array a = new (1, struct ArrayStruct) ;
  if (fread (a, sizeof(struct ArrayStruct), 1, f) != 1) return 0 ;
  a->base = myalloc (a->size*a->dim) ;
  if (fread (a->base, a->size, a->dim, f) != a->dim) { free(a) ; return 0 ; }
#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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x20, %edi
callq 0x5a3c
movq %rax, %rbx
movl $0x20, %esi
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rcx
callq 0x1070
cmpq $0x1, %rax
jne 0x5647
movslq 0x14(%rbx), %rax
movslq 0x10(%rbx), %rdi
imulq %rax, %rdi
callq 0x5a3c
movq %rax, 0x8(%rbx)
movslq 0x14(%rbx), %rsi
movslq 0x10(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0x1070
movslq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0x5649
movq %rbx, %rdi
callq 0x1040
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/array.c
// Function: arrayFind
BOOL arrayFind(Array a, void *s, int *ip, ArrayOrder *order)
{
  int ord ;
  int i = 0 , j, k ;

  if (!arrayExists (a)) 
    die ("arrayFind called on bad array %lx", (long unsigned int) a) ;

  j = arrayMax(a) ;
  if (!j || (ord = order(s,uArray(a,0))) < 0)
    { if (ip) *ip = -1 ;
      return FALSE ;
    }   /* not found */

  if (ord == 0)
    { if (ip) *ip = 0 ;
      return TRUE ;
    }

  if ((ord = order(s,uArray(a,--j))) > 0)
    { if (ip) *ip = j ;
      return FALSE ;
    }
  
  if (ord == 0)
    { if (ip) *ip = j ;
      return TRUE ;
    }

  while(TRUE)
    { k = i + ((j-i) >> 1) ; /* midpoint */
      if ((ord = order(s, uArray(a,k))) == 0)
	{ if (ip) *ip = k ;
	  return TRUE ;
	}
      if (ord > 0) i = k ;
      else j = k ;
      if (i == (j-1))
        break ;
    }
  if (ip)
    *ip = i ;
  return FALSE ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
testq %rdi, %rdi
je 0x567a
cmpl $0x881502, (%r13)       # imm = 0x881502
je 0x568b
leaq 0x1950(%rip), %rdi      # 0x6fd1
movq %r13, %rsi
xorl %eax, %eax
callq 0x5974
movl 0x18(%r13), %r14d
testl %r14d, %r14d
je 0x572b
jg 0x56b3
cmpl $0x0, 0x10(%r13)
jg 0x56ab
movq %r13, %rdi
xorl %esi, %esi
callq 0x53fd
movl $0x1, 0x18(%r13)
movq 0x8(%r13), %rsi
movq %r12, %rdi
callq *%r15
testl %eax, %eax
js 0x572b
je 0x574a
decl %r14d
movq %r13, %rdi
movl %r14d, %esi
callq 0x54ad
movq %r12, %rdi
movq %rax, %rsi
callq *%r15
testl %eax, %eax
jg 0x5731
je 0x574d
movq %rbx, (%rsp)
xorl %ebp, %ebp
movl %r14d, %ebx
movl %ebx, %r14d
subl %ebp, %r14d
sarl %r14d
addl %ebp, %r14d
movq %r13, %rdi
movl %r14d, %esi
callq 0x54ad
movq %r12, %rdi
movq %rax, %rsi
callq *%r15
testl %eax, %eax
je 0x5751
jle 0x5719
movl %r14d, %ebp
movl %ebx, %r14d
leal -0x1(%r14), %eax
movl %r14d, %ebx
cmpl %eax, %ebp
jne 0x56ed
xorl %eax, %eax
movl %ebp, %r14d
jmp 0x5753
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
xorl %eax, %eax
testq %rbx, %rbx
je 0x573b
movl %r14d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
movb $0x1, %al
jmp 0x5733
movb $0x1, %al
movq (%rsp), %rbx
jmp 0x5733
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/array.c
// Function: arrayRemove
BOOL arrayRemove (Array a, void * s, int (* order)(const void*, const void*))
{
  int i;

  if (!arrayExists (a))
    die ("arrayRemove called on bad array %lx", (long unsigned int) a) ;

  if (arrayFind(a, s, &i,order))
    {
      /* memcpy would be faster but regions overlap
       * and memcpy is said to fail with some compilers
       */
      char *cp = uArray(a,i), *cq = cp + a->size ;
      int j = (arrayMax(a) - i)*(a->size) ;
      while (j--)
	*cp++ = *cq++ ;

      arrayMax(a)-- ;
      return TRUE ;
    }
  else

    return FALSE ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5778
cmpl $0x881502, (%rbx)       # imm = 0x881502
je 0x5789
leaq 0x1874(%rip), %rdi      # 0x6ff3
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5974
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x5654
testb %al, %al
je 0x57e2
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x54ad
movslq 0x14(%rbx), %rcx
movl 0x18(%rbx), %edx
movl %edx, %esi
subl 0xc(%rsp), %esi
imull %ecx, %esi
testl %esi, %esi
je 0x57d9
addq %rax, %rcx
movl %esi, %edx
xorl %esi, %esi
movb (%rcx,%rsi), %dil
movb %dil, (%rax,%rsi)
incq %rsi
cmpl %esi, %edx
jne 0x57c7
movl 0x18(%rbx), %edx
decl %edx
movl %edx, 0x18(%rbx)
movb $0x1, %al
jmp 0x57e4
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/array.c
// Function: arrayInsert
BOOL arrayInsert(Array a, void * s, int (*order)(const void*, const void*))
{
  int i, j, arraySize;

  if (!arrayExists (a))
    die ("arrayInsert called on bad array %x", (long unsigned int)a) ;

  if (arrayFind(a, s, &i,order))
    return FALSE ;  /* no doubles */
  
  arraySize = arrayMax(a) ;
  j = arraySize + 1 ;

  uArray(a,j-1) ; /* to create space */

	/* avoid memcpy for same reasons as above */
  {
    char *cp, *cq ;
    int k ;
    
    if (arraySize > 0)
      { cp = uArray(a,j - 1) + a->size - 1 ;
	cq = cp - a->size ;
	k = (j - i - 1)*(a->size) ;
	while (k--)
	  *cp-- = *cq-- ;
      }
    
    cp = uArray(a,i+1) ; 
    cq = (char *) s ; 
    k = a->size ;
    while (k--)
      *cp++ = *cq++ ;
  }
  return TRUE ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x580c
cmpl $0x881502, (%r14)       # imm = 0x881502
je 0x581d
leaq 0x1804(%rip), %rdi      # 0x7017
movq %r14, %rsi
xorl %eax, %eax
callq 0x5974
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x5654
testb %al, %al
je 0x5838
xorl %eax, %eax
jmp 0x589f
movl 0x18(%r14), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x54ad
testl %ebp, %ebp
jle 0x5872
movq %r14, %rdi
movl %ebp, %esi
callq 0x54ad
movslq 0x14(%r14), %rcx
subl 0x4(%rsp), %ebp
imull %ecx, %ebp
testl %ebp, %ebp
je 0x5872
decq %rax
movb (%rax), %dl
movb %dl, (%rax,%rcx)
decq %rax
decl %ebp
jne 0x5866
movl 0x4(%rsp), %esi
incl %esi
movq %r14, %rdi
callq 0x54ad
movq %rax, %rcx
movl 0x14(%r14), %edx
movb $0x1, %al
testq %rdx, %rdx
je 0x589f
xorl %esi, %esi
movb (%rbx,%rsi), %dil
movb %dil, (%rcx,%rsi)
incq %rsi
cmpl %esi, %edx
jne 0x5890
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/array.c
// Function: arrayCompress
void arrayCompress(Array a)
{
  int i, j, k , as ;
  char *x, *y, *ab ;

  if (!arrayExists (a))
    die ("arrayCompress called on bad array %lx", (long unsigned int) a) ;

  if (arrayMax(a) < 2)
    return ;

  ab = a->base ; 
  as = a->size ;
  for (i = 1, j = 0 ; i < arrayMax(a) ; i++)
    { x = ab + i * as ; y = ab + j * as ;
      for (k = a->size ; k-- ;)		
	if (*x++ != *y++) 
	  goto different ;
      continue ;
      
    different:
      if (i != ++j)
	{ x = ab + i * as ; y = ab + j * as ;
	  for (k = a->size ; k-- ;)	 
	    *y++ = *x++ ;
	}
    }
  arrayMax(a) = j + 1 ;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x58be
cmpl $0x881502, (%rbx)       # imm = 0x881502
je 0x58cf
leaq 0x1775(%rip), %rdi      # 0x703a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5974
movl 0x18(%rbx), %r8d
cmpl $0x2, %r8d
jl 0x5954
movq 0x8(%rbx), %rcx
movslq 0x14(%rbx), %rdx
leaq (%rcx,%rdx), %rsi
xorl %eax, %eax
movl $0x1, %edi
movl %eax, %r9d
imull %edx, %r9d
movslq %r9d, %r10
addq %rcx, %r10
movl 0x14(%rbx), %r9d
xorl %r11d, %r11d
cmpl %r11d, %r9d
je 0x5941
movb (%rsi,%r11), %bpl
leaq 0x1(%r11), %r14
cmpb (%r10,%r11), %bpl
movq %r14, %r11
je 0x5900
incl %eax
cmpq %rax, %rdi
je 0x5941
movl %eax, %r8d
imull %edx, %r8d
movslq %r8d, %r8
addq %rcx, %r8
xorl %r10d, %r10d
movb (%rsi,%r10), %r11b
movb %r11b, (%r8,%r10)
incq %r10
cmpl %r10d, %r9d
jne 0x592d
movl 0x18(%rbx), %r8d
incq %rdi
movslq %r8d, %r9
addq %rdx, %rsi
cmpq %r9, %rdi
jl 0x58ec
incl %eax
movl %eax, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/utils.c
// Function: die
void die (char *format, ...)
{
  va_list args ;

  va_start (args, format) ;
  fprintf (stderr, "FATAL ERROR: ") ;
  vfprintf (stderr, format, args) ;
  fprintf (stderr, "\n") ;
  va_end (args) ;

  exit (-1) ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x59d7
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x45fa(%rip), %r15      # 0x9ff8
movq (%r15), %rcx
leaq 0x168e(%rip), %rdi      # 0x7096
movl $0xd, %esi
movl $0x1, %edx
callq 0x1220
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x11e0
movq (%r15), %rsi
movl $0xa, %edi
callq 0x10e0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1210
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/utils.c
// Function: myalloc
void *myalloc (size_t size)
{
  void *p = (void*) malloc (size) ;
  if (!p) die ("myalloc failure requesting %d bytes", size) ;
  totalAllocated += size ;
  return p ;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1170
testq %rax, %rax
je 0x5a53
addq %rbx, 0x593f(%rip)      # 0xb390
popq %rbx
retq
leaq 0x164a(%rip), %rdi      # 0x70a4
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5974
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/utils.c
// Function: mycalloc
void *mycalloc (size_t number, size_t size)
{
  void *p = (void*) calloc (number, size) ;
  if (!p) die ("mycalloc failure requesting %d objects of size %d", number, size) ;
  totalAllocated += size*number ;
  return p ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x10f0
testq %rax, %rax
je 0x5a8b
imulq %r14, %rbx
addq %rbx, 0x590d(%rip)      # 0xb390
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1636(%rip), %rdi      # 0x70c8
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x5974
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/utils.c
// Function: fgetword
char *fgetword (FILE *f)
{
  int n = 0 ;
  static char *buf = 0 ;
  int bufSize = 64 ;
  char *cp ;
  if (!buf) buf = (char*) myalloc (bufSize) ;
  cp = buf ;
  while (!feof (f) && (*cp = getc (f)))
    if (isgraph(*cp) && !isspace(*cp))
      { ++cp ; ++n ;
	if (n >= bufSize)
	  { bufSize *= 2 ;
	    if (!(buf = (char*) realloc (buf, bufSize)))
	      die ("fgetword realloc failure requesting %d bytes", bufSize) ;
	  }
      }
    else
      { while ((*cp = getc (f)) && (isspace(*cp) || !isgraph(*cp)) && *cp != '\n' && !feof(f)) ;
	ungetc (*cp, f) ;
	break ;
      }
  *cp = 0 ;
  return buf ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x58e4(%rip), %rbx      # 0xb398
testq %rbx, %rbx
jne 0x5acd
movl $0x40, %edi
callq 0x5a3c
movq %rax, %rbx
movq %rax, 0x58cb(%rip)      # 0xb398
movq %r14, %rdi
callq 0x1130
testl %eax, %eax
je 0x5af2
movb $0x0, (%rbx)
movq 0x58b5(%rip), %rax      # 0xb398
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %ebp
movl $0x1, %r13d
movq %r14, %rdi
callq 0x1230
movl %eax, %r12d
movb %r12b, (%rbx)
shll $0x18, %r12d
je 0x5ad9
sarl $0x18, %r12d
callq 0x1240
movq %rax, %r15
movq (%rax), %rax
movslq %r12d, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0xa000, %eax           # imm = 0xA000
negw %ax
jno 0x5b92
cmpl %ebp, %r13d
jl 0x5b53
addl %ebp, %ebp
movq 0x5859(%rip), %rdi      # 0xb398
movslq %ebp, %rsi
callq 0x1190
movq %rax, 0x584a(%rip)      # 0xb398
testq %rax, %rax
je 0x5bb7
incq %rbx
movq %r14, %rdi
callq 0x1130
incl %r13d
testl %eax, %eax
je 0x5afd
jmp 0x5ad9
cmpb $0xa, %al
je 0x5ba7
sarl $0x18, %ecx
movq (%r15), %rdx
movslq %ecx, %rcx
movzwl (%rdx,%rcx,2), %ecx
andl $0xa000, %ecx           # imm = 0xA000
negw %cx
jo 0x5ba7
movq %r14, %rdi
callq 0x1130
testl %eax, %eax
jne 0x5ba5
movq %r14, %rdi
callq 0x1230
movb %al, (%rbx)
movl %eax, %ecx
shll $0x18, %ecx
jne 0x5b6a
jmp 0x5ba7
movb (%rbx), %al
movsbl %al, %edi
movq %r14, %rsi
callq 0x1180
jmp 0x5ad9
leaq 0x153c(%rip), %rdi      # 0x70fa
movl %ebp, %esi
xorl %eax, %eax
callq 0x5974
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/utils.c
// Function: fopenTag
FILE *fopenTag (char* root, char* tag, char* mode)
{
  if (strlen (tag) > 30) die ("tag %s in fopenTag too long - should be < 30 chars", tag) ;
  char *fileName = new (strlen (root) + 32, char) ;
  strcpy (fileName, root) ;
  strcat (fileName, ".") ;
  strcat (fileName, tag) ;
  FILE *f = fopen (fileName, mode) ;
  free (fileName) ;
  return f ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x10a0
cmpq $0x1f, %rax
jae 0x5c44
movq %r15, %rdi
callq 0x10a0
leaq 0x20(%rax), %rdi
callq 0x5a3c
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x1060
movq %r12, %rdi
callq 0x10a0
movw $0x2e, (%r12,%rax)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1200
movq %r12, %rdi
movq %r14, %rsi
callq 0x11c0
movq %rax, %rbx
movq %r12, %rdi
callq 0x1040
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x14dc(%rip), %rdi      # 0x7127
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5974
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/utils.c
// Function: timeUpdate
void timeUpdate (FILE *f)
{
  static BOOL isFirst = 1 ;
  struct rusage rNew ;
  int secs, usecs ;

  getrusage (RUSAGE_SELF, &rNew) ;
  if (!isFirst)
    { secs = rNew.ru_utime.tv_sec - rOld.ru_utime.tv_sec ;
      usecs =  rNew.ru_utime.tv_usec - rOld.ru_utime.tv_usec ;
      if (usecs < 0) { usecs += 1000000 ; secs -= 1 ; }
      fprintf (f, "user\t%d.%06d", secs, usecs) ;
      secs = rNew.ru_stime.tv_sec - rOld.ru_stime.tv_sec ;
      usecs =  rNew.ru_stime.tv_usec - rOld.ru_stime.tv_usec ;
      if (usecs < 0) { usecs += 1000000 ; secs -= 1 ; }
      fprintf (f, "\tsystem\t%d.%06d", secs, usecs) ;
      fprintf (f, "\tmax_RSS\t%ld", rNew.ru_maxrss - rOld.ru_maxrss) ;
      fprintf (f, "\tmemory\t%li", totalAllocated) ;   
      fputc ('\n', f) ;
    }
  else
    { rFirst = rNew ;
      isFirst = FALSE ;
    }

  rOld = rNew ;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
xorl %edi, %edi
callq 0x11d0
cmpb $0x1, 0x572b(%rip)      # 0xb3a0
jne 0x5d32
movl 0x8(%rsp), %eax
movl 0x10(%rsp), %esi
subl 0x571f(%rip), %eax      # 0xb3a8
subl 0x5721(%rip), %esi      # 0xb3b0
movl $0xf4240, %r14d         # imm = 0xF4240
leal (%rsi,%r14), %ecx
movl %esi, %edx
sarl $0x1f, %edx
addl %eax, %edx
testl %esi, %esi
cmovnsl %esi, %ecx
leaq 0x14ae(%rip), %rsi      # 0x715a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1120
movl 0x18(%rsp), %eax
movl 0x20(%rsp), %ecx
subl 0x56f4(%rip), %eax      # 0xb3b8
subl 0x56f6(%rip), %ecx      # 0xb3c0
addl %ecx, %r14d
movl %ecx, %edx
sarl $0x1f, %edx
addl %eax, %edx
testl %ecx, %ecx
cmovnsl %ecx, %r14d
leaq 0x1486(%rip), %rsi      # 0x7167
movq %rbx, %rdi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1120
movq 0x28(%rsp), %rdx
subq 0x56ce(%rip), %rdx      # 0xb3c8
leaq 0x1476(%rip), %rsi      # 0x7177
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1120
movq 0x567e(%rip), %rdx      # 0xb390
leaq 0x146b(%rip), %rsi      # 0x7184
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1120
movl $0xa, %edi
movq %rbx, %rsi
callq 0x10e0
jmp 0x5d4f
leaq 0x56ff(%rip), %rdi      # 0xb438
leaq 0x8(%rsp), %rsi
movl $0x90, %edx
callq 0x1140
movb $0x1, 0x5651(%rip)      # 0xb3a0
leaq 0x5652(%rip), %rdi      # 0xb3a8
leaq 0x8(%rsp), %rsi
movl $0x90, %edx
callq 0x1140
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/keithnoguchi[P]pearls-in-action/0x2/main.c
// Function: main
int main(void)
{
	int fail = 0;
	int i = 0;

	printf("===============================\n");
	printf("Programming Pearls: Chapter 0x2\n");
	printf("===============================\n");

	if (rotate_test(&i))
		fail++;
	if (sign_test(&i))
		fail++;

	puts("");

	return fail;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0xe32(%rip), %r14       # 0x2024
movq %r14, %rdi
callq 0x1050
leaq 0xe03(%rip), %rdi       # 0x2004
callq 0x1050
movq %r14, %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x12d8
xorl %r14d, %r14d
testl %eax, %eax
setne %r14b
movq %rbx, %rdi
callq 0x1474
leal 0x1(%r14), %ebx
testl %eax, %eax
cmovel %r14d, %ebx
movl $0xa, %edi
callq 0x1030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/keithnoguchi[P]pearls-in-action/0x2/rotate.c
// Function: rotate
char *rotate(char *input, int n, int pos)
{
	reverse(input, 0, pos-1);
	reverse(input, pos, n-1);
	reverse(input, 0, n-1);
	return input;
}

// Assembly:
movq %rdi, %rax
cmpl $0x2, %edx
jl 0x1279
leal -0x1(%rdx), %ecx
movl $0x1, %edi
movb -0x1(%rax,%rdi), %r8b
movb (%rax,%rcx), %r9b
movb %r9b, -0x1(%rax,%rdi)
movb %r8b, (%rax,%rcx)
decq %rcx
leaq 0x1(%rdi), %r8
cmpq %rcx, %rdi
movq %r8, %rdi
jl 0x1258
leal -0x1(%rsi), %ecx
cmpl %edx, %ecx
jle 0x12aa
movslq %edx, %rdx
movslq %ecx, %rdi
incq %rdx
movb -0x1(%rax,%rdx), %r8b
movb (%rax,%rdi), %r9b
movb %r9b, -0x1(%rax,%rdx)
movb %r8b, (%rax,%rdi)
decq %rdi
leaq 0x1(%rdx), %r8
cmpq %rdi, %rdx
movq %r8, %rdx
jl 0x1289
cmpl $0x2, %esi
jl 0x12d7
movl %ecx, %ecx
movl $0x1, %edx
movb -0x1(%rax,%rdx), %sil
movb (%rax,%rcx), %dil
movb %dil, -0x1(%rax,%rdx)
movb %sil, (%rax,%rcx)
decq %rcx
leaq 0x1(%rdx), %rsi
cmpq %rcx, %rdx
movq %rsi, %rdx
jl 0x12b6
retq
// File: /workspace/github_c_makefile_star2_O3/keithnoguchi[P]pearls-in-action/0x2/sign.c
// Function: quicksort
static void quicksort(char word[], int len)
{
	int last;
	int i;

	if (len < 2)
		return;

	/* Put a pivot in array 0 */
	swap(word, 0, rand()%len);

	last = 0;
	for (i = 1; i < len; i++)
		if (word[i] < word[0])
			swap(word, ++last, i);
	swap(word, 0, last);

	quicksort(word, last);
	quicksort(&word[last+1], len-(last+1));
}

// Assembly:
cmpl $0x2, %esi
jl 0x1472
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0x10d0
cltd
idivl %r14d
movb (%rbx), %al
movslq %edx, %rcx
movb (%rbx,%rcx), %dl
movb %dl, (%rbx)
movb %al, (%rbx,%rcx)
movl %r14d, %r15d
xorl %eax, %eax
movl $0x1, %ecx
movb (%rbx,%rcx), %dl
cmpb (%rbx), %dl
jge 0x142d
movslq %eax, %rsi
leaq 0x1(%rsi), %rax
movb 0x1(%rbx,%rsi), %dil
movb %dl, 0x1(%rbx,%rsi)
movb %dil, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %r15
jne 0x1412
movb (%rbx), %cl
movslq %eax, %r14
leaq (%rbx,%r14), %r12
incq %r12
movb -0x1(%r12), %al
movb %al, (%rbx)
movb %cl, -0x1(%r12)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x13db
notl %r14d
addl %r15d, %r14d
movq %r12, %rbx
cmpl $0x1, %r14d
jg 0x13f2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/darwin-on-arm[P]darwin-sdk/developer_cmds/asa/asa.c
// Function: main
int main(int argc, char **argv)
{
	FILE *fp;
	int exit_val = 0;
	/* skip progname */
	argv++;

	if (*argv && !strcmp(*argv, "--")) {
		argv++;
		argc--;
	}

	if (argc == 1) {
		asa(stdin);
		exit(exit_val);
	}

        do {
                if (*argv) {
                        if (!(fp = fopen(*argv, "r"))) {
				warn ("%s", *argv);
				exit_val = 1;
				continue;
                        } else {
				asa(fp);
				(void)fclose(fp);
			}
                }
        } while (*argv++);

	exit (exit_val);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x8(%rsi), %r12
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x120b
cmpb $0x2d, (%rax)
jne 0x120b
cmpb $0x2d, 0x1(%rax)
jne 0x120b
cmpb $0x0, 0x2(%rax)
jne 0x120b
addq $0x10, %rsi
decl %edi
movq %rsi, %r12
cmpl $0x1, %edi
jne 0x1226
movq 0x2dc9(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1287
xorl %edi, %edi
callq 0x10d0
leaq 0xdd7(%rip), %rbx       # 0x2004
leaq 0xdd2(%rip), %r14       # 0x2006
xorl %ebp, %ebp
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1280
movq %rbx, %rsi
callq 0x10b0
testq %rax, %rax
je 0x1261
movq %rax, %r15
movq %rax, %rdi
callq 0x1287
movq %r15, %rdi
callq 0x1060
jmp 0x1274
movq (%r12), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1050
movl $0x1, %ebp
cmpq $0x0, (%r12)
leaq 0x8(%r12), %r12
jne 0x1236
movl %ebp, %edi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/darwin-on-arm[P]darwin-sdk/developer_cmds/asa/asa.c
// Function: asa
static void
asa(f)
	FILE *f;
{
	char *buf;
	size_t len;

	if ((buf = fgetln (f, &len)) != NULL) {
		if (buf[len - 1] == '\n')
			buf[--len] = '\0';
		/* special case the first line  */
		switch (buf[0]) {
		case '0':
			putchar ('\n');
			break;
		case '1':
			putchar ('\f');
			break;
		}

		if (len > 1 && buf[0] && buf[1]) {
			printf("%.*s", (int)(len - 1), buf + 1);
		}

		while ((buf = fgetln(f, &len)) != NULL) {
			if (buf[len - 1] == '\n')
				buf[--len] = '\0';
			switch (buf[0]) {
			default:
			case ' ':
				putchar ('\n');
				break;
			case '0':
				putchar ('\n');
				putchar ('\n');
				break;
			case '1':
				putchar ('\n');
				putchar ('\f');
				break;
			case '+':
				putchar ('\r');
				break;
			}

			if (len > 1 && buf[0] && buf[1]) {
				printf("%.*s", (int)(len - 1), buf + 1);
			}
		}

		putchar ('\n');
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x13f4
testq %rax, %rax
je 0x13e5
movq %rax, %r14
movq 0x8(%rsp), %rax
cmpb $0xa, -0x1(%r14,%rax)
jne 0x12c8
leaq -0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x0, -0x1(%r14,%rax)
movzbl (%r14), %eax
cmpl $0x30, %eax
je 0x12dd
cmpl $0x31, %eax
jne 0x12e7
movl $0xc, %edi
jmp 0x12e2
movl $0xa, %edi
callq 0x1030
movq 0x8(%rsp), %rsi
cmpq $0x2, %rsi
jb 0x1315
cmpb $0x0, (%r14)
je 0x1315
cmpb $0x0, 0x1(%r14)
je 0x1315
incq %r14
decl %esi
leaq 0xcfe(%rip), %rdi       # 0x2009
movq %r14, %rdx
xorl %eax, %eax
callq 0x1070
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x13f4
testq %rax, %rax
je 0x13db
movq %rax, %r12
leaq 0xcd4(%rip), %r14       # 0x2009
leaq 0x8(%rsp), %r15
movq 0x8(%rsp), %rax
cmpb $0xa, -0x1(%r12,%rax)
jne 0x1356
leaq -0x1(%rax), %rcx
movq %rcx, 0x8(%rsp)
movb $0x0, -0x1(%r12,%rax)
movzbl (%r12), %eax
cmpl $0x2b, %eax
je 0x138c
cmpl $0x31, %eax
je 0x137b
movl $0xa, %ebp
cmpl $0x30, %eax
jne 0x1391
movl $0xa, %edi
callq 0x1030
jmp 0x1391
movl $0xa, %edi
callq 0x1030
movl $0xc, %ebp
jmp 0x1391
movl $0xd, %ebp
movl %ebp, %edi
callq 0x1030
movq 0x8(%rsp), %rsi
cmpq $0x2, %rsi
jb 0x13c4
cmpb $0x0, (%r12)
je 0x13c4
cmpb $0x0, 0x1(%r12)
je 0x13c4
incq %r12
decl %esi
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13f4
movq %rax, %r12
testq %rax, %rax
jne 0x133a
movl $0xa, %edi
callq 0x1030
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/darwin-on-arm[P]darwin-sdk/developer_cmds/asa/fgetln.c
// Function: fgetln
char *fgetln(FILE *f, size_t *l)
{
	int fd, h;
	struct entry *p;
	ssize_t cnt;
	char *ret = 0;

	flockfile(f);
	fd = fileno(f);
	h = fd % K;

#ifdef THREAD_SAFE
	pthread_rwlock_rdlock(&lock);
#endif
	for (p=table[h]; p && (p->fd!=fd || (fd<0 && p->f!=f)); p=p->next);
	if (!p) {
		if (!(p = calloc(sizeof *p, 1))) {
#ifdef THREAD_SAFE
			pthread_rwlock_unlock(&lock);
#endif
			funlockfile(f);
			return 0;
		}
		p->fd = fd;
		p->f = f;
#ifdef THREAD_SAFE
		pthread_rwlock_unlock(&lock);
		pthread_rwlock_wrlock(&lock);
#endif
		p->next = table[h];
		table[h] = p;
	}
#ifdef THREAD_SAFE
	pthread_rwlock_unlock(&lock);
#endif
	cnt = getline(&p->buf, (size_t[]){0}, f);
	if (cnt >= 0) {
		*l = cnt;
		ret = p->buf;
	}
	funlockfile(f);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
callq 0x1080
movq %rbx, %rdi
callq 0x10a0
movl %eax, %ebp
movl %eax, %r12d
andl $0x3f, %r12d
leaq 0x2c69(%rip), %r13      # 0x4090
movq (%r13,%r12,8), %r14
testq %r14, %r14
je 0x144c
movq %r14, %r15
cmpl %ebp, 0x8(%r15)
jne 0x1444
testl %ebp, %ebp
jns 0x1472
cmpq %rbx, 0x10(%r15)
je 0x1472
movq (%r15), %r15
testq %r15, %r15
jne 0x1434
movl $0x20, %edi
movl $0x1, %esi
callq 0x1090
testq %rax, %rax
je 0x14ac
movq %rax, %r15
movl %ebp, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r14, (%rax)
movq %rax, (%r13,%r12,8)
addq $0x18, %r15
leaq 0x10(%rsp), %rsi
movq $0x0, (%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x10c0
testq %rax, %rax
js 0x149f
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq (%r15), %r14
jmp 0x14a2
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1040
jmp 0x14b7
movq %rbx, %rdi
callq 0x1040
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mesbahamin[P]star-sim/src/star.c
// Function: star_attract
void star_attract(struct Star *s1, struct Star *s2)
{
    float dx = s1->x - s2->x;
    float dy = s1->y - s2->y;
    float distance = hypotf(dx, dy);

    if (distance > s1->size + s2->size)
    {
        float theta = atan2f(dy, dx);
        float force = GRAVITATION * (s1->mass * s2->mass / powf(distance, 2));
        star_accelerate(s1, theta - (0.5 * M_PI), force / s1->mass);
        star_accelerate(s2, theta + (0.5 * M_PI), force / s2->mass);
        //printf("%f\n", force);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movss 0x10(%rdi), %xmm0
movss 0x14(%rdi), %xmm1
subss 0x10(%rsi), %xmm0
subss 0x14(%rsi), %xmm1
movss %xmm0, 0xc(%rsp)
movss %xmm1, 0x10(%rsp)
callq 0x1080
movaps %xmm0, %xmm1
movss 0xc(%r14), %xmm0
addss 0xc(%rbx), %xmm0
ucomiss %xmm0, %xmm1
jbe 0x2a4d
movss 0x10(%rsp), %xmm0
movss %xmm1, 0x10(%rsp)
movss 0xc(%rsp), %xmm1
callq 0x11d0
movss 0x8(%r14), %xmm1
movss 0x8(%rbx), %xmm3
mulss %xmm1, %xmm3
movss 0x10(%rsp), %xmm2
mulss %xmm2, %xmm2
divss %xmm2, %xmm3
mulss 0x1743(%rip), %xmm3     # 0x4100
movss %xmm3, 0xc(%rsp)
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsp)
movsd 0x1720(%rip), %xmm0     # 0x40f8
addsd %xmm2, %xmm0
xorps %xmm2, %xmm2
cvtsd2ss %xmm0, %xmm2
divss %xmm1, %xmm3
movss (%r14), %xmm0
movss 0x4(%r14), %xmm1
callq 0x2814
movsd (%rax), %xmm0
movsd %xmm0, (%r14)
movq %rax, %rdi
callq 0x11a0
movsd 0x10(%rsp), %xmm0
addsd 0x16da(%rip), %xmm0     # 0x40f0
xorps %xmm2, %xmm2
cvtsd2ss %xmm0, %xmm2
movss 0xc(%rsp), %xmm3
divss 0x8(%rbx), %xmm3
movss (%rbx), %xmm0
movss 0x4(%rbx), %xmm1
callq 0x2814
movsd (%rax), %xmm0
movsd %xmm0, (%rbx)
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x11a0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mesbahamin[P]star-sim/src/star.c
// Function: star_attract_to_mass
void star_attract_to_mass(struct Star *star, float mass, float mass_x, float mass_y)
{
    float dx = star->x - mass_x;
    float dy = star->y - mass_y;
    float distance = hypotf(dx, dy);

    float theta = atan2f(dy, dx);
    float force = GRAVITATION * (star->mass * mass / powf(distance, 2));
    star_accelerate(star, theta - (0.5 * M_PI), force / star->mass);
    //printf("%f\n", force);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
movss 0x10(%rdi), %xmm0
movss 0x14(%rdi), %xmm3
subss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
subss %xmm2, %xmm3
movss %xmm3, (%rsp)
movaps %xmm3, %xmm1
callq 0x1080
movss %xmm0, 0x8(%rsp)
movss (%rsp), %xmm0
movss 0x4(%rsp), %xmm1
callq 0x11d0
movss 0x8(%rbx), %xmm1
movss 0xc(%rsp), %xmm3
mulss %xmm1, %xmm3
movss 0x8(%rsp), %xmm2
mulss %xmm2, %xmm2
divss %xmm2, %xmm3
mulss 0x163d(%rip), %xmm3     # 0x4100
cvtss2sd %xmm0, %xmm0
addsd 0x1629(%rip), %xmm0     # 0x40f8
xorps %xmm2, %xmm2
cvtsd2ss %xmm0, %xmm2
divss %xmm1, %xmm3
movss (%rbx), %xmm0
movss 0x4(%rbx), %xmm1
callq 0x2814
movsd (%rax), %xmm0
movsd %xmm0, (%rbx)
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x11a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: cell_contains_star
bool cell_contains_star(struct Cell *c, struct Star *s)
{
    return (s->x <= c->center_x + c->distance_x
        && s->x >= c->center_x - c->distance_x
        && s->y <= c->center_y + c->distance_y
        && s->y >= c->center_y - c->distance_y);
}

// Assembly:
movss 0x10(%rsi), %xmm0
movss (%rdi), %xmm1
movss 0x8(%rdi), %xmm2
movaps %xmm1, %xmm3
addss %xmm2, %xmm3
xorl %eax, %eax
ucomiss %xmm0, %xmm3
jb 0x2bc2
subss %xmm2, %xmm1
ucomiss %xmm1, %xmm0
jb 0x2bc2
movss 0x14(%rsi), %xmm0
movss 0x4(%rdi), %xmm1
movss 0xc(%rdi), %xmm2
movaps %xmm1, %xmm3
addss %xmm2, %xmm3
ucomiss %xmm0, %xmm3
jae 0x2bc3
xorl %eax, %eax
retq
subss %xmm2, %xmm1
ucomiss %xmm1, %xmm0
setae %al
retq
// File: /workspace/github_c_makefile_star2_O3/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: quad_tree_node_free
void quad_tree_node_free(struct QuadTreeNode *node)
{
    if (node)
    {
        quad_tree_node_free(node->ne);
        quad_tree_node_free(node->nw);
        quad_tree_node_free(node->sw);
        quad_tree_node_free(node->se);
        free(node->cell);
        free(node);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x2cae
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x2c70
movq 0x10(%rbx), %rdi
callq 0x2c70
movq 0x18(%rbx), %rdi
callq 0x2c70
movq 0x20(%rbx), %rdi
callq 0x2c70
movq (%rbx), %rdi
callq 0x11a0
movq %rbx, %rdi
popq %rbx
jmp 0x11a0
retq
// File: /workspace/github_c_makefile_star2_O3/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: quad_tree_node_subdivide
void quad_tree_node_subdivide(struct QuadTreeNode *node)
{
    if (node && quad_tree_node_is_leaf(node))
    {
        float child_distance_x = node->cell->distance_x / 2;
        float child_distance_y = node->cell->distance_y / 2;

        node->ne = quad_tree_node_init(node->cell->center_x + child_distance_x, node->cell->center_y + child_distance_y, child_distance_x, child_distance_y);
        node->nw = quad_tree_node_init(node->cell->center_x - child_distance_x, node->cell->center_y + child_distance_y, child_distance_x, child_distance_y);
        node->sw = quad_tree_node_init(node->cell->center_x - child_distance_x, node->cell->center_y - child_distance_y, child_distance_x, child_distance_y);
        node->se = quad_tree_node_init(node->cell->center_x + child_distance_x, node->cell->center_y - child_distance_y, child_distance_x, child_distance_y);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x2dc7
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2d08
cmpq $0x0, 0x10(%rbx)
je 0x2d08
cmpq $0x0, 0x18(%rbx)
je 0x2d08
cmpq $0x0, 0x20(%rbx)
jne 0x2dc2
movq (%rbx), %rax
movss 0x137d(%rip), %xmm3     # 0x4090
movss 0x8(%rax), %xmm2
mulss %xmm3, %xmm2
movss %xmm2, 0x8(%rsp)
mulss 0xc(%rax), %xmm3
movss %xmm3, 0xc(%rsp)
movss (%rax), %xmm0
addss %xmm2, %xmm0
movss 0x4(%rax), %xmm1
addss %xmm3, %xmm1
callq 0x2bd7
movq %rax, 0x8(%rbx)
movq (%rbx), %rax
movss (%rax), %xmm0
movss 0x8(%rsp), %xmm2
subss %xmm2, %xmm0
movss 0x4(%rax), %xmm1
movss 0xc(%rsp), %xmm3
addss %xmm3, %xmm1
callq 0x2bd7
movq %rax, 0x10(%rbx)
movq (%rbx), %rax
movss (%rax), %xmm0
movss 0x4(%rax), %xmm1
movss 0x8(%rsp), %xmm2
subss %xmm2, %xmm0
movss 0xc(%rsp), %xmm3
subss %xmm3, %xmm1
callq 0x2bd7
movq %rax, 0x18(%rbx)
movq (%rbx), %rax
movss (%rax), %xmm0
movss 0x8(%rsp), %xmm2
addss %xmm2, %xmm0
movss 0x4(%rax), %xmm1
movss 0xc(%rsp), %xmm3
subss %xmm3, %xmm1
callq 0x2bd7
movq %rax, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: quad_tree_init
struct QuadTree *quad_tree_init(void)
{
    struct QuadTree *qt = (struct QuadTree *)malloc(sizeof (struct QuadTree));
    if (qt)
    {
        qt->root = NULL;
    }
    return qt;
}

// Assembly:
pushq %rax
movl $0x8, %edi
callq 0x11b0
testq %rax, %rax
je 0x2f6e
movq $0x0, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: node_is_sufficiently_far
bool node_is_sufficiently_far(struct QuadTreeNode *node, struct Star *star)
{
    float s = node->cell->distance_x * 2;
    float dx = node->cell->mass_center_x - star->x;
    float dy = node->cell->mass_center_y - star->y;
    float d = hypotf(dx, dy);

    return s / d < THETA;
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movss 0x8(%rax), %xmm1
movss 0x14(%rax), %xmm0
subss 0x10(%rsi), %xmm0
addss %xmm1, %xmm1
movss %xmm1, 0x4(%rsp)
movss 0x18(%rax), %xmm1
subss 0x14(%rsi), %xmm1
callq 0x1080
movss 0x4(%rsp), %xmm1
divss %xmm0, %xmm1
movss 0x10c7(%rip), %xmm0     # 0x4090
ucomiss %xmm1, %xmm0
seta %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/mesbahamin[P]star-sim/src/barnes_hut.c
// Function: quad_tree_calc_force_on_star
void quad_tree_calc_force_on_star(struct QuadTreeNode *node, struct Star *star)
{
    if (!star || !node)
    {
        return;
    }

    if (quad_tree_node_is_leaf(node) && !cell_is_empty(node->cell) && !cell_contains_star(node->cell, star))
    {
        star_attract(node->cell->star, star);
    }
    else if (node_is_sufficiently_far(node, star))
    {
        star_attract_to_mass(star,
                node->cell->mass_total,
                node->cell->mass_center_x,
                node->cell->mass_center_y);
    }
    else
    {
        quad_tree_calc_force_on_star(node->ne, star);
        quad_tree_calc_force_on_star(node->nw, star);
        quad_tree_calc_force_on_star(node->sw, star);
        quad_tree_calc_force_on_star(node->se, star);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x30e3
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x8(%r14)
je 0x3015
cmpq $0x0, 0x10(%r14)
je 0x3015
cmpq $0x0, 0x18(%r14)
je 0x3015
cmpq $0x0, 0x20(%r14)
je 0x3015
movq (%r14), %rax
movss 0x10(%rbx), %xmm1
jmp 0x3074
movq (%r14), %rax
movq 0x28(%rax), %rdi
movss 0x10(%rbx), %xmm1
testq %rdi, %rdi
je 0x3074
movss (%rax), %xmm0
movss 0x8(%rax), %xmm2
movaps %xmm0, %xmm3
addss %xmm2, %xmm3
ucomiss %xmm1, %xmm3
jb 0x30eb
subss %xmm2, %xmm0
ucomiss %xmm0, %xmm1
jb 0x30eb
movss 0x14(%rbx), %xmm0
movss 0x4(%rax), %xmm2
movss 0xc(%rax), %xmm3
movaps %xmm2, %xmm4
addss %xmm3, %xmm4
ucomiss %xmm0, %xmm4
jb 0x30eb
subss %xmm3, %xmm2
ucomiss %xmm2, %xmm0
jb 0x30eb
movss 0x8(%rax), %xmm2
movss 0x14(%rax), %xmm0
subss %xmm1, %xmm0
addss %xmm2, %xmm2
movss %xmm2, 0x4(%rsp)
movss 0x18(%rax), %xmm1
subss 0x14(%rbx), %xmm1
callq 0x1080
movss 0x4(%rsp), %xmm1
divss %xmm0, %xmm1
movss 0xfe3(%rip), %xmm0      # 0x4090
ucomiss %xmm1, %xmm0
ja 0x30fa
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x2fd1
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x2fd1
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x2fd1
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x2fef
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2938
movq (%r14), %rax
movss 0x10(%rax), %xmm0
movss 0x14(%rax), %xmm1
movss 0x18(%rax), %xmm2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a55