LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x75e2
movq -0x8(%rbp), %rax
cmpl $0x881502, (%rax)       # imm = 0x881502
je 0x75f4
movq -0x8(%rbp), %rsi
leaq 0x2938(%rip), %rdi      # 0x9f25
movb $0x0, %al
callq 0x8180
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x7605
jmp 0x76ee
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x14(%rax), %ecx
movl 0x6d7a(%rip), %eax      # 0xe394
subl %ecx, %eax
movl %eax, 0x6d72(%rip)      # 0xe394
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x14(%rcx), %eax
cmpl $0x800000, %eax         # imm = 0x800000
jge 0x7646
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
shll %ecx
movl %ecx, 0x10(%rax)
jmp 0x7665
movq -0x8(%rbp), %rcx
movl $0x800000, %eax         # imm = 0x800000
cltd
idivl 0x14(%rcx)
movl %eax, %ecx
addl $0x400, %ecx            # imm = 0x400
movq -0x8(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jl 0x767e
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x14(%rcx), %eax
addl 0x6d01(%rip), %eax      # 0xe394
movl %eax, 0x6cfb(%rip)      # 0xe394
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x14(%rax), %rsi
callq 0x82b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x18(%rcx), %eax
movslq %eax, %rdx
callq 0x1140
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x7740
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jl 0x7733
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x75c0
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7782
movq -0x8(%rbp), %rax
cmpl $0x881502, (%rax)       # imm = 0x881502
je 0x7794
movq -0x8(%rbp), %rsi
leaq 0x27bc(%rip), %rdi      # 0x9f49
movb $0x0, %al
callq 0x8180
cmpl $0x0, -0xc(%rbp)
jge 0x77ab
movl -0xc(%rbp), %esi
leaq 0x27c5(%rip), %rdi      # 0x9f69
movb $0x0, %al
callq 0x8180
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x77cf
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
leaq 0x27c2(%rip), %rdi      # 0x9f8a
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x783f
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jl 0x782f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl -0x10(%rbp), %esi
callq 0x75c0
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x20, %edi
callq 0x8260
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x20, %esi
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x7921
movq $0x0, -0x8(%rbp)
jmp 0x798c
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
imull 0x10(%rcx), %eax
movslq %eax, %rdi
callq 0x8260
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movslq 0x14(%rax), %rsi
movq -0x18(%rbp), %rax
movslq 0x10(%rax), %rdx
movq -0x10(%rbp), %rcx
callq 0x1070
movq -0x18(%rbp), %rcx
movslq 0x10(%rcx), %rcx
cmpq %rcx, %rax
je 0x7984
movq -0x18(%rbp), %rdi
callq 0x1040
movq $0x0, -0x8(%rbp)
jmp 0x798c
movq -0x18(%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: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7b97
movq -0x10(%rbp), %rax
cmpl $0x881502, (%rax)       # imm = 0x881502
je 0x7ba9
movq -0x10(%rbp), %rsi
leaq 0x2431(%rip), %rdi      # 0x9fd3
movb $0x0, %al
callq 0x8180
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x24(%rbp), %rdx
callq 0x79a0
cmpb $0x0, %al
je 0x7c41
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x7700
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x14(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
subl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x7c2e
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb (%rax), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
jmp 0x7bfa
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x7c45
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7c77
movq -0x10(%rbp), %rax
cmpl $0x881502, (%rax)       # imm = 0x881502
je 0x7c89
movq -0x10(%rbp), %rsi
leaq 0x2375(%rip), %rdi      # 0x9ff7
movb $0x0, %al
callq 0x8180
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x24(%rbp), %rdx
callq 0x79a0
cmpb $0x0, %al
je 0x7cab
movb $0x0, -0x1(%rbp)
jmp 0x7db8
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
subl $0x1, %esi
callq 0x7700
cmpl $0x0, -0x2c(%rbp)
jle 0x7d5b
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
subl $0x1, %esi
callq 0x7700
movq -0x10(%rbp), %rcx
movslq 0x14(%rcx), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x14(%rcx), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0x28(%rbp), %eax
subl -0x24(%rbp), %eax
subl $0x1, %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x44(%rbp)
cmpl $0x0, %eax
je 0x7d59
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x40(%rbp)
movb (%rax), %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
jmp 0x7d25
jmp 0x7d5b
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
addl $0x1, %esi
callq 0x7700
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x44(%rbp)
cmpl $0x0, %eax
je 0x7db4
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb (%rax), %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
jmp 0x7d80
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7def
movq -0x8(%rbp), %rax
cmpl $0x881502, (%rax)       # imm = 0x881502
je 0x7e01
movq -0x8(%rbp), %rsi
leaq 0x2220(%rip), %rdi      # 0xa01a
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rax
cmpl $0x2, 0x18(%rax)
jge 0x7e10
jmp 0x7f4d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x7f40
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
imull -0x18(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movl -0x10(%rbp), %ecx
imull -0x18(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x7eb4
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %eax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x7eb2
jmp 0x7eb6
jmp 0x7e78
jmp 0x7f32
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl %ecx, %eax
je 0x7f30
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
imull -0x18(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movl -0x10(%rbp), %ecx
imull -0x18(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x7f2e
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
jmp 0x7efa
jmp 0x7f30
jmp 0x7f32
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7e34
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/array.c
// Function: arrayReport
void arrayReport (int j)
{
  int i ;
  Array a ;

  fprintf(stderr, "Array report: %d created, %d active, %d MB allocated\n",   
	  totalNumberCreated, totalNumberActive, totalAllocatedMemory/(1024*1024)) ;

  if (reportArray)
    { i = arrayMax (reportArray) ;
      while (i-- && i > j)
	{ a = arr (reportArray, i, Array) ;
	  if (arrayExists(a))
	    fprintf (stderr, " array %d  size %d, max %d\n", i, a->size, a->max) ;
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x5056(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movl 0x63fd(%rip), %eax      # 0xe3a8
movl %eax, -0x14(%rbp)
movl 0x63e4(%rip), %ecx      # 0xe398
movl 0x63da(%rip), %eax      # 0xe394
movl $0x100000, %esi         # imm = 0x100000
cltd
idivl %esi
movl -0x14(%rbp), %edx
movl %eax, %r8d
leaq 0x2071(%rip), %rsi      # 0xa040
movb $0x0, %al
callq 0x1120
cmpq $0x0, 0x63c2(%rip)      # 0xe3a0
je 0x8083
movq 0x63b5(%rip), %rax      # 0xe3a0
movl 0x18(%rax), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x8012
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
setg %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x801b
jmp 0x8081
movq 0x637e(%rip), %rax      # 0xe3a0
movq 0x8(%rax), %rax
movl -0x8(%rbp), %ecx
movq 0x6370(%rip), %rdx      # 0xe3a0
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x807c
movq -0x10(%rbp), %rax
cmpl $0x881502, (%rax)       # imm = 0x881502
jne 0x807c
movq 0x4f9f(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %r8d
leaq 0x2001(%rip), %rsi      # 0xa076
movb $0x0, %al
callq 0x1120
jmp 0x7ff1
jmp 0x8083
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/array.c
// Function: arrayStatus
void arrayStatus (int *nmadep, int *nusedp, int *memAllocp, int *memUsedp)
{ 
  int i ;
  Array a ;

  *nmadep = totalNumberCreated ; 
  *nusedp = totalNumberActive ;
  *memAllocp = totalAllocatedMemory ;
  *memUsedp = 0 ;

  if (reportArray)
    for (i = 0 ; i < arrayMax(reportArray) ; ++i)
      if (arrayExists (a = arr(reportArray, i, Array)))
	*memUsedp += a->max * a->size ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl 0x62fe(%rip), %ecx      # 0xe3a8
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl 0x62e2(%rip), %ecx      # 0xe398
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl 0x62d2(%rip), %ecx      # 0xe394
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, 0x62c6(%rip)      # 0xe3a0
je 0x8175
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq 0x62af(%rip), %rcx      # 0xe3a0
cmpl 0x18(%rcx), %eax
jge 0x8173
movq 0x62a3(%rip), %rax      # 0xe3a0
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
movq 0x6295(%rip), %rdx      # 0xe3a0
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8163
movq 0x6279(%rip), %rax      # 0xe3a0
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
movq 0x626b(%rip), %rdx      # 0xe3a0
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x30(%rbp)
cmpl $0x881502, (%rax)       # imm = 0x881502
jne 0x8163
movq -0x30(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x30(%rbp), %rax
imull 0x14(%rax), %ecx
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x8165
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x80e7
jmp 0x8175
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x81b5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x4df1(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x1e81(%rip), %rsi      # 0xa092
movb $0x0, %al
callq 0x1120
movq 0x4dd9(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x11e0
movq 0x4dc2(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0xe3e(%rip), %rsi       # 0x907e
movb $0x0, %al
callq 0x1120
leaq -0x20(%rbp), %rax
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1210
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1170
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8292
movq -0x8(%rbp), %rsi
leaq 0x1e15(%rip), %rdi      # 0xa0a0
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rax
addq 0x6113(%rip), %rax      # 0xe3b0
movq %rax, 0x610c(%rip)      # 0xe3b0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x82ee
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x1ddd(%rip), %rdi      # 0xa0c4
movb $0x0, %al
callq 0x8180
movq -0x10(%rbp), %rax
imulq -0x8(%rbp), %rax
addq 0x60b2(%rip), %rax      # 0xe3b0
movq %rax, 0x60ab(%rip)      # 0xe3b0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
cmpq $0x1e, %rax
jbe 0x8525
movq -0x10(%rbp), %rsi
leaq 0x1c05(%rip), %rdi      # 0xa123
movb $0x0, %al
callq 0x8180
movq -0x8(%rbp), %rdi
callq 0x10a0
movq %rax, %rdi
addq $0x20, %rdi
shlq $0x0, %rdi
callq 0x8260
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1060
movq -0x20(%rbp), %rdi
leaq 0x1bfc(%rip), %rsi      # 0xa156
callq 0x1200
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1200
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1040
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
leaq -0x98(%rbp), %rsi
callq 0x11d0
cmpb $0x0, 0x5d8c(%rip)      # 0xe340
jne 0x86db
movq -0x98(%rbp), %rax
subq 0x5df8(%rip), %rax      # 0xe3c0
movl %eax, -0x9c(%rbp)
movq -0x90(%rbp), %rax
subq 0x5dec(%rip), %rax      # 0xe3c8
movl %eax, -0xa0(%rbp)
cmpl $0x0, -0xa0(%rbp)
jge 0x860b
movl -0xa0(%rbp), %eax
addl $0xf4240, %eax          # imm = 0xF4240
movl %eax, -0xa0(%rbp)
movl -0x9c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x9c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x9c(%rbp), %edx
movl -0xa0(%rbp), %ecx
leaq 0x1b36(%rip), %rsi      # 0xa158
movb $0x0, %al
callq 0x1120
movq -0x88(%rbp), %rax
subq 0x5d99(%rip), %rax      # 0xe3d0
movl %eax, -0x9c(%rbp)
movq -0x80(%rbp), %rax
subq 0x5d90(%rip), %rax      # 0xe3d8
movl %eax, -0xa0(%rbp)
cmpl $0x0, -0xa0(%rbp)
jge 0x8677
movl -0xa0(%rbp), %eax
addl $0xf4240, %eax          # imm = 0xF4240
movl %eax, -0xa0(%rbp)
movl -0x9c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x9c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x9c(%rbp), %edx
movl -0xa0(%rbp), %ecx
leaq 0x1ad7(%rip), %rsi      # 0xa165
movb $0x0, %al
callq 0x1120
movq -0x8(%rbp), %rdi
movq -0x78(%rbp), %rdx
subq 0x5d3c(%rip), %rdx      # 0xe3e0
leaq 0x1aca(%rip), %rsi      # 0xa175
movb $0x0, %al
callq 0x1120
movq -0x8(%rbp), %rdi
movq 0x5cf3(%rip), %rdx      # 0xe3b0
leaq 0x1abe(%rip), %rsi      # 0xa182
movb $0x0, %al
callq 0x1120
movq -0x8(%rbp), %rsi
movl $0xa, %edi
callq 0x10e0
jmp 0x86fa
leaq 0x5d6e(%rip), %rdi      # 0xe450
leaq -0x98(%rbp), %rsi
movl $0x90, %edx
callq 0x1140
movb $0x0, 0x5c46(%rip)      # 0xe340
leaq 0x5cbf(%rip), %rdi      # 0xe3c0
leaq -0x98(%rbp), %rsi
movl $0x90, %edx
callq 0x1140
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0xe10(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1060
leaq 0xe23(%rip), %rdi       # 0x2025
movb $0x0, %al
callq 0x1060
leaq 0xdf4(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1060
leaq -0xc(%rbp), %rdi
callq 0x1310
cmpl $0x0, %eax
je 0x122e
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x15e0
cmpl $0x0, %eax
je 0x1245
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
leaq 0xefb(%rip), %rdi       # 0x2147
callq 0x1040
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x12b0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
subl $0x1, %edx
callq 0x12b0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x12b0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x2/rotate.c
// Function: reverse
static void reverse(char *input, int i, int j)
{
	while (i < j) {
		char tmp = input[i];
		input[i] = input[j];
		input[j] = tmp;
		i++;
		j--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x130c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x11(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12be
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0x14da
jmp 0x157e
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x10c0
movq -0x20(%rbp), %rdi
cltd
idivl -0xc(%rbp)
xorl %esi, %esi
callq 0x1590
movl $0x0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1545
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x1538
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movl -0x14(%rbp), %edx
callq 0x1590
jmp 0x153a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1504
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
xorl %esi, %esi
callq 0x1590
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x14c0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
addl $0x1, %eax
cltq
addq %rax, %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %eax
addl $0x1, %eax
subl %eax, %esi
callq 0x14c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x2/sign_test.c
// Function: sign_test
int sign_test(int *i)
{
	const struct test {
		const char	*name;
		const char	*word;
		const char	*want;
	} tests[] = {
		{
			.name	= "pans -> anps",
			.word	= "pans",
			.want	= "anps",
		},
		{
			.name	= "pots -> opst",
			.word	= "pots",
			.want	= "opst",
		},
		{
			.name	= "opt -> opt",
			.word	= "opt",
			.want	= "opt",
		},
		{
			.name	= "snap -> anps",
			.word	= "snap",
			.want	= "anps",
		},
		{
			.name	= "stop -> opst",
			.word	= "stop",
			.want	= "opst",
		},
		{
			.name	= "tops -> opst",
			.word	= "tops",
			.want	= "opst",
		},
		{ /* sentry */ },
	};
	const struct test *t;
	int fail = 0;

	for (t = tests; t->name; t++) {
#define WORDSIZE	100
		char got[WORDSIZE];

		printf("%2d) %-15s: %-55s", ++(*i), "sign_test", t->name);
		sign(t->word, strlen(t->word), got);
		if (strcmp(got, t->want)) {
			fail++;
			puts("FAIL");
		} else
			puts("PASS");
	}
	return fail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq 0x2753(%rip), %rsi      # 0x3d50
movl $0xa8, %edx
callq 0x1090
movl $0x0, -0xbc(%rbp)
leaq -0xb0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x16ef
movq -0x8(%rbp), %rax
movl (%rax), %esi
addl $0x1, %esi
movl %esi, (%rax)
movq -0xb8(%rbp), %rax
movq (%rax), %rcx
leaq 0xac7(%rip), %rdi       # 0x2113
leaq 0xb5a(%rip), %rdx       # 0x21ad
movb $0x0, %al
callq 0x1060
movq -0xb8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x128(%rbp)
movq -0xb8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1050
movq -0x128(%rbp), %rdi
movl %eax, %esi
leaq -0x120(%rbp), %rdx
callq 0x1470
leaq -0x120(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1080
cmpl $0x0, %eax
je 0x16ca
movl -0xbc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xbc(%rbp)
leaq 0xaf4(%rip), %rdi       # 0x21b7
callq 0x1040
jmp 0x16d6
leaq 0xa60(%rip), %rdi       # 0x2131
callq 0x1040
jmp 0x16d8
movq -0xb8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0xb8(%rbp)
jmp 0x161f
movl -0xbc(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1250
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xe1b(%rip), %rsi       # 0x204c
callq 0x10a0
cmpl $0x0, %eax
jne 0x1250
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x126d
movq 0x2d83(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x12f0
movl -0x1c(%rbp), %edi
callq 0x10e0
jmp 0x126f
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x12c8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xdc8(%rip), %rsi       # 0x204f
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x12b4
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xdad(%rip), %rdi       # 0x2051
movb $0x0, %al
callq 0x1050
movl $0x1, -0x1c(%rbp)
jmp 0x12ca
movq -0x18(%rbp), %rdi
callq 0x12f0
movq -0x18(%rbp), %rdi
callq 0x1060
jmp 0x12c8
jmp 0x12ca
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, (%rax)
jne 0x126f
movl -0x1c(%rbp), %edi
callq 0x10e0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1080
movq -0x10(%rbp), %rdi
callq 0x10b0
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
andq $0x3f, %rax
movl %eax, -0x20(%rbp)
movslq -0x20(%rbp), %rcx
leaq 0x2b8d(%rip), %rax      # 0x40a0
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x41(%rbp)
je 0x1561
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movb $0x1, %al
cmpl -0x1c(%rbp), %ecx
movb %al, -0x42(%rbp)
jne 0x155b
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x43(%rbp)
jge 0x1555
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
setne %al
movb %al, -0x43(%rbp)
movb -0x43(%rbp), %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x156a
jmp 0x1579
jmp 0x156c
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x151b
cmpq $0x0, -0x28(%rbp)
jne 0x15ee
movl $0x20, %edi
movl $0x1, %esi
callq 0x1090
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x15af
movq -0x10(%rbp), %rdi
callq 0x1040
movq $0x0, -0x8(%rbp)
jmp 0x163e
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movslq -0x20(%rbp), %rcx
leaq 0x2ad0(%rip), %rax      # 0x40a0
movq (%rax,%rcx,8), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdx
movslq -0x20(%rbp), %rcx
leaq 0x2ab6(%rip), %rax      # 0x40a0
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq $0x0, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x10d0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jl 0x162d
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1040
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vanhauser-thc[P]vulntest/fdleak.c
// Function: main
int main(int argc, char *argv[]) {
  int fd;

  if ((fd = open("/var/log/app.log", O_RDWR | O_APPEND | O_CREAT, 0600)) < 0) {
    close(fd);
    return -1;
  }

  if (geteuid() != getuid()) {
    setegid(getgid());
    seteuid(getuid());
  }

  write(1, "Hello\n", 6);

  system("/bin/bash");

  close(fd);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe27(%rip), %rdi       # 0x2004
movl $0x442, %esi            # imm = 0x442
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x1090
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0x1207
movl -0x14(%rbp), %edi
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1266
callq 0x1060
movl %eax, -0x18(%rbp)
callq 0x1040
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
je 0x1235
callq 0x1080
movl %eax, %edi
callq 0x10a0
callq 0x1040
movl %eax, %edi
callq 0x10b0
movl $0x1, %edi
leaq 0xdd4(%rip), %rsi       # 0x2015
movl $0x6, %edx
callq 0x1030
leaq 0xdca(%rip), %rdi       # 0x201c
callq 0x1050
movl -0x14(%rbp), %edi
callq 0x1070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mesbahamin[P]star-sim/src/platform_sdl.c
// Function: sdl_resize_texture
void sdl_resize_texture(struct SDLOffscreenBuffer *buffer, SDL_Renderer *renderer, int width, int height)
{
    if (buffer->memory)
    {
        free(buffer->memory);
    }

    if (buffer->texture)
    {
        SDL_DestroyTexture(buffer->texture);
    }

    buffer->texture = SDL_CreateTexture(
            renderer,
            SDL_PIXELFORMAT_ARGB8888,
            SDL_TEXTUREACCESS_STREAMING,
            width, height);

    buffer->width = width;
    buffer->height = height;
    buffer->pitch = width * BYTES_PER_PIXEL;

    buffer->memory = malloc(width * height * BYTES_PER_PIXEL);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl %ecx, (%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x136f
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11a0
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1387
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x10d0
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %ecx
movl (%rsp), %r8d
movl $0x16362004, %esi       # imm = 0x16362004
movl $0x1, %edx
callq 0x11f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movl (%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x14(%rax)
movl 0x4(%rsp), %ecx
shll $0x2, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movl 0x4(%rsp), %eax
imull (%rsp), %eax
shll $0x2, %eax
movslq %eax, %rdi
callq 0x11b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mesbahamin[P]star-sim/src/sim.c
// Function: sim_bounding_box_update
void sim_bounding_box_update(struct SimBounds *bounds, float min_x, float min_y, float max_x, float max_y)
{
    if (!bounds)
    {
        // TODO: handle invalid pointer error
        return;
    }

    float bounding_square_side_length = fmaxf(max_x - min_x, max_y - min_y);
    bounds->side_length_x = bounding_square_side_length;
    bounds->side_length_y = bounding_square_side_length;
    bounds->center_x = (min_x + max_x) / 2;
    bounds->center_y = (min_y + max_y) / 2;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movss %xmm0, -0xc(%rsp)
movss %xmm1, -0x10(%rsp)
movss %xmm2, -0x14(%rsp)
movss %xmm3, -0x18(%rsp)
cmpq $0x0, -0x8(%rsp)
jne 0x222a
jmp 0x22c9
movss -0x14(%rsp), %xmm3
subss -0xc(%rsp), %xmm3
movss -0x18(%rsp), %xmm2
subss -0x10(%rsp), %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordss %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
maxss %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movss %xmm0, -0x1c(%rsp)
movss -0x1c(%rsp), %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, 0x8(%rax)
movss -0x1c(%rsp), %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, 0xc(%rax)
movss -0xc(%rsp), %xmm0
addss -0x14(%rsp), %xmm0
movss 0x1dee(%rip), %xmm1     # 0x4088
divss %xmm1, %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, (%rax)
movss -0x10(%rsp), %xmm0
addss -0x18(%rsp), %xmm0
movss 0x1dcd(%rip), %xmm1     # 0x4088
divss %xmm1, %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, 0x4(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mesbahamin[P]star-sim/src/sim.c
// Function: sim_set_pixel
void sim_set_pixel(struct OffscreenBuffer *buffer, uint32_t x, uint32_t y, uint32_t color)
{
    if (!buffer)
    {
        // TODO: handle invalid pointer error
        return;
    }

    /* Origin is (0, 0) on the upper left.
     * To go one pixel right, increment by 32 bits.
     * To go one pixel down, increment by (buffer.width * 32) bits.
     */
    if (x < buffer->width && y < buffer->height)
    {
        uint8_t *pixel_pos = (uint8_t *)buffer->memory;
        pixel_pos += ((BYTES_PER_PIXEL*x) + (buffer->pitch * y));
        uint32_t *pixel = (uint32_t *)pixel_pos;
        *pixel = color;
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
cmpq $0x0, -0x8(%rsp)
jne 0x297b
jmp 0x29de
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x29de
movl -0x10(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x29de
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movl -0xc(%rsp), %ecx
shll $0x2, %ecx
movq -0x8(%rsp), %rax
movl 0x10(%rax), %eax
imull -0x10(%rsp), %eax
addl %eax, %ecx
movq -0x20(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq %rax, -0x28(%rsp)
movl -0x14(%rsp), %ecx
movq -0x28(%rsp), %rax
movl %ecx, (%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mesbahamin[P]star-sim/src/star.c
// Function: vec2d_add
struct Vec2d *vec2d_add(float angle1, float length1, float angle2, float length2)
{
    float x = sinf(angle1) * length1 + sinf(angle2) * length2;
    float y = cosf(angle1) * length1 + cosf(angle2) * length2;

    struct Vec2d *new_vec = (struct Vec2d*)malloc(sizeof(struct Vec2d));
    new_vec->angle = 0.5 * M_PI - atan2f(y, x);
    new_vec->length = hypotf(x, y);
    return new_vec;
}

// Assembly:
subq $0x38, %rsp
movss %xmm0, 0x34(%rsp)
movss %xmm1, 0x30(%rsp)
movss %xmm2, 0x2c(%rsp)
movss %xmm3, 0x28(%rsp)
movss 0x34(%rsp), %xmm0
callq 0x1130
movss %xmm0, 0xc(%rsp)
movss 0x30(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x2c(%rsp), %xmm0
callq 0x1130
movss 0x8(%rsp), %xmm2
movaps %xmm0, %xmm1
movss 0xc(%rsp), %xmm0
mulss 0x28(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x24(%rsp)
movss 0x34(%rsp), %xmm0
callq 0x10f0
movss %xmm0, 0x14(%rsp)
movss 0x30(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x2c(%rsp), %xmm0
callq 0x10f0
movss 0x10(%rsp), %xmm2
movaps %xmm0, %xmm1
movss 0x14(%rsp), %xmm0
mulss 0x28(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x20(%rsp)
movl $0x8, %edi
callq 0x11b0
movq %rax, 0x18(%rsp)
movss 0x20(%rsp), %xmm0
movss 0x24(%rsp), %xmm1
callq 0x11d0
cvtss2sd %xmm0, %xmm1
movsd 0xdba(%rip), %xmm0      # 0x4098
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x18(%rsp), %rax
movss %xmm0, (%rax)
movss 0x24(%rsp), %xmm0
movss 0x20(%rsp), %xmm1
callq 0x1080
movq 0x18(%rsp), %rax
movss %xmm0, 0x4(%rax)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mesbahamin[P]star-sim/src/star.c
// Function: star_accelerate
void star_accelerate(struct Star *s, float angle, float acceleration)
{
    struct Vec2d *new_vec = vec2d_add(s->angle, s->speed, angle, acceleration);
    s->angle = new_vec->angle;
    s->speed = new_vec->length;
    free(new_vec);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movss %xmm1, 0x8(%rsp)
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
movq 0x10(%rsp), %rax
movss 0x4(%rax), %xmm1
movss 0xc(%rsp), %xmm2
movss 0x8(%rsp), %xmm3
callq 0x3200
movq %rax, (%rsp)
movq (%rsp), %rax
movss (%rax), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, (%rax)
movq (%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0x4(%rax)
movq (%rsp), %rdi
callq 0x11a0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movss 0x10(%rax), %xmm0
movq 0x18(%rsp), %rax
subss 0x10(%rax), %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x20(%rsp), %rax
movss 0x14(%rax), %xmm0
movq 0x18(%rsp), %rax
subss 0x14(%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x14(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
callq 0x1080
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
movq 0x20(%rsp), %rax
movss 0xc(%rax), %xmm1
movq 0x18(%rsp), %rax
addss 0xc(%rax), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x3502
movss 0x10(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
callq 0x11d0
movss %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movss 0x8(%rax), %xmm0
movq 0x18(%rsp), %rax
mulss 0x8(%rax), %xmm0
movss %xmm0, (%rsp)
movss 0xc(%rsp), %xmm0
movss 0xc0e(%rip), %xmm1      # 0x4088
callq 0x11e0
movss (%rsp), %xmm1
divss %xmm0, %xmm1
movss 0xc1c(%rip), %xmm0      # 0x40ac
mulss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xbe7(%rip), %xmm1      # 0x4098
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss 0x4(%rsp), %xmm1
movq 0x20(%rsp), %rax
divss 0x8(%rax), %xmm1
callq 0x3320
movq 0x18(%rsp), %rdi
movss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xbb3(%rip), %xmm1      # 0x4098
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss 0x4(%rsp), %xmm1
movq 0x18(%rsp), %rax
divss 0x8(%rax), %xmm1
callq 0x3320
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movss %xmm0, 0x2c(%rsp)
movss %xmm1, 0x28(%rsp)
movss %xmm2, 0x24(%rsp)
movq 0x30(%rsp), %rax
movss 0x10(%rax), %xmm0
subss 0x28(%rsp), %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rax
movss 0x14(%rax), %xmm0
subss 0x24(%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
movss 0x20(%rsp), %xmm0
movss 0x1c(%rsp), %xmm1
callq 0x1080
movss %xmm0, 0x18(%rsp)
movss 0x1c(%rsp), %xmm0
movss 0x20(%rsp), %xmm1
callq 0x11d0
movss %xmm0, 0x14(%rsp)
movq 0x30(%rsp), %rax
movss 0x8(%rax), %xmm0
mulss 0x2c(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x18(%rsp), %xmm0
movss 0xadf(%rip), %xmm1      # 0x4088
callq 0x11e0
movss 0xc(%rsp), %xmm1
divss %xmm0, %xmm1
movss 0xaec(%rip), %xmm0      # 0x40ac
mulss %xmm1, %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movss 0x14(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xab7(%rip), %xmm1      # 0x4098
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss 0x10(%rsp), %xmm1
movq 0x30(%rsp), %rax
divss 0x8(%rax), %xmm1
callq 0x3320
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)