LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/clearcut.c
// Function: NJ_print_vertex
void
NJ_print_vertex(NJ_VERTEX *vertex) {

  long int i;

  printf("Number of active nodes: %ld\n", vertex->nactive);

  for(i=0;i<vertex->nactive;i++) {
    printf("%ld ", vertex->nodes[i]->taxa_index);
  }
  printf("\n");

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
leaq 0x394d(%rip), %rdi      # 0x828e
xorl %eax, %eax
callq 0x2100
cmpq $0x0, 0x10(%rbx)
jle 0x4977
leaq 0x3955(%rip), %r14      # 0x82ab
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x18(%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2100
incq %r15
cmpq 0x10(%rbx), %r15
jl 0x4959
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/clearcut.c
// Function: NJ_print_r
void
NJ_print_r(DMAT *dmat) {
  
  long int i;
  
  printf("\n");
  for(i=0;i<dmat->size;i++) {
    printf("r[%ld] = %0.2f\n", i, dmat->r[i]);
  }
  printf("\n");

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xa, %edi
callq 0x2050
cmpq $0x0, 0x8(%rbx)
jle 0x49cc
xorl %r14d, %r14d
leaq 0x3907(%rip), %r15      # 0x82b0
movq 0x28(%rbx), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%r14,4), %xmm0
movq %r15, %rdi
movq %r14, %rsi
movb $0x1, %al
callq 0x2100
incq %r14
cmpq 0x8(%rbx), %r14
jl 0x49a9
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/clearcut.c
// Function: NJ_print_taxanames
void
NJ_print_taxanames(DMAT *dmat) {
  
  long int i;
  
  printf("Number of taxa: %ld\n", dmat->ntaxa);
  
  for(i=0;i<dmat->ntaxa;i++) {
    printf("%ld) %s\n", i, dmat->taxaname[i]);
  }
  
  printf("\n");

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x38d3(%rip), %rdi      # 0x82c0
xorl %eax, %eax
callq 0x2100
cmpq $0x0, (%rbx)
jle 0x4a21
leaq 0x38d4(%rip), %r14      # 0x82d5
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2100
incq %r15
cmpq (%rbx), %r15
jl 0x4a04
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/clearcut.c
// Function: NJ_print_permutation
void
NJ_print_permutation(long int *perm,
		     long int size) {
  
  long int i;
  
  for(i=0;i<size-1;i++) {
    printf("%ld,", perm[i]);
  }
  printf("%ld\n", perm[size-1]);
  
  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x2, %rsi
jl 0x4a69
leaq -0x1(%rbx), %r12
leaq 0x38d1(%rip), %r15      # 0x8321
xorl %r13d, %r13d
movq (%r14,%r13,8), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2100
incq %r13
cmpq %r13, %r12
jne 0x4a53
movq -0x8(%r14,%rbx,8), %rsi
leaq 0x3da4(%rip), %rdi      # 0x8819
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2100
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/dist.c
// Function: NJ_DNA_jc_correction
void
NJ_DNA_jc_correction(DMAT *dmat,
		     NJ_alignment *alignment) {
  
  long int i, j;
  long int k;
  float d, cutoff, dist;
  long int residues;

  cutoff = 0.75;
  
  for(i=0;i<dmat->size;i++) {
    for(j=i+1;j<dmat->size;j++) {
      
      k = NJ_pw_differences(alignment, i, j, &residues);
      d = 1.0 - NJ_pw_percentid(alignment, i, j);      
      
      if(d > cutoff) {
	dist = NJ_BIGDIST;
      } else {
	dist = (-0.75) * log(1.0 - (4.0/3.0)*d);
      }
      
      if(fabs(dist) < FLT_EPSILON) {
	dmat->val[NJ_MAP(i, j, dmat->size)] = 0.0;
      } else {
	dmat->val[NJ_MAP(i, j, dmat->size)] = dist;
      }
    }
  }


  
  return;
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x4da5
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
leaq 0x1(%r12), %rcx
movq %rcx, 0x8(%rsp)
cmpq %rax, %rcx
jge 0x4d89
movq %r12, %rbp
notq %rbp
movq 0x8(%rsp), %r13
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x53e6
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x536b
movss 0x337c(%rip), %xmm1     # 0x8078
subss %xmm0, %xmm1
ucomiss 0x36ed(%rip), %xmm1     # 0x83f4
movss 0x36e1(%rip), %xmm0     # 0x83f0
ja 0x4d39
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x36f8(%rip), %xmm0     # 0x8418
addsd 0x36f8(%rip), %xmm0     # 0x8420
callq 0x2140
mulsd 0x36f3(%rip), %xmm0     # 0x8428
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, %xmm1
andps 0x32fd(%rip), %xmm1     # 0x8040
movq 0x8(%r14), %rax
leaq (,%rax,2), %rcx
addq %rbp, %rcx
imulq %r12, %rcx
movq %rcx, %rdx
shrq $0x3f, %rdx
addq %rcx, %rdx
andq $-0x2, %rdx
addq %rdx, %rdx
addq 0x18(%r14), %rdx
cmpltss 0x3300(%rip), %xmm1     # 0x8074
andnps %xmm0, %xmm1
movss %xmm1, (%rdx,%r13,4)
incq %r13
cmpq %rax, %r13
jl 0x4cd5
movq 0x8(%rsp), %r12
cmpq %rax, %r12
jl 0x4cb7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/dist.c
// Function: NJ_PROTEIN_jc_correction
void
NJ_PROTEIN_jc_correction(DMAT *dmat,
			 NJ_alignment *alignment) {
  
  long int i, j;
  long int residues;
  long int diff;
  float dist, x;
  

  for(i=0;i<dmat->size;i++) {
    for(j=i+1;j<dmat->size;j++) {

      diff = NJ_pw_differences(alignment, i, j, &residues);
      
      if(!diff || !residues) {
	dist = 0.0;
      } else {

	dist = (float)diff/(float)residues;
	x = ((20.0/19.0)*dist);

	if(NJ_FLT_GT(x, 1.0)) {
	  dist = NJ_BIGDIST;
	} else {
	  dist = -(19.0/20.0) * log(1.0 - x);
	}
      }
      
      dmat->val[NJ_MAP(i, j, dmat->size)] = dist;
    }
  }
  
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rdi), %rbp
testq %rbp, %rbp
jle 0x4ecd
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x1(%r12), %r13
cmpq %rbp, %r13
movq %r13, 0x8(%rsp)
jge 0x4ebf
movq %r12, %r15
notq %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
leaq 0x10(%rsp), %rcx
callq 0x53e6
testq %rax, %rax
setne %dl
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
setne %sil
andb %dl, %sil
xorps %xmm0, %xmm0
cmpb $0x1, %sil
jne 0x4e90
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %rcx, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x35fc(%rip), %xmm0     # 0x8430
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
movaps %xmm1, %xmm0
addss 0x35b2(%rip), %xmm0     # 0x83f8
ucomiss 0x322b(%rip), %xmm1     # 0x8078
jbe 0x4e6b
andps 0x31ea(%rip), %xmm0     # 0x8040
movss 0x3216(%rip), %xmm2     # 0x8074
ucomiss %xmm0, %xmm2
movss 0x3587(%rip), %xmm0     # 0x83f0
jbe 0x4e90
cvtss2sd %xmm1, %xmm1
movsd 0x35a9(%rip), %xmm0     # 0x8420
subsd %xmm1, %xmm0
callq 0x2140
mulsd 0x35b0(%rip), %xmm0     # 0x8438
cvtsd2ss %xmm0, %xmm0
movq 0x8(%r14), %rbp
leaq (%r15,%rbp,2), %rax
imulq %r12, %rax
movq %rax, %rcx
shrq $0x3f, %rcx
addq %rax, %rcx
andq $-0x2, %rcx
addq %rcx, %rcx
addq 0x18(%r14), %rcx
movss %xmm0, (%rcx,%r13,4)
incq %r13
cmpq %rbp, %r13
jl 0x4de3
movq 0x8(%rsp), %r12
cmpq %rbp, %r12
jl 0x4dca
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/dist.c
// Function: NJ_PROTEIN_kimura_correction
void
NJ_PROTEIN_kimura_correction(DMAT *dmat,
			     NJ_alignment *alignment) {

  long int i, j;
  long int residues;
  long int diff;
  float dist;
  

  printf("NJ_PROTEIN_kimura_correction()\n");

  for(i=0;i<dmat->size;i++) {
    for(j=i+1;j<dmat->size;j++) {
      diff = NJ_pw_differences(alignment, i, j, &residues);
      
      if(!diff || !residues) {
	dist = 0.0;
      } else {
	dist = (float)diff/(float)residues;
      }
      
      if(NJ_FLT_LT(dist, 0.75)) {
	if(NJ_FLT_GT(dist, 0.0) ) {
	  dist = -log(1.0 - dist - (dist * dist/5.0) );
	}
      } else {
	if(NJ_FLT_GT(dist, 0.93) ) {
	  dist = 10.0; 
	} else {
	  dist = (float)NJ_dayhoff[ (int)((dist*1000.0)-750.0) ] / 100.0 ;
	}
      }
      
      dmat->val[NJ_MAP(i, j, dmat->size)] = dist;
    }
  }
  
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3478(%rip), %rdi      # 0x8585
callq 0x20b0
movq 0x8(%r14), %rbp
testq %rbp, %rbp
jle 0x52b0
xorl %r12d, %r12d
leaq 0x1(%r12), %r13
cmpq %rbp, %r13
movq %r13, 0x8(%rsp)
jge 0x52a2
movq %r12, %r15
notq %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
leaq 0x10(%rsp), %rcx
callq 0x53e6
testq %rax, %rax
setne %cl
movq 0x10(%rsp), %rdx
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
testq %rdx, %rdx
xorps %xmm0, %xmm0
cvtsi2ss %rdx, %xmm0
setne %al
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
andb %cl, %al
jne 0x517d
xorps %xmm0, %xmm0
movaps %xmm0, %xmm2
addss 0x3278(%rip), %xmm2     # 0x8400
movss 0x3264(%rip), %xmm3     # 0x83f4
ucomiss %xmm0, %xmm3
jbe 0x5210
andps 0x2ea4(%rip), %xmm2     # 0x8040
movss 0x2ed0(%rip), %xmm3     # 0x8074
ucomiss %xmm2, %xmm3
ja 0x5210
andps 0x2e90(%rip), %xmm1     # 0x8040
movss 0x2ebc(%rip), %xmm2     # 0x8074
ucomiss %xmm1, %xmm2
setbe %cl
ucomiss 0x3237(%rip), %xmm0     # 0x83fc
jbe 0x5273
andb %cl, %al
je 0x5273
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movsd 0x323e(%rip), %xmm2     # 0x8420
subsd %xmm1, %xmm2
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x325a(%rip), %xmm0     # 0x8450
addsd %xmm2, %xmm0
callq 0x2140
cvtsd2ss %xmm0, %xmm0
xorps 0x2e16(%rip), %xmm0     # 0x8020
movq 0x8(%r14), %rbp
jmp 0x5273
movaps %xmm0, %xmm1
addss 0x31e9(%rip), %xmm1     # 0x8404
ucomiss 0x31e6(%rip), %xmm0     # 0x8408
jbe 0x5242
andps 0x2e15(%rip), %xmm1     # 0x8040
movss 0x2e41(%rip), %xmm2     # 0x8074
ucomiss %xmm1, %xmm2
ja 0x5242
movss 0x31b0(%rip), %xmm0     # 0x83f0
jmp 0x5273
cvtss2sd %xmm0, %xmm0
mulsd 0x320a(%rip), %xmm0     # 0x8458
addsd 0x320a(%rip), %xmm0     # 0x8460
cvttsd2si %xmm0, %eax
cltq
leaq 0x7edd(%rip), %rcx      # 0xd140
xorps %xmm0, %xmm0
cvtsi2ssl (%rcx,%rax,4), %xmm0
divss 0x3199(%rip), %xmm0     # 0x840c
leaq (%r15,%rbp,2), %rax
imulq %r12, %rax
movq %rax, %rcx
shrq $0x3f, %rcx
addq %rax, %rcx
andq $-0x2, %rcx
addq %rcx, %rcx
addq 0x18(%r14), %rcx
movss %xmm0, (%rcx,%r13,4)
incq %r13
cmpq %rbp, %r13
jl 0x513b
movq 0x8(%rsp), %r12
cmpq %rbp, %r12
jl 0x5122
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/dist.c
// Function: NJ_no_correction
void
NJ_no_correction(DMAT *dmat,
		 NJ_alignment *alignment) {

  long int i, j;
  float pdiff;

  /* compute pairwise percent identity */
  for(i=0;i<dmat->size;i++) {
    for(j=i+1;j<dmat->size;j++) {
      pdiff = 1.0 - NJ_pw_percentid(alignment, i, j);      
      dmat->val[NJ_MAP(i, j, dmat->size)] = pdiff;
    }
  }
  
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rdi), %r13
testq %r13, %r13
jle 0x535c
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%r13,2), %rax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
leaq 0x1(%r15), %rax
movq %rax, 0x8(%rsp)
cmpq %r13, %rax
jge 0x5352
movq %r15, %rax
notq %rax
addq 0x10(%rsp), %rax
imulq %r15, %rax
movq %rax, %rbp
shrq $0x3f, %rbp
addq %rax, %rbp
addq %rbp, %rbp
andq $-0x4, %rbp
movq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x536b
movss 0x2d3f(%rip), %xmm1     # 0x8078
subss %xmm0, %xmm1
movq 0x18(%r14), %rax
addq %rbp, %rax
movss %xmm1, (%rax,%r12,4)
incq %r12
cmpq %r13, %r12
jl 0x5323
movq 0x8(%rsp), %r15
cmpq %r13, %r15
jne 0x52f0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/dist.c
// Function: NJ_pw_percentid
float
NJ_pw_percentid(NJ_alignment *alignment,
		long int x,
		long int y) {
  
  float pid;
  long int i;
  long int residues;
  long int same;
  char c1, c2;

  residues = 0;
  same     = 0;
  for(i=0;i<alignment->length;i++) {

    c1 = alignment->data[x*alignment->length+i];
    c2 = alignment->data[y*alignment->length+i];
    
    if( c1 != NJ_AMBIGUITY_CHAR ||
        c2 != NJ_AMBIGUITY_CHAR ) {
      
      residues++;

      if(c1 == c2) {
	same++;
      }
    }

  }

  pid = (float)same/(float)residues;
  
  return(pid);
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x53dd
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rcx
imulq %rax, %rsi
addq %rcx, %rsi
imulq %rax, %rdx
addq %rcx, %rdx
xorl %ecx, %ecx
xorl %edi, %edi
xorl %r8d, %r8d
movb (%rsi,%rcx), %r9b
movb (%rdx,%rcx), %r10b
movl %r9d, %r11d
xorb $0x3f, %r11b
movl %r10d, %ebx
xorb $0x3f, %bl
xorl %r14d, %r14d
orb %r11b, %bl
setne %r14b
cmpb %r10b, %r9b
sete %r9b
andb %r14b, %r9b
movzbl %r9b, %r9d
addq %r9, %r8
addq %r14, %rdi
incq %rcx
cmpq %rcx, %rax
jne 0x5390
cvtsi2ss %r8, %xmm0
cvtsi2ss %rdi, %xmm1
divss %xmm1, %xmm0
popq %rbx
popq %r14
retq
movss 0x302b(%rip), %xmm0     # 0x8410
retq
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/dist.c
// Function: NJ_pw_differences
long int
NJ_pw_differences(NJ_alignment *alignment,
		  long int x,
		  long int y,
		  long int *residues) {

  long int i;
  long int diff;
  char c1, c2;
  long int tmp_residues;
  
  diff         = 0;
  tmp_residues = 0;
  for(i=0;i<alignment->length;i++) {

    c1 = alignment->data[x*alignment->length+i];
    c2 = alignment->data[y*alignment->length+i];
    
    if( c1 != NJ_AMBIGUITY_CHAR ||
        c2 != NJ_AMBIGUITY_CHAR ) {
      
      tmp_residues++;

      if(c1 != c2) {
	diff++;
      }
    }

  }

  *residues = tmp_residues;

  return(diff);
}

// Assembly:
movq 0x8(%rdi), %r8
testq %r8, %r8
jle 0x544d
pushq %rbp
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rax
imulq %r8, %rsi
addq %rax, %rsi
imulq %r8, %rdx
addq %rax, %rdx
xorl %edi, %edi
xorl %r9d, %r9d
xorl %eax, %eax
movb (%rsi,%r9), %r10b
movb (%rdx,%r9), %r11b
movl %r10d, %ebx
xorb $0x3f, %bl
movl %r11d, %ebp
xorb $0x3f, %bpl
xorl %r14d, %r14d
orb %bl, %bpl
setne %r14b
cmpb %r11b, %r10b
setne %r10b
andb %r14b, %r10b
movzbl %r10b, %r10d
addq %r10, %rax
addq %r14, %rdi
incq %r9
cmpq %r9, %r8
jne 0x540c
popq %rbx
popq %r14
popq %rbp
jmp 0x5451
xorl %eax, %eax
xorl %edi, %edi
movq %rdi, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/fasta.c
// Function: NJ_taxaname_unique
int
NJ_taxaname_unique(NJ_alignment *alignment) {
  
  long int i, j;
  
  for(i=0;i<alignment->nseq;i++) {
    for(j=i+1;j<alignment->nseq;j++) {
        if(!strcmp(alignment->titles[i], 
		 alignment->titles[j])) {
	fprintf(stderr, "Clearcut: Taxa %ld and %ld (%s) do not have unique taxon labels.\n", 
		i, j, alignment->titles[i]);
	return(0);
      }
    }
  }
  
  return(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
movq (%rdi), %rbp
movl $0x1, %r14d
testq %rbp, %rbp
jle 0x664a
xorl %r15d, %r15d
movq %r15, %rbx
incq %r15
cmpq %rbp, %r15
jge 0x6619
movq (%rsp), %rax
movq 0x10(%rax), %r14
movq (%r14,%rbx,8), %r12
movq %r15, %r13
movq (%r14,%r13,8), %rsi
movq %r12, %rdi
callq 0x2170
testl %eax, %eax
je 0x6626
incq %r13
cmpq %rbp, %r13
jl 0x6601
cmpq %rbp, %r15
jne 0x65e7
movl $0x1, %r14d
jmp 0x664a
movq 0x69cb(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2437(%rip), %rsi      # 0x8a6e
xorl %r14d, %r14d
movq %rbx, %rdx
movq %r13, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x2180
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/fasta.c
// Function: NJ_free_alignment
void
NJ_free_alignment(NJ_alignment *alignment) {
  
  long int i;
  
  if(alignment) {

    /* free the allocated titles */
    if(alignment->titles) {
      for(i=0;i<alignment->nseq;i++) {

	if(alignment->titles[i]) {
	  free(alignment->titles[i]);
	}
      }
      
      free(alignment->titles);
    }

    /* free the alignment data */
    if(alignment->data) {
      free(alignment->data);
    }

    /* free the alignment itself */
    free(alignment);
  }

  return;
}

// Assembly:
testq %rdi, %rdi
je 0x66bf
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x66a2
movq (%rbx), %rax
testq %rax, %rax
jle 0x669d
xorl %r14d, %r14d
movq 0x10(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x6691
callq 0x2040
movq (%rbx), %rax
incq %r14
cmpq %rax, %r14
jl 0x667c
movq 0x10(%rbx), %rdi
callq 0x2040
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x66b0
callq 0x2040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/fasta.c
// Function: NJ_print_alignment
void
NJ_print_alignment(NJ_alignment *alignment) {
  
  long int i, j;
  
  printf("nseq = %ld, length = %ld\n", alignment->nseq, alignment->length);
  
  for(i=0;i<alignment->nseq;i++) {
    
    printf("> %s\n", alignment->titles[i]);

    for(j=0;j<alignment->length;j++) {
      printf("%c", alignment->data[i*alignment->length+j]);
    }

    printf("\n");
  }

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
leaq 0x237b(%rip), %rdi      # 0x8a54
xorl %eax, %eax
callq 0x2100
cmpq $0x0, (%rbx)
jle 0x673e
leaq 0x25ec(%rip), %r14      # 0x8cd9
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2100
movq 0x8(%rbx), %rax
testq %rax, %rax
jle 0x672c
xorl %r12d, %r12d
imulq %r15, %rax
addq 0x18(%rbx), %rax
movsbl (%r12,%rax), %edi
callq 0x2050
incq %r12
movq 0x8(%rbx), %rax
cmpq %rax, %r12
jl 0x670e
movl $0xa, %edi
callq 0x2050
incq %r15
cmpq (%rbx), %r15
jl 0x66f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/cmdargs.c
// Function: NJ_print_args
void
NJ_print_args(NJ_ARGS *nj_args) {
  
  char input_mode[32];
  
  switch (nj_args->input_mode) {
  case NJ_INPUT_MODE_DISTANCE:
    sprintf(input_mode, "Distance Matrix");
    break;
  case NJ_INPUT_MODE_UNALIGNED_SEQUENCES:
    sprintf(input_mode, "Unaligned Sequences");
    break;
  case NJ_INPUT_MODE_ALIGNED_SEQUENCES:
    sprintf(input_mode, "Aligned Sequences");
    break;
  default:
    sprintf(input_mode, "UNKNOWN");
    break;
  }

  printf("\n***  Command Line Arguments ***\n");
  
  printf("Input Mode: %s\n", input_mode);
  
  if(nj_args->stdin_flag) {
    printf("Input from STDIN\n");
  } else {
    printf("Input File: %s\n", nj_args->infilename);
  }

  if(nj_args->stdout_flag) {
    printf("Output from STDOUT\n");
  } else {
    printf("Output File: %s\n", nj_args->outfilename);
  }
  
  if(nj_args->input_mode != NJ_INPUT_MODE_DISTANCE) {
    if(nj_args->aligned_flag) {
      printf("Input Sequences Aligned: YES\n");
    } else {
      printf("Input Sequences Aligned:  NO\n");
    }
  }
  
  if(nj_args->verbose_flag) {
    printf("Verbose Mode: ON\n");
  } else {
    printf("Verbose Mode: OFF\n");
  }
  
  if(nj_args->quiet_flag) {
    printf("Quiet Mode: ON\n");
  } else {
    printf("Quiet Mode: OFF\n");
  }
  
  if(nj_args->seed) {
    printf("Random Seed: %d\n", nj_args->seed);
  }
  
  printf("\n*******\n");
  
  return;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x18(%rdi), %eax
cmpl $0x66, %eax
je 0x6e88
cmpl $0x65, %eax
je 0x6e73
cmpl $0x64, %eax
jne 0x6e9c
movups 0x222b(%rip), %xmm0     # 0x9098
movaps %xmm0, (%rsp)
jmp 0x6eaa
movups 0x222e(%rip), %xmm0     # 0x90a8
movaps %xmm0, (%rsp)
movl $0x736563, 0x10(%rsp)   # imm = 0x736563
jmp 0x6eaa
movups 0x222d(%rip), %xmm0     # 0x90bc
movaps %xmm0, (%rsp)
movw $0x73, 0x10(%rsp)
jmp 0x6eaa
movabsq $0x4e574f4e4b4e55, %rax # imm = 0x4E574F4E4B4E55
movq %rax, (%rsp)
leaq 0x291e(%rip), %rdi      # 0x97cf
callq 0x20b0
leaq 0x2211(%rip), %rdi      # 0x90ce
movq %rsp, %rsi
xorl %eax, %eax
callq 0x2100
cmpl $0x0, 0x28(%rbx)
je 0x6edb
leaq 0x291c(%rip), %rdi      # 0x97f0
callq 0x20b0
jmp 0x6eec
movq (%rbx), %rsi
leaq 0x21f9(%rip), %rdi      # 0x90de
xorl %eax, %eax
callq 0x2100
cmpl $0x0, 0x2c(%rbx)
je 0x6f00
leaq 0x2908(%rip), %rdi      # 0x9801
callq 0x20b0
jmp 0x6f12
movq 0x8(%rbx), %rsi
leaq 0x21e3(%rip), %rdi      # 0x90ee
xorl %eax, %eax
callq 0x2100
cmpl $0x64, 0x18(%rbx)
je 0x6f33
cmpl $0x0, 0x1c(%rbx)
leaq 0x28f1(%rip), %rax      # 0x9814
leaq 0x2907(%rip), %rdi      # 0x9831
cmoveq %rax, %rdi
callq 0x20b0
cmpl $0x0, 0x20(%rbx)
leaq 0x2910(%rip), %rax      # 0x984e
leaq 0x291b(%rip), %rdi      # 0x9860
cmoveq %rax, %rdi
callq 0x20b0
cmpl $0x0, 0x24(%rbx)
leaq 0x2918(%rip), %rax      # 0x9871
leaq 0x2921(%rip), %rdi      # 0x9881
cmoveq %rax, %rdi
callq 0x20b0
movl 0x48(%rbx), %esi
testl %esi, %esi
je 0x6f7e
leaq 0x2188(%rip), %rdi      # 0x90ff
xorl %eax, %eax
callq 0x2100
leaq 0x290b(%rip), %rdi      # 0x9890
callq 0x20b0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/prng.c
// Function: NJ_genrand_int31_top
long int
NJ_genrand_int31_top(long int top) {

  long int overflow;
  long int r;
  long int retval;

  if(top <= 0) {
    return(0); 
  } else {
    overflow = (NJ_RAND_MAX / top) * top;
  }
  
  while(1) {
    r = genrand_int31();
    if(r < overflow) {
      break;
    }
  }
  
  retval = r % top;
  
  return(retval);
}

// Assembly:
testq %rdi, %rdi
jle 0x7387
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rdi
movq %rdx, %r14
xorq %rcx, %r14
callq 0x70e7
shrq %rax
cmpq %r14, %rax
jae 0x736a
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/getopt_long.c
// Function: insert_argv
static int
insert_argv(char **argv, int src, int dest)
{
    int i;
    char *tmp = argv[src];

    if (src > dest) {
        for (i = src; i > dest; i--)
            argv[i] = argv[i-1];
    }
    if (src < dest) {
        for (i = src; i < dest; i++)
            argv[i] = argv[i+1];
    }

    argv[dest] = tmp;

    return 0;
}

// Assembly:
movslq %esi, %rcx
movq (%rdi,%rcx,8), %rax
movslq %edx, %r8
cmpl %edx, %ecx
jle 0x796c
movq %rcx, %r9
movq -0x8(%rdi,%r9,8), %r10
movq %r10, (%rdi,%r9,8)
decq %r9
cmpq %r8, %r9
jg 0x795b
cmpl %edx, %esi
jge 0x7985
movq 0x8(%rdi,%rcx,8), %rdx
movq %rdx, (%rdi,%rcx,8)
leaq 0x1(%rcx), %rdx
movq %rdx, %rcx
cmpq %rdx, %r8
jne 0x7970
movq %rax, (%rdi,%r8,8)
retq
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/getopt_long.c
// Function: has_argument_short
static int
has_argument_short(char *arg, const char *shortopts)
{
    int i;
    int open_bracket = 0;
    for (i = 0; shortopts[i]; i++) {
        switch (shortopts[i]) {
        case '[':
            open_bracket++;
            continue;
        case ']':
            if (open_bracket <= 0) {
                fprintf(stderr, "getopt_long() -- unbalanced bracket in short options");
                return -1;
            }
            open_bracket--;
            continue;
        }
        if (open_bracket) continue;
        if (*arg != shortopts[i]) continue;

        switch (shortopts[i+1]) {
        case ':':
            if (shortopts[i+2] != ':') {
                if (arg[1])
                    return 1; /* following string is argument */
                else
                    return 2; /* next argv is argument */
            }
            else {
                /* '::' means optional argument (GNU extention) */
                if (arg[1])
                    return 1;
                else
                    return 0; /* no argument */
            }
        case '[':
            if (arg[1] == '\0')
                return 0;   /* no argument */
            /* my extention */
            for (i++; shortopts[i] && shortopts[i] != ']'; i++) {
                if (arg[1] == shortopts[i])
                    return 3; /* has 1 byte argument */
            }
            if (!shortopts[i]) {
                fprintf(stderr, "getopt_long() -- unbalanced bracket in short options");
                return -1;
            }
            break;
        default:
            return 0;   /* no argument */
        }
    }
    /* Invalid option */
    return -1;
}

// Assembly:
pushq %rax
leaq 0x1(%rsi), %rcx
xorl %edx, %edx
xorl %r8d, %r8d
movslq %edx, %r9
movzbl (%rsi,%r9), %r10d
cmpl $0x5b, %r10d
je 0x7a0c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x5d, %r10d
je 0x7a02
testl %r10d, %r10d
je 0x7a1d
testl %r8d, %r8d
jne 0x7a0f
xorl %r8d, %r8d
cmpb %r10b, (%rdi)
jne 0x7a0f
movzbl 0x1(%rsi,%r9), %edx
xorl %eax, %eax
cmpl $0x5b, %edx
jne 0x7a1f
movb 0x1(%rdi), %r8b
testb %r8b, %r8b
je 0x7a1d
incq %r9
movq %r9, %rax
addq %rcx, %rax
movb $0x5b, %r10b
movl %r9d, %edx
cmpb $0x5d, %r10b
je 0x7a13
movzbl %r10b, %r9d
testl %r9d, %r9d
je 0x7a38
cmpb %r10b, %r8b
je 0x7a18
movb (%rax), %r10b
incl %edx
incq %rax
jmp 0x79e4
testl %r8d, %r8d
jle 0x7a49
decl %r8d
jmp 0x7a0f
incl %r8d
incl %edx
jmp 0x7994
xorl %r8d, %r8d
jmp 0x7a0f
movl $0x3, %eax
popq %rcx
retq
cmpl $0x3a, %edx
jne 0x7a1d
cmpb $0x3a, 0x2(%rsi,%r9)
movb 0x1(%rdi), %cl
jne 0x7a3f
xorl %eax, %eax
testb %cl, %cl
setne %al
jmp 0x7a1d
callq 0x2a32
jmp 0x7a4e
xorl %eax, %eax
cmpb $0x1, %cl
adcl $0x1, %eax
jmp 0x7a1d
callq 0x2a16
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x7a1d
// File: /workspace/github_c_makefile_star2_O3/sheneman[P]clearcut/getopt_long.c
// Function: search_longopt
static int
search_longopt(char *arg, struct option *longopts)
{
    int i, found = -1;
    int len;
    for (len = 0; arg[len] && arg[len] != '='; len++)
        ;

    for (i = 0; longopts[i].name; i++) {
        if (strncmp(arg, longopts[i].name, len) == 0) {
            if (found != -1)
                return -1;      /* found some candidate */
            found = i;
        }
    }
    return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movzbl (%r14,%r15), %eax
testl %eax, %eax
je 0x7a79
cmpl $0x3d, %eax
je 0x7a79
incq %r15
jmp 0x7a66
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x7ab5
addq $0x20, %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rdx
callq 0x2080
testl %eax, %eax
jne 0x7aa4
cmpl $-0x1, %ebp
movl %r12d, %ebp
jne 0x7ab5
movq (%rbx), %rsi
incl %r12d
addq $0x20, %rbx
testq %rsi, %rsi
jne 0x7a8d
jmp 0x7aba
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_control.c
// Function: bcore_ext_wrn
void bcore_ext_wrn( sc_t func, sc_t file, int line, sc_t format, ... )
{
    fprintf( stderr, "warning:%s:%i:0 in function %s:\n", file, line, func );
    va_list args;
    va_start( args, format );
    vfprintf( stderr, format, args );
    va_end( args );
    fprintf( stderr, "\n" );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rcx, %rbx
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %r10
testb %al, %al
je 0xd653
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)
leaq 0x20(%rsp), %r14
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
movq 0x180979(%rip), %r15    # 0x18dfe0
movq (%r15), %rdi
leaq 0x135d57(%rip), %rsi    # 0x1433c8
movq %r10, %r8
xorl %eax, %eax
callq 0xd430
movq %rsp, %rdx
movq %r14, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000020, %rax     # imm = 0x3000000020
movq %rax, (%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0xd1e0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0xd200
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/lib/bcore/bcore_sinks.c
// Function: bcore_sink_stderr_s_push_data
uz_t bcore_sink_stderr_s_push_data( bcore_sink_stderr_s* o, vc_t data, uz_t size )
{
    st_s* msg = st_s_create_sc_n( data, size );
    fprintf( stderr, "%s", msg->sc );
    st_s_discard( msg );
    return size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x109e7c
movq %rax, %r14
movq 0x180854(%rip), %rax    # 0x18dfe0
movq (%rax), %rsi
movq 0x8(%r14), %rdi
callq 0xd2b0
movq %r14, %rdi
callq 0x10a028
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_parse_fa
er_t xoico_parse_fa( xoico* o, const xoico_host* host, sc_t format, ... )
{
    // xoico.x:125:1
    BLM_INIT_LEVEL(0);
    va_list args;
    va_start( args, format );
    er_t ret = xoico_a_parse(o,host, ((x_source*)BLM_LEVEL_A_PUSH(0,x_source_create_from_fv(format, args ))) );
    va_end( args );
    BLM_RETURNV(er_t, ret)
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testb %al, %al
je 0xdffa
movaps %xmm0, 0x80(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm2, 0xa0(%rsp)
movaps %xmm3, 0xb0(%rsp)
movaps %xmm4, 0xc0(%rsp)
movaps %xmm5, 0xd0(%rsp)
movaps %xmm6, 0xe0(%rsp)
movaps %xmm7, 0xf0(%rsp)
leaq 0x50(%rsp), %r13
movq %rcx, 0x18(%r13)
movq %r8, 0x20(%r13)
movq %r9, 0x28(%r13)
leaq 0x18ddbe(%rip), %rax    # 0x19bdd0
movq (%rax), %rsi
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xd6675
movq $0x0, 0x10(%r12)
movq %rsp, %rsi
movq %r13, 0x10(%rsi)
leaq 0x130(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rsi)
movq %r15, %rdi
callq 0xe46d4
movq %r12, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0xd6b17
movq %rax, %r15
movq (%r14), %r12
leaq 0x18441b(%rip), %rax    # 0x192488
movl 0x184415(%rip), %ecx    # 0x192488
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r12, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0xe0c7
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xe0c7
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xe0c7
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xe0d0
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0xe0f7
movabsq $0x5d91f496b6479859, %rdi # imm = 0x5D91F496B6479859
movq %r12, %rsi
callq 0xe9bc5
movq %rax, %r13
leaq 0x18439c(%rip), %rdi    # 0x192488
movq %r12, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *0x28(%r13)
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xd6d2c
movq %rbx, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_compiler_s_nameof
sc_t xoico_compiler_s_nameof( const xoico_compiler_s* o, tp_t type )
{
    // xoico_compiler.x:295:5
    
    sc_t name = bcore_hmap_name_s_get_sc(&(o->name_map),type );
    if( !name ) name = ifnameof( type );
    return  name;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
addq $0x140, %rdi            # imm = 0x140
callq 0xd3dbe
testq %rax, %rax
jne 0xe405
movq %rbx, %rdi
callq 0xd6ec4
movq %rax, %rcx
testq %rax, %rax
leaq 0x13a314(%rip), %rax    # 0x148715
cmovneq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_name_s_parse
BCORE_DEFINE_OBJECT_INST_P_NASC_END( xoico_name_s )

er_t xoico_name_s_parse( xoico_name_s* o, const xoico_host* host, x_source* source )
{
    // xoico_name.x:24:5
    
    x_source_point_s_setup_from_source(&(o->source_point),source );
    BLM_TRY(xoico_host_a_parse_name_tp(host,source, (&(o->name)) ))
    //source.parse_fa( " ; " );
    return  0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %r12
movq %rdx, %rdi
callq 0xbe7e4
movq %r12, %rdi
movq %rax, %rsi
callq 0x242ed
movq (%rbx), %r12
leaq 0x18e370(%rip), %rax    # 0x19ccc8
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r12, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0xe9ae
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xe9ae
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xe9ae
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xe9b7
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0xe9de
movabsq $-0x7e8ee9b9b4bbaa8, %rdi # imm = 0xF817116464B44558
movq %r12, %rsi
callq 0xe9bc5
movq %rax, %r13
leaq 0x18e2f5(%rip), %rdi    # 0x19ccc8
movq %r12, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r13, %rdi
movq %rbx, %rsi
callq 0xffe72
movq %rax, 0x20(%r14)
addq $0x8, %r14
movq (%r15), %r12
leaq 0x183ca5(%rip), %rax    # 0x1926a0
movl 0x183c9f(%rip), %ecx    # 0x1926a0
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r12, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0xea55
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xea55
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xea55
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xea5e
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0xea85
movabsq $-0x1e682f89ce03d7c8, %rdi # imm = 0xE197D07631FC2838
movq %r12, %rsi
callq 0xe9bc5
movq %rax, %r13
leaq 0x183c26(%rip), %rdi    # 0x1926a0
movq %r12, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x18(%r13)
movq %rax, %rbx
testq %rax, %rax
je 0xeaa9
leaq 0x18d32f(%rip), %rax    # 0x19bdd0
movq (%rax), %rdi
callq 0xd6d2c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_forward_s_parse
BCORE_DEFINE_OBJECT_INST_P_NASC_END( xoico_forward_s )

er_t xoico_forward_s_parse( xoico_forward_s* o, const xoico_host* host, x_source* source )
{
    // xoico_forward.x:27:5
    
    x_source_point_s_setup_from_source(&(o->source_point),source );
    BLM_TRY(xoico_host_a_parse_name_tp(host,source, (&(o->name)) ))
    //source.parse_fa( " ; " );
    return  0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rdi), %r12
movq %rdx, %rdi
callq 0xbe7e4
movq %r12, %rdi
movq %rax, %rsi
callq 0x242ed
movq (%rbx), %r12
leaq 0x18d8e0(%rip), %rax    # 0x19ccc8
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r12, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0xf43e
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xf43e
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xf43e
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xf447
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0xf46e
movabsq $-0x7e8ee9b9b4bbaa8, %rdi # imm = 0xF817116464B44558
movq %r12, %rsi
callq 0xe9bc5
movq %rax, %r13
leaq 0x18d865(%rip), %rdi    # 0x19ccc8
movq %r12, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r13, %rdi
movq %rbx, %rsi
callq 0xffe72
movq %rax, 0x28(%r14)
addq $0x8, %r14
movq (%r15), %r12
leaq 0x183215(%rip), %rax    # 0x1926a0
movl 0x18320f(%rip), %ecx    # 0x1926a0
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r12, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0xf4e5
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0xf4e5
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0xf4e5
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0xf4ee
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0xf515
movabsq $-0x1e682f89ce03d7c8, %rdi # imm = 0xE197D07631FC2838
movq %r12, %rsi
callq 0xe9bc5
movq %rax, %r13
leaq 0x183196(%rip), %rdi    # 0x1926a0
movq %r12, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x18(%r13)
movq %rax, %rbx
testq %rax, %rax
je 0xf539
leaq 0x18c89f(%rip), %rax    # 0x19bdd0
movq (%rax), %rdi
callq 0xd6d2c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_typespec_s_convert_transient_types
er_t xoico_typespec_s_convert_transient_types( xoico_typespec_s* o, const xoico_host* host, const xoico_transient_map_s* map )
{
    // xoico_typespec.x:78:5
    
    if( o->transient )
    {
        tp_t type = xoico_transient_map_s_get(map,o->transient->class );
        if( type ) o->type = type;
    }
    return  0;
}

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x1022d
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rax), %rsi
addq $0x8, %rdx
movq %rdx, %rdi
callq 0xc9f2a
testq %rax, %rax
je 0x1022c
movq (%rax), %rax
testq %rax, %rax
je 0x1022c
movq %rax, 0x8(%rbx)
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_typespec_s_is_ptr_type
bl_t xoico_typespec_s_is_ptr_type( const xoico_typespec_s* o )
{
    // xoico_typespec.x:423:1
    
    return  o->type == TYPEOF_vd_t ||
           o->type == TYPEOF_vc_t ||
           o->type == TYPEOF_sc_t ||
           o->type == TYPEOF_sd_t;
}

// Assembly:
movq 0x8(%rdi), %rcx
movb $0x1, %al
movabsq $0x54de8100f7c1cbe4, %rdx # imm = 0x54DE8100F7C1CBE4
cmpq %rdx, %rcx
jg 0x12202
movabsq $-0x84b14e74a9e1ff0, %rdx # imm = 0xF7B4EB18B561E010
cmpq %rdx, %rcx
je 0x12220
movabsq $0x230abe18cdeefc99, %rdx # imm = 0x230ABE18CDEEFC99
jmp 0x1221b
movabsq $0x54de8100f7c1cbe5, %rdx # imm = 0x54DE8100F7C1CBE5
cmpq %rdx, %rcx
je 0x12220
movabsq $0x6f0b060106a30da4, %rdx # imm = 0x6F0B060106A30DA4
cmpq %rdx, %rcx
jne 0x12221
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_transient_map_s_copy
BCORE_DEFINE_OBJECT_INST_P_NASC_END( xoico_transient_map_s )

bcore_arr_tp_s* xoico_transient_map_s_create_key_arr( const xoico_transient_map_s* o )
{
    // xoico_transient_map.x:33:5
    
    bcore_arr_tp_s* arr_tp = bcore_arr_tp_s_create();
    sz_t size = bcore_hmap_tptp_s_size(&(o->map));
    for(sz_t i = 0; i < size; i++ ) if( bcore_hmap_tptp_s_idx_key(&(o->map),i ) ) bcore_arr_tp_s_push(arr_tp,bcore_hmap_tptp_s_idx_key(&(o->map),i ) );
    return  arr_tp;
}

// Assembly:
cmpq %rsi, %rdi
je 0x12456
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x2d2648b9bef99573, %r15 # imm = 0x2D2648B9BEF99573
leaq 0x18a0b6(%rip), %rax    # 0x19c468
movl (%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r15, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r15, %rdx
je 0x12408
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r15, %rdx
je 0x12408
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r15, %rdx
je 0x12408
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r15, %rdx
jne 0x12411
movq (%rax,%rcx), %r12
testq %r12, %r12
jne 0x12438
movabsq $0x782b96602f424981, %rdi # imm = 0x782B96602F424981
movq %r15, %rsi
callq 0xe9bc5
movq %rax, %r12
leaq 0x18a03b(%rip), %rdi    # 0x19c468
movq %r15, %rsi
movq %rax, %rdx
callq 0x115fac
movq 0x90(%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_transient_map_s_update
xoico_transient_map_s* xoico_transient_map_s_update( xoico_transient_map_s* o, const xoico_transient_map_s* src )
{
    // xoico_transient_map.x:44:1
    
    for(sz_t i = 0; i < bcore_hmap_tptp_s_size(&(src->map)); i++ )
    {
        tp_t key = bcore_hmap_tptp_s_idx_key(&(src->map),i );
        if( key ) bcore_hmap_tptp_s_set(&(o->map),key, bcore_hmap_tptp_s_idx_val(&(src->map),i ) );
    }
    return o;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %r14
movq %r14, %rdi
callq 0xca34d
testq %rax, %rax
je 0x1274a
leaq 0x8(%rbx), %r15
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0xca352
testq %rax, %rax
je 0x1273a
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0xca35f
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0xca10b
incq %r12
movq %r14, %rdi
callq 0xca34d
cmpq %rax, %r12
jb 0x1270e
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_arg_s_expand
er_t xoico_arg_s_expand( const xoico_arg_s* o, const xoico_host* host, x_sink* sink )
{
    // xoico_arg.x:86:1
    
    BLM_TRY(xoico_typespec_s_expand(&(o->typespec),host, sink ) )
    if( o->name )
    {
        x_sink_push_fa(sink," " );
        BLM_TRY(xoico_arg_s_expand_name(o,host, sink ))
    }
    return  0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x20, %rdi
callq 0x11760
cmpq $0x0, 0x50(%r15)
je 0x134cb
leaq 0x13053a(%rip), %rsi    # 0x1439ed
movq %rbx, %rdi
xorl %eax, %eax
callq 0xed3f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x134d3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_arg_s_expand_name
er_t xoico_arg_s_expand_name( const xoico_arg_s* o, const xoico_host* host, x_sink* sink )
{
    // xoico_arg.x:112:1
    
    if( !o->name ) return  0;
    x_sink_push_fa(sink,"#<sc_t>", xoico_compiler_s_nameof(xoico_host_a_compiler(host),o->name ) );
    return  0;
}

// Assembly:
cmpq $0x0, 0x50(%rdi)
je 0x135b4
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %r12
leaq 0x17f1a6(%rip), %rax    # 0x1926a0
movl 0x17f1a0(%rip), %ecx    # 0x1926a0
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movq 0x18(%rax,%rcx,8), %rcx
andq %r12, %rcx
shlq $0x4, %rcx
leaq (%rdx,%rcx), %rax
movq (%rdx,%rcx), %rdx
movl $0x8, %ecx
cmpq %r12, %rdx
je 0x13554
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r12, %rdx
je 0x13554
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r12, %rdx
je 0x13554
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r12, %rdx
jne 0x1355d
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0x13584
movabsq $-0x1e682f89ce03d7c8, %rdi # imm = 0xE197D07631FC2838
movq %r12, %rsi
callq 0xe9bc5
movq %rax, %r13
leaq 0x17f127(%rip), %rdi    # 0x1926a0
movq %r12, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r15, %rdi
callq *0x20(%r13)
movq 0x50(%r14), %rsi
movq %rax, %rdi
callq 0xe3d7
leaq 0x1316d7(%rip), %rsi    # 0x144c75
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xed3f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_arg_s_expand_x
er_t xoico_arg_s_expand_x( const xoico_arg_s* o, const xoico_host* host, x_sink* sink )
{
    // xoico_arg.x:99:1
    
    BLM_TRY(xoico_typespec_s_expand_x(&(o->typespec),host, sink ) )
    if( o->name )
    {
        x_sink_push_fa(sink," " );
        BLM_TRY(xoico_arg_s_expand_name(o,host, sink ))
    }
    return  0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x20, %rdi
callq 0x11ac2
cmpq $0x0, 0x50(%r15)
je 0x135f4
leaq 0x130411(%rip), %rsi    # 0x1439ed
movq %rbx, %rdi
xorl %eax, %eax
callq 0xed3f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x134d3
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_args_s_append
BCORE_DEFINE_OBJECT_INST_P_NASC_END( xoico_args_s )

er_t xoico_args_s_append( xoico_args_s* o, const xoico_host* host, x_source* source )
{
    // xoico_args.x:33:1
    BLM_INIT_LEVEL(0);
    bl_t first = true;
    while( !x_source_parse_bl(source," #=?')' " ) ) // args follow
    {
        if( xoico_args_s_is_variadic(o) ) BLM_RETURNV(er_t, x_source_parse_error_fa(source,"Cannot append to variadic argument list." ))
        if( !first ) BLM_TRY(xoico_parse_f(source, " , " ))
        xoico_arg_s* arg = ((xoico_arg_s*)BLM_LEVEL_T_PUSH(0,xoico_arg_s,xoico_arg_s_create()));
        BLM_TRY(xoico_arg_s_parse(arg,host, source ))
        x_array_push_d(((x_array*)(o)),((x_inst*)(((xoico_arg_s*)bcore_fork(arg)) )));
        first = false;
    }
    BLM_RETURNV(er_t, 0)
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, (%rsp)
movq %rdi, %r12
leaq 0x1880c0(%rip), %rax    # 0x19bdd0
movq (%rax), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xd6675
movq $0x0, 0x10(%r14)
movb $0x1, %r15b
leaq 0x188f96(%rip), %rbp    # 0x19ccc8
movq (%rbx), %r14
movl (%rbp), %eax
cltq
leaq (%rax,%rax,2), %rax
movq 0x20(%rbp,%rax,8), %rcx
movq 0x18(%rbp,%rax,8), %rdx
andq %r14, %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movq (%rcx,%rdx), %rdx
movl $0x8, %ecx
cmpq %r14, %rdx
je 0x13d8b
movq 0x10(%rax), %rdx
movl $0x18, %ecx
cmpq %r14, %rdx
je 0x13d8b
movq 0x20(%rax), %rdx
movl $0x28, %ecx
cmpq %r14, %rdx
je 0x13d8b
movq 0x30(%rax), %rdx
movl $0x38, %ecx
cmpq %r14, %rdx
jne 0x13d94
movq (%rax,%rcx), %r13
testq %r13, %r13
jne 0x13db7
movabsq $-0x7e8ee9b9b4bbaa8, %rdi # imm = 0xF817116464B44558
movq %r14, %rsi
callq 0xe9bc5
movq %rax, %r13
movq %rbp, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x115fac
movq %r13, %rdi
movq %rbx, %rsi
leaq 0x1196b9(%rip), %rdx    # 0x12d47d
callq 0xffe2b
testb %al, %al
jne 0x13e5b
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x13deb
movq 0x8(%r12), %rcx
movq -0x8(%rcx,%rax,8), %rax
cmpb $0x1, 0x4f(%rax)
je 0x13e5f
testb $0x1, %r15b
jne 0x13e07
movq %rbx, %rdi
leaq 0x119562(%rip), %rsi    # 0x12d35d
xorl %eax, %eax
callq 0xda80
testq %rax, %rax
jne 0x13e70
callq 0x12dab
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movabsq $-0x21883bf5398e4338, %rdx # imm = 0xDE77C40AC671BCC8
movq %rax, %rcx
callq 0xd68a8
movq %rax, %r14
movq %rax, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq 0x12fd2
testq %rax, %rax
jne 0x13e70
movq %r14, %rdi
callq 0xbe7e4
movq (%r12), %rsi
movq %r12, %rdi
movq %rax, %rdx
callq 0x55b79
xorl %r15d, %r15d
jmp 0x13d32
xorl %ebx, %ebx
jmp 0x13e73
leaq 0x119620(%rip), %rsi    # 0x12d486
movq %rbx, %rdi
xorl %eax, %eax
callq 0xde10
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xd6d2c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/johsteffens[P]beth/xoico/src/xoico.xo.c
// Function: xoico_args_s_expand
er_t xoico_args_s_expand( const xoico_args_s* o, const xoico_host* host, bl_t first, x_sink* sink )
{
    // xoico_args.x:66:1
    
    {const xoico_args_s* __a=o ;if(__a)for(sz_t __i=0;__i<__a->size;__i++){xoico_arg_s* arg=__a->data[__i];
    {
        if( !first ) x_sink_push_fa(sink,", " );
        first = false;
        BLM_TRY(xoico_arg_s_expand(arg,host, sink ))
    }
    }}return  0;
}

// Assembly:
testq %rdi, %rdi
je 0x13fce
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
cmpq $0x0, 0x10(%rdi)
je 0x13fc0
movq %rcx, %rbx
movq %rsi, %r14
leaq 0x1193d3(%rip), %r12    # 0x12d35e
xorl %ebp, %ebp
movq 0x8(%r15), %rax
movq (%rax,%rbp,8), %r13
testb $0x1, %dl
jne 0x13fa7
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0xed3f
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1348e
incq %rbp
xorl %edx, %edx
cmpq 0x10(%r15), %rbp
jb 0x13f8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq