LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/rouming[P]io/io-test.c
// Function: on_read_vari_len_req1_1__slave_from_master
static int on_read_vari_len_req1_1__slave_from_master(struct io_req *req, int len)
{
	int nb, rc, stashed;
	char msg[len], *str;
	struct io_req *s_m_req;
	struct loop_ctx *ctx = req->data;

	nb = buf_memcpy_to(&req->buf, 0, msg, len);
	assert(nb == len);

	str = memmem(msg, nb, "</msg>", 6);
	if (str == NULL)
		return 0;

	nb = str - msg + strlen("</msg>");
	stashed = len - nb;
	len = nb;
	printf(" VARI LEN MSG 1: stashed=%2d, len=%2d, msg='%.*s'\n",
	       stashed, len, len, msg);
	io_req_put(req);

	/* Read slave<-master, part2 */
	s_m_req = io_req_create(&ctx->slave, REQ_RD, ctx,
				on_read_vari_len_req1_2__slave_from_master);
	s_m_req->buf = (struct io_buf){
		.iov[0] = {
			.iov_base = NULL,
			.iov_len  = 0
		},
		.iov_num  = 1,
		.is_vari_len = true
	};
	rc = io_queue_submit(s_m_req);
	assert(rc == 0);

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, %eax
movq %rsp, %r13
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
movq 0x18(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
movslq %esi, %r12
xorl %r14d, %r14d
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
callq 0x2dca
cmpl %r12d, %eax
jne 0x1e53
leaq 0x3541(%rip), %rdx      # 0x52de
pushq $0x6
popq %rcx
movq %r13, %rdi
movq %r12, %rsi
callq 0x1120
testq %rax, %rax
je 0x1e41
movq %rax, %r12
subl %r13d, %r12d
addl $0x6, %r12d
subl %r12d, %r15d
leaq 0x35a6(%rip), %rdi      # 0x536e
movl %r15d, %esi
movl %r12d, %edx
movl %r12d, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x1090
movq %rbx, %rdi
callq 0x3cd7
movq -0x30(%rbp), %rdx
leaq 0x178(%rdx), %rdi
leaq 0x1ea(%rip), %rcx       # 0x1fdf
xorl %esi, %esi
callq 0x3c44
movq %rax, %rbx
leaq 0x28(%rax), %rdi
movl $0x120, %edx            # imm = 0x120
xorl %esi, %esi
callq 0x10b0
movq $0x1, 0x148(%rbx)
movb $0x1, 0x150(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x151(%rbx)
movups %xmm0, 0x160(%rbx)
movq %rbx, %rdi
callq 0x39b9
movl %r12d, %r14d
testl %eax, %eax
jne 0x1e72
movl %r14d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3359(%rip), %rdi      # 0x51b3
leaq 0x31ac(%rip), %rsi      # 0x500d
leaq 0x34c1(%rip), %rcx      # 0x5329
movl $0xf9, %edx
callq 0x10a0
leaq 0x323c(%rip), %rdi      # 0x50b5
leaq 0x318d(%rip), %rsi      # 0x500d
leaq 0x34a2(%rip), %rcx      # 0x5329
movl $0x112, %edx            # imm = 0x112
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/rouming[P]io/io-test.c
// Function: on_write_vari_len_req1_2__master_to_slave
static int on_write_vari_len_req1_2__master_to_slave(struct io_req *req, int len)
{
	int rc;
	struct io_req *m_s_req3;
	struct loop_ctx *ctx = req->data;

	assert(len > 0);
	io_req_put(req);

	/* Write master->slave, part3 */
	m_s_req3 = io_req_create(&ctx->master, REQ_WR, ctx,
				 on_write_vari_len_req1_3__master_to_slave);
	assert(m_s_req3);
	m_s_req3->buf = (struct io_buf){
		.iov[0] = {
			.iov_base = "2 vari",
			.iov_len  = strlen("2 vari")
		},
		.iov[1] = {
			.iov_base = " length 2",
			.iov_len  = strlen(" length 2")
		},
		.iov[2] = {
			.iov_base = "</msg>",
			.iov_len  = strlen("</msg>")
		},
		/* Data for next action */
		.iov[3] = {
			.iov_base = "GARBAGE<msg>3 vari length 3</msg>",
			.iov_len  = strlen("GARBAGE<msg>3 vari length 3</msg>"),
		},
		.iov_num  = 4,
		.is_vari_len = false
	};
	rc = io_queue_submit(m_s_req3);
	assert(rc == 0);

	return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
testl %esi, %esi
jle 0x1f53
movl %esi, %ebx
movq 0x18(%rdi), %r14
callq 0x3cd7
leaq 0xf7(%rip), %rcx        # 0x1fb0
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r14, %rdx
callq 0x3c44
testq %rax, %rax
je 0x1f72
movq %rax, %r14
movq %rax, %r15
addq $0x28, %r15
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %r12
movups %xmm0, 0x110(%r12)
movups %xmm0, 0x100(%r12)
leaq 0x6dfd(%rip), %rsi      # 0x8cf8
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
callq 0x1140
movl $0x120, %edx            # imm = 0x120
movq %r15, %rdi
movq %r12, %rsi
callq 0x1140
movq $0x4, 0x148(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r14)
movups %xmm0, 0x160(%r14)
movq %r14, %rdi
callq 0x39b9
testl %eax, %eax
jne 0x1f91
movl %ebx, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x31b1(%rip), %rdi      # 0x510b
leaq 0x30ac(%rip), %rsi      # 0x500d
leaq 0x32fd(%rip), %rcx      # 0x5265
movl $0x9a, %edx
callq 0x10a0
leaq 0x3330(%rip), %rdi      # 0x52a9
leaq 0x308d(%rip), %rsi      # 0x500d
leaq 0x32de(%rip), %rcx      # 0x5265
movl $0xa0, %edx
callq 0x10a0
leaq 0x311d(%rip), %rdi      # 0x50b5
leaq 0x306e(%rip), %rsi      # 0x500d
leaq 0x32bf(%rip), %rcx      # 0x5265
movl $0xb7, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/rouming[P]io/io-test.c
// Function: on_read_vari_len_req1_2__slave_from_master
static int on_read_vari_len_req1_2__slave_from_master(struct io_req *req, int len)
{
	int nb, stashed;
	char msg[len + 1], *str;

	nb = buf_memcpy_to(&req->buf, 0, msg, len);
	assert(nb == len);

	str = memmem(msg, nb, "</msg>", 6);
	if (str == NULL)
		return 0;

	nb = str - msg + strlen("</msg>");
	stashed = len - nb;
	len = nb;
	printf("   VARI LEN MSG 2: stashed=%2d, len=%2d, msg='%.*s'\n",
	       stashed, len, len, msg);
	io_req_put(req);

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leal 0x1(%r14), %eax
movq %rsp, %r15
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
addq $0x28, %rdi
movslq %esi, %r12
xorl %r13d, %r13d
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2dca
cmpl %r12d, %eax
jne 0x2082
leaq 0x32b3(%rip), %rdx      # 0x52de
pushq $0x6
popq %rcx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1120
testq %rax, %rax
je 0x2070
movq %rax, %r12
subl %r15d, %r12d
addl $0x6, %r12d
subl %r12d, %r14d
leaq 0x3394(%rip), %rdi      # 0x53e6
movl %r14d, %esi
movl %r12d, %edx
movl %r12d, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x1090
movq %rbx, %rdi
callq 0x3cd7
movl %r12d, %r13d
movl %r13d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x312a(%rip), %rdi      # 0x51b3
leaq 0x2f7d(%rip), %rsi      # 0x500d
leaq 0x330a(%rip), %rcx      # 0x53a1
movl $0xe1, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/rouming[P]io/io-test.c
// Function: on_read_vari_len_req2__slave_from_master
static int on_read_vari_len_req2__slave_from_master(struct io_req *req, int len)
{
	int nb, stashed;
	char msg[len + 1], *beg, *end;

	nb = buf_memcpy_to(&req->buf, 0, msg, len);
	assert(nb == len);

	beg = memmem(msg, nb, "<msg>", 5);
	if (beg == NULL)
		return 0;

	end = memmem(msg, nb, "</msg>", 6);
	if (end == NULL)
		return 0;

	nb = end - msg + strlen("</msg>");
	stashed = len - nb;
	nb = end - beg + strlen("</msg>");
	printf(" VARI LEN MSG 3: stashed=%2d, len=%2d, msg='%.*s'\n",
	       stashed, nb, nb, beg);
	io_req_put(req);

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
leal 0x1(%rbx), %eax
movq %rsp, %r15
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
movslq %esi, %r14
xorl %r12d, %r12d
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2dca
cmpl %r14d, %eax
jne 0x215f
leaq 0x311f(%rip), %rdx      # 0x520b
pushq $0x5
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1120
testq %rax, %rax
je 0x214d
movq %rax, %r13
leaq 0x31d5(%rip), %rdx      # 0x52de
pushq $0x6
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1120
testq %rax, %rax
je 0x214d
subl %eax, %r15d
leal (%rbx,%r15), %esi
addl $-0x6, %esi
subl %r13d, %eax
addl $0x6, %eax
leaq 0x3354(%rip), %rdi      # 0x5487
movl %eax, %edx
movl %eax, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x1090
movq -0x30(%rbp), %rdi
callq 0x3cd7
movl %ebx, %r12d
movl %r12d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x304d(%rip), %rdi      # 0x51b3
leaq 0x2ea0(%rip), %rsi      # 0x500d
leaq 0x32d0(%rip), %rcx      # 0x5444
movl $0x144, %edx            # imm = 0x144
callq 0x10a0
nop
// File: /workspace/github_c_makefile_star2_O2/sheneman[P]clearcut/clearcut.c
// Function: NJ_neighbor_joining
NJ_TREE *
NJ_neighbor_joining(NJ_ARGS *nj_args,
		    DMAT *dmat) {

  
  NJ_TREE   *tree = NULL;
  NJ_VERTEX *vertex = NULL;

  long int a, b;
  float min;
    

  /* initialize the r and r2 vectors */
  NJ_init_r(dmat);

  /* allocate and initialize our vertex vector used for tree construction */
  vertex = NJ_init_vertex(dmat);
  if(!vertex) {
    fprintf(stderr, "Clearcut:  Could not initialize vertex in NJ_neighbor_joining()\n");
    return(NULL);
  }
  
  /* we iterate until the working distance matrix has only 2 entries */
  while(vertex->nactive > 2) {
 
    /* 
     * Find the global minimum transformed distance from the distance matrix
     */
    min = NJ_min_transform(dmat, &a, &b);

    /* 
     * Build the tree by removing nodes a and b from the vertex array
     * and inserting a new internal node which joins a and b.  Collapse
     * the vertex array similarly to how the distance matrix and r and r2 
     * are compacted. 
     */
    NJ_decompose(dmat, vertex, a, b, 0);

    /* decrement the r and r2 vectors by the distances corresponding to a, b */
    NJ_compute_r(dmat, a, b);

    /* compact the distance matrix and the r and r2 vectors */
    NJ_collapse(dmat, vertex, a, b);
  }
  
  /* Properly join the last two nodes on the vertex list */
  tree = NJ_decompose(dmat, vertex, 0, 1, NJ_LAST);

  /* return the computed tree to the calling function */
  return(tree);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x2f1c
movq %rbx, %rdi
callq 0x2fb9
testq %rax, %rax
je 0x293d
movq %rax, %r14
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpq $0x3, 0x10(%r14)
jl 0x291b
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3036
movq 0x10(%rsp), %r13
movq 0x8(%rsp), %rbp
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbp, %rcx
xorl %r8d, %r8d
callq 0x30b6
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x31a4
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x328c
jmp 0x28ca
pushq $0x1
popq %rcx
pushq $0x65
popq %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30b6
movq 0x96b4(%rip), %rax      # 0xbff8
movq (%rax), %rcx
leaq 0x4807(%rip), %rdi      # 0x7155
pushq $0x40
popq %rsi
pushq $0x1
popq %rdx
callq 0x2230
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sheneman[P]clearcut/clearcut.c
// Function: NJ_output_tree
void
NJ_output_tree(NJ_ARGS *nj_args,
	       NJ_TREE *tree,
	       DMAT *dmat,
	       long int count) {

  FILE *fp;

  if(nj_args->stdout_flag) {
    fp = stdout;
  } else {

    if(count == 0) {
      fp = fopen(nj_args->outfilename, "w");  /* open for writing   */
    } else {
      fp = fopen(nj_args->outfilename, "a");  /* open for appending */
    }

    if(!fp) {
      fprintf(stderr, "Clearcut: Failed to open outfile %s\n", nj_args->outfilename);
      exit(-1);
    }
  }

  NJ_output_tree2(fp, nj_args, tree, tree, dmat);
  fprintf(fp, " ;\n");
  
  if(!nj_args->stdout_flag) {
    fclose(fp);
  }

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x0, 0x2c(%rdi)
je 0x2df9
movq 0x91dc(%rip), %rax      # 0xbfd0
movq (%rax), %r12
jmp 0x2e1f
testq %rcx, %rcx
movq 0x8(%rbx), %rdi
leaq 0x4406(%rip), %rax      # 0x720d
leaq 0x4e06(%rip), %rsi      # 0x7c14
cmoveq %rax, %rsi
callq 0x21f0
movq %rax, %r12
testq %rax, %rax
je 0x2e6d
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x3a88
leaq 0x43fa(%rip), %rdi      # 0x7234
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %r12, %rcx
callq 0x2230
cmpl $0x0, 0x2c(%rbx)
je 0x2e5a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20d0
movq 0x9184(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq 0x8(%rbx), %rdx
leaq 0x438d(%rip), %rsi      # 0x720f
xorl %eax, %eax
callq 0x2180
pushq $-0x1
popq %rdi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O2/sheneman[P]clearcut/clearcut.c
// Function: NJ_init_r
void
NJ_init_r(DMAT *dmat) {

  long int i, j, size;
  long int index;
  float *r, *r2, *val;
  long int size1;
  float size2;
  
  r     = dmat->r;
  r2    = dmat->r2;
  val   = dmat->val;
  size  = dmat->size;
  size1 = size-1;
  size2 = (float)(size-2);

  index = 0;
  for(i=0;i<size1;i++) {
    index++;
    for(j=i+1;j<size;j++) {
      r[i] += val[index];
      r[j] += val[index];
      index++;
    }

    r2[i] = r[i]/size2;
  }
  
  return;
}

// Assembly:
pushq %r14
pushq %rbx
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rcx
movq 0x8(%rdi), %rsi
leaq -0x1(%rsi), %rdx
addq $-0x2, %rsi
cvtsi2ss %rsi, %xmm0
xorl %esi, %esi
testq %rdx, %rdx
movl $0x0, %r8d
cmovgq %rdx, %r8
movq 0x18(%rdi), %rdi
addq $0x4, %rdi
leaq 0x4(%rax), %r9
xorl %r10d, %r10d
cmpq %r8, %r10
je 0x2fb5
leaq 0x1(%r10), %r11
leaq (%rdi,%rsi,4), %r14
xorl %ebx, %ebx
cmpq %rbx, %rdx
je 0x2f93
movss (%r14,%rbx,4), %xmm1
addss (%rax,%r10,4), %xmm1
movss %xmm1, (%rax,%r10,4)
movss (%r14,%rbx,4), %xmm1
addss (%r9,%rbx,4), %xmm1
movss %xmm1, (%r9,%rbx,4)
incq %rbx
jmp 0x2f65
movss (%rax,%r10,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%rcx,%r10,4)
decq %rdx
addq %rbx, %rsi
incq %rsi
addq $0x4, %r9
movq %r11, %r10
jmp 0x2f56
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sheneman[P]clearcut/clearcut.c
// Function: NJ_init_vertex
NJ_VERTEX *
NJ_init_vertex(DMAT *dmat) {
  
  long int i;
  NJ_VERTEX *vertex;
  
  /* allocate the vertex here */
  vertex = (NJ_VERTEX *)calloc(1, sizeof(NJ_VERTEX));
  
  /* allocate the nodes in the vertex */
  vertex->nodes        = (NJ_TREE **)calloc(dmat->ntaxa, sizeof(NJ_TREE *));
  vertex->nodes_handle = vertex->nodes;
  
  /* initialize our size and active variables */
  vertex->nactive = dmat->ntaxa;
  vertex->size    = dmat->ntaxa;
  
  /* initialize the nodes themselves */
  for(i=0;i<dmat->ntaxa;i++) {
    
    vertex->nodes[i] = (NJ_TREE *)calloc(1, sizeof(NJ_TREE));

    vertex->nodes[i]->left  = NULL;
    vertex->nodes[i]->right = NULL;
    
    vertex->nodes[i]->taxa_index = i;
  }

  return(vertex);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
pushq $0x1
popq %rbx
pushq $0x20
popq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
movq %rax, %r15
movq (%r12), %r12
pushq $0x8
popq %rsi
movq %r12, %rdi
callq 0x2160
movq %rax, %r13
movq %rax, (%r15)
movq %rax, 0x8(%r15)
movq %r12, 0x10(%r15)
movq %r12, 0x18(%r15)
xorl %ebp, %ebp
testq %r12, %r12
cmovleq %rbp, %r12
cmpq %rbp, %r12
je 0x3024
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
movq %rax, (%r13,%rbp,8)
movq %rbp, 0x18(%rax)
incq %rbp
jmp 0x3006
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sheneman[P]clearcut/clearcut.c
// Function: NJ_decompose
NJ_TREE *
NJ_decompose(DMAT *dmat,
	     NJ_VERTEX *vertex,
	     long int x,
	     long int y,
	     int last_flag) {

  NJ_TREE *new_node;
  float x2clade, y2clade;

  /* compute the distance from the clade components to the new node */
  if(last_flag) {
    x2clade = 
      (dmat->val[NJ_MAP(x, y, dmat->size)]);  
  } else {
    x2clade = 
      (dmat->val[NJ_MAP(x, y, dmat->size)])/2 +   
      ((dmat->r2[x] - dmat->r2[y])/2);
  }

  vertex->nodes[x]->dist = x2clade;

  if(last_flag) {
    y2clade = 
      (dmat->val[NJ_MAP(x, y, dmat->size)]);  
  } else {
    y2clade = 
      (dmat->val[NJ_MAP(x, y, dmat->size)])/2 +  
      ((dmat->r2[y] - dmat->r2[x])/2);
  }

  vertex->nodes[y]->dist = y2clade;

  /* allocate new node to connect two sub-clades */
  new_node = (NJ_TREE *)calloc(1, sizeof(NJ_TREE));

  new_node->left  = vertex->nodes[x];
  new_node->right = vertex->nodes[y];
  new_node->taxa_index = NJ_INTERNAL_NODE;  /* this is not a terminal node, no taxa index */
  
  if(last_flag) {
    return(new_node);
  }

  vertex->nodes[x] = new_node;
  vertex->nodes[y] = vertex->nodes[0];
  
  vertex->nodes = &(vertex->nodes[1]);
  
  vertex->nactive--;

  return(new_node);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %rcx
movq %rsi, %rbx
movq 0x8(%rdi), %rax
notq %rdx
leaq (%rdx,%rax,2), %rax
imulq %rcx, %rax
pushq $0x2
popq %rsi
cqto
idivq %rsi
shlq $0x2, %rax
addq 0x18(%rdi), %rax
movss (%rax,%r14,4), %xmm0
testl %r8d, %r8d
je 0x310a
movq (%rbx), %rdx
leaq (%rdx,%rcx,8), %r15
movq (%r15), %r12
movss %xmm0, 0x10(%r12)
jmp 0x315b
movss 0x3efe(%rip), %xmm1     # 0x7010
mulss %xmm1, %xmm0
movq 0x30(%rdi), %rsi
movss (%rsi,%rcx,4), %xmm2
subss (%rsi,%r14,4), %xmm2
mulss %xmm1, %xmm2
addss %xmm0, %xmm2
movq (%rbx), %rdx
leaq (%rdx,%rcx,8), %r15
movq (%r15), %r12
movss %xmm2, 0x10(%r12)
movss (%rax,%r14,4), %xmm2
mulss %xmm1, %xmm2
movss (%rsi,%r14,4), %xmm0
subss (%rsi,%rcx,4), %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
movq (%rdx,%r14,8), %r13
movss %xmm0, 0x10(%r13)
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x2160
orq $-0x1, 0x18(%rax)
movq %r12, (%rax)
movq %r13, 0x8(%rax)
testl %ebp, %ebp
jne 0x3195
movq %rax, (%r15)
movq (%rbx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rcx,%r14,8)
addq $0x8, (%rbx)
decq 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sheneman[P]clearcut/clearcut.c
// Function: NJ_compute_r
static inline
void
NJ_compute_r(DMAT *dmat,
	     long int a,
	     long int b) {
  
  long int i;         /* a variable used in indexing */
  float *ptrx, *ptry; /* pointers into the distance matrix */
  
  /* some variables to limit pointer dereferencing in loop */
  long int size; 
  float *r, *val;
  
  /* to limit pointer dereferencing */
  size = dmat->size;
  val  = dmat->val;
  r    = dmat->r+a+1;

  /* 
   * Loop through the rows and decrement the stored r values 
   * by the distances stored in the rows and columns of the distance 
   * matrix which are being removed post-join.
   *
   * We do the rows altogether in order to benefit from cache locality.
   */
  ptrx = &(val[NJ_MAP(a, a+1, size)]); 
  ptry = &(val[NJ_MAP(b, b+1, size)]); 

  for(i=a+1;i<size;i++) {
    *r -= *(ptrx++);  

    if(i>b) {
      *r -= *(ptry++); 
    }

    r++;
  }

  /* Similar to the above loop, we now do the columns */
  ptrx = &(val[NJ_MAP(0, a, size)]);  
  ptry = &(val[NJ_MAP(0, b, size)]);  
  r = dmat->r;
  for(i=0;i<b;i++) {
    if(i<a) {
      *r -= *ptrx;
      ptrx += size-i-1;
    }

    *r -= *ptry;
    ptry += size-i-1;
    r++;
  }

  return;
}

// Assembly:
pushq %rbx
movq %rdx, %rcx
movq 0x8(%rdi), %r8
movq 0x18(%rdi), %r9
movq 0x28(%rdi), %rdi
leaq 0x1(%rsi), %r10
movq %rsi, %rax
notq %rax
leaq (%rax,%r8,2), %rax
imulq %rsi, %rax
movabsq $0x2, %rbx
cqto
idivq %rbx
leaq (%r9,%rax,4), %r11
movq %rcx, %rax
notq %rax
leaq (%rax,%r8,2), %rax
imulq %rcx, %rax
cqto
idivq %rbx
leaq (%r9,%rax,4), %rax
leaq (%rax,%rcx,4), %rax
addq $0x4, %rax
cmpq %r8, %r10
jge 0x3227
movss (%rdi,%r10,4), %xmm0
subss (%r11,%r10,4), %xmm0
movss %xmm0, (%rdi,%r10,4)
cmpq %rcx, %r10
jle 0x3222
subss (%rax), %xmm0
addq $0x4, %rax
movss %xmm0, (%rdi,%r10,4)
incq %r10
jmp 0x31f8
leaq (%r9,%rsi,4), %rax
leaq (%r9,%rcx,4), %rdx
xorl %r9d, %r9d
testq %rcx, %rcx
cmovleq %r9, %rcx
leaq -0x1(%r8), %r10
leaq -0x4(,%r8,4), %r11
cmpq %r9, %rcx
je 0x328a
movss (%rdi,%r9,4), %xmm0
cmpq %rsi, %r9
jge 0x326d
subss (%rax), %xmm0
movss %xmm0, (%rdi,%r9,4)
movq %r9, %rbx
notq %rbx
addq %r8, %rbx
addq %r11, %rax
jmp 0x3270
movq %r10, %rbx
subss (%rdx), %xmm0
movss %xmm0, (%rdi,%r9,4)
leaq (%rdx,%rbx,4), %rdx
incq %r9
decq %r10
addq $-0x4, %r11
jmp 0x3245
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/sheneman[P]clearcut/clearcut.c
// Function: NJ_permute
static inline
void
NJ_permute(long int *perm,
	   long int size) {
  
  long int i;     /* index used for looping */
  long int swap;  /* we swap values to generate permutation */
  long int tmp;   /* used for swapping values */


  /* check to see if vector of long ints is valid */
  if(!perm) {
    fprintf(stderr, "Clearcut: NULL permutation pointer in NJ_permute()\n");
    exit(-1);
  }
  
  /* init permutation as an ordered list of integers */
  for(i=0;i<size;i++) {
    perm[i] = i;
  }

  /* 
   * Iterate across the array from i = 0 to size -1, swapping ith element
   * with a randomly chosen element from a changing range of possible values
   */
  for(i=0;i<size;i++) {

    /* choose which element we will swap with */
    swap = i + NJ_genrand_int31_top(size-i);

    /* swap elements here */
    if(i != swap) {
      tmp        = perm[swap];
      perm[swap] = perm[i];
      perm[i]    = tmp;
    }
  }
  
  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3564
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
testq %rsi, %rsi
movl $0x0, %r15d
cmovgq %rsi, %r15
cmpq %rax, %r15
je 0x3558
movq %rax, (%r14,%rax,8)
incq %rax
jmp 0x3528
movq %rbx, %rdi
callq 0x667b
testq %rax, %rax
je 0x3551
movq (%r14,%rax,8), %rcx
movq (%r14), %rdx
movq %rdx, (%r14,%rax,8)
movq %rcx, (%r14)
addq $0x8, %r14
decq %rbx
subq $0x1, %r15
jae 0x3536
popq %rbx
popq %r14
popq %r15
retq
movq 0x8a8d(%rip), %rax      # 0xbff8
movq (%rax), %rcx
leaq 0x3ddf(%rip), %rdi      # 0x7354
pushq $0x33
popq %rsi
pushq $0x1
popq %rdx
callq 0x2230
pushq $-0x1
popq %rdi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O2/sheneman[P]clearcut/clearcut.c
// Function: NJ_print_distance_matrix
void
NJ_print_distance_matrix(DMAT *dmat) {

  long int i, j;

  printf("ntaxa: %ld\n", dmat->ntaxa);
  printf(" size: %ld\n", dmat->size);
  
  for(i=0;i<dmat->size;i++) {

    for(j=0;j<dmat->size;j++) {
      if(j>i) {
	printf("    %0.4f", dmat->val[NJ_MAP(i, j, dmat->size)]);  
      } else {
	printf("         -");
      }
    }


    if(dmat->r && dmat->r2) {
      printf("\t\t%0.4f", dmat->r[i]);    
      printf("\t%0.4f", dmat->r2[i]);


    
      printf("\n");

      for(j=0;j<dmat->size;j++) {
	if(j>i) {
	  printf("   %0.4f", dmat->val[NJ_MAP(i, j, dmat->size)] - (dmat->r2[i] + dmat->r2[j])); 
	} else {
	  printf("          ");
	}
      }
      
      printf("\n\n");
    }
  }
  
  printf("\n");
  
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x38b4(%rip), %rdi      # 0x71cd
xorl %eax, %eax
callq 0x2100
movq 0x8(%rbx), %rsi
leaq 0x38ae(%rip), %rdi      # 0x71d9
xorl %eax, %eax
callq 0x2100
pushq $0x2
popq %rbp
leaq 0x38b3(%rip), %r15      # 0x71ef
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
cmpq %rax, %r12
jge 0x3a72
movq %r12, %r13
notq %r13
xorl %r14d, %r14d
cmpq %rax, %r14
jge 0x39a4
cmpq %r12, %r14
jbe 0x3991
leaq (,%rax,2), %rax
addq %r13, %rax
imulq %r12, %rax
cqto
idivq %rbp
shlq $0x2, %rax
addq 0x18(%rbx), %rax
cvtss2sd (%rax,%r14,4), %xmm0
leaq 0x385d(%rip), %rdi      # 0x71e5
movb $0x1, %al
callq 0x2100
jmp 0x399b
movq %r15, %rdi
xorl %eax, %eax
callq 0x2100
incq %r14
movq 0x8(%rbx), %rax
jmp 0x3955
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x3a6a
cmpq $0x0, 0x30(%rbx)
je 0x3a6a
cvtss2sd (%rax,%r12,4), %xmm0
leaq 0x3831(%rip), %rdi      # 0x71fa
movb $0x1, %al
callq 0x2100
movq 0x30(%rbx), %rax
cvtss2sd (%rax,%r12,4), %xmm0
leaq 0x381a(%rip), %rdi      # 0x71fb
movb $0x1, %al
callq 0x2100
pushq $0xa
popq %rdi
callq 0x2050
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
cmpq %rax, %r14
jge 0x3a5e
cmpq %r12, %r14
jbe 0x3a4b
leaq (,%rax,2), %rax
addq %r13, %rax
imulq %r12, %rax
cqto
idivq %rbp
shlq $0x2, %rax
addq 0x18(%rbx), %rax
movss (%rax,%r14,4), %xmm0
movq 0x30(%rbx), %rax
movss (%rax,%r12,4), %xmm1
addss (%rax,%r14,4), %xmm1
subss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x37a4(%rip), %rdi      # 0x71e6
movb $0x1, %al
callq 0x2100
jmp 0x3a59
leaq 0x37b0(%rip), %rdi      # 0x7202
xorl %eax, %eax
callq 0x2100
incq %r14
jmp 0x39f3
leaq 0x43f4(%rip), %rdi      # 0x7e59
callq 0x20b0
incq %r12
jmp 0x393f
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/sheneman[P]clearcut/clearcut.c
// Function: NJ_output_tree2
void
NJ_output_tree2(FILE *fp,
		NJ_ARGS *nj_args,
		NJ_TREE *tree,
		NJ_TREE *root,
		DMAT *dmat) {
  
  if(!tree) {
    return;
  }
	
  if(tree->taxa_index != NJ_INTERNAL_NODE) {

    if(nj_args->expblen) {
      fprintf(fp, "%s:%e", 
	      dmat->taxaname[tree->taxa_index],
	      tree->dist);
    } else {
      fprintf(fp, "%s:%f", 
	      dmat->taxaname[tree->taxa_index],
	      tree->dist);
    }
    
  } else {
    

    if(tree->left && tree->right) {
      fprintf(fp, "(");
    }
    if(tree->left) {
      NJ_output_tree2(fp, nj_args, tree->left, root, dmat);
    }

    if(tree->left && tree->right) {
      fprintf(fp, ",");
    }
    if(tree->right) {
      NJ_output_tree2(fp, nj_args, tree->right, root, dmat);
    }

    if(tree != root->left) { 
      if(tree->left && tree->right) {
	if(tree != root) {
	  if(nj_args->expblen) {
	    fprintf(fp, "):%e", tree->dist);
	  } else {
	    fprintf(fp, "):%f", tree->dist);
	  }
	} else {
	  fprintf(fp, ")");
	}
      }
    } else {
      fprintf(fp, ")");
    }
  }

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x3b6b
movq %r8, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdx), %rax
cmpq $-0x1, %rax
je 0x3ad5
cmpl $0x0, 0x60(%r15)
movq 0x10(%r13), %rcx
movq (%rcx,%rax,8), %rdx
cvtss2sd 0x10(%r14), %xmm0
je 0x3b75
leaq 0x3768(%rip), %rsi      # 0x7238
jmp 0x3b7c
movq %rcx, %r12
movq (%r14), %rdx
testq %rdx, %rdx
je 0x3b23
cmpq $0x0, 0x8(%r14)
je 0x3afa
pushq $0x28
popq %rdi
movq %rbx, %rsi
callq 0x2150
movq (%r14), %rdx
testq %rdx, %rdx
je 0x3b23
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
movq %r13, %r8
callq 0x3a88
cmpq $0x0, (%r14)
je 0x3b23
cmpq $0x0, 0x8(%r14)
je 0x3b23
pushq $0x2c
popq %rdi
movq %rbx, %rsi
callq 0x2150
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x3b3d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
movq %r13, %r8
callq 0x3a88
cmpq %r14, (%r12)
je 0x3b8f
cmpq $0x0, (%r14)
je 0x3b6b
cmpq $0x0, 0x8(%r14)
je 0x3b6b
cmpq %r12, %r14
je 0x3b8f
cmpl $0x0, 0x60(%r15)
cvtss2sd 0x10(%r14), %xmm0
je 0x3ba3
leaq 0x36db(%rip), %rsi      # 0x7244
jmp 0x3baa
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x36c2(%rip), %rsi      # 0x723e
movq %rbx, %rdi
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2180
pushq $0x29
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2150
leaq 0x369f(%rip), %rsi      # 0x7249
movq %rbx, %rdi
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O2/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 0x367e(%rip), %rdi      # 0x724e
xorl %eax, %eax
callq 0x2100
leaq 0x368d(%rip), %r14      # 0x726b
xorl %r15d, %r15d
cmpq 0x10(%rbx), %r15
jge 0x3c01
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x18(%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2100
incq %r15
jmp 0x3be1
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0xa
popq %rdi
callq 0x2050
xorl %r14d, %r14d
leaq 0x3648(%rip), %r15      # 0x7270
cmpq 0x8(%rbx), %r14
jge 0x3c4a
movq 0x28(%rbx), %rax
cvtss2sd (%rax,%r14,4), %xmm0
movq %r15, %rdi
movq %r14, %rsi
movb $0x1, %al
callq 0x2100
incq %r14
jmp 0x3c28
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 0x3617(%rip), %rdi      # 0x7280
xorl %eax, %eax
callq 0x2100
leaq 0x361e(%rip), %r14      # 0x7295
xorl %r15d, %r15d
cmpq (%rbx), %r15
jge 0x3c99
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2100
incq %r15
jmp 0x3c7a
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/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
leaq -0x1(%rsi), %r12
xorl %eax, %eax
testq %r12, %r12
cmovleq %rax, %r12
leaq 0x3618(%rip), %r15      # 0x72e1
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x3ce4
movq (%r14,%r13,8), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2100
incq %r13
jmp 0x3ccc
movq -0x8(%r14,%rbx,8), %rsi
leaq 0x3b01(%rip), %rdi      # 0x77f1
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rcx
xorl %r12d, %r12d
pushq $0x2
popq %rbp
cmpq %rcx, %r12
jge 0x404e
leaq 0x1(%r12), %r13
movq %r12, %r15
notq %r15
movq %r13, 0x8(%rsp)
cmpq %rcx, %r13
jge 0x4044
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
leaq 0x10(%rsp), %rcx
callq 0x465d
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x45eb
movss 0x303f(%rip), %xmm1     # 0x700c
subss %xmm0, %xmm1
ucomiss 0x33dc(%rip), %xmm1     # 0x73b4
movss 0x33d0(%rip), %xmm0     # 0x73b0
ja 0x4007
cvtss2sd %xmm1, %xmm0
mulsd 0x33e2(%rip), %xmm0     # 0x73d0
addsd 0x33e2(%rip), %xmm0     # 0x73d8
callq 0x2140
mulsd 0x33dd(%rip), %xmm0     # 0x73e0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, %xmm1
andps 0x300f(%rip), %xmm1     # 0x7020
movq 0x8(%r14), %rcx
leaq (%r15,%rcx,2), %rax
imulq %r12, %rax
cqto
idivq %rbp
shlq $0x2, %rax
addq 0x18(%r14), %rax
cmpltss 0x2fd5(%rip), %xmm1     # 0x7008
andnps %xmm0, %xmm1
movss %xmm1, (%rax,%r13,4)
incq %r13
jmp 0x3f9b
movq 0x8(%rsp), %r12
jmp 0x3f82
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
xorl %r12d, %r12d
cmpq %r15, %r12
jge 0x4175
leaq 0x1(%r12), %r13
movq %r12, %rbp
notq %rbp
movq %r13, 0x8(%rsp)
cmpq %r15, %r13
jge 0x416b
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
leaq 0x10(%rsp), %rcx
callq 0x465d
testq %rax, %rax
setne %dl
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
setne %sil
andb %dl, %sil
xorps %xmm0, %xmm0
cmpb $0x1, %sil
jne 0x413e
cvtsi2ss %rax, %xmm0
cvtsi2ss %rcx, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x3303(%rip), %xmm0     # 0x73e8
cvtsd2ss %xmm0, %xmm1
movaps %xmm1, %xmm0
addss 0x32c4(%rip), %xmm0     # 0x73b8
ucomiss 0x2f11(%rip), %xmm1     # 0x700c
jbe 0x4119
andps 0x2f1c(%rip), %xmm0     # 0x7020
movss 0x2efc(%rip), %xmm2     # 0x7008
ucomiss %xmm0, %xmm2
movss 0x3299(%rip), %xmm0     # 0x73b0
jbe 0x413e
cvtss2sd %xmm1, %xmm1
movsd 0x32b3(%rip), %xmm0     # 0x73d8
subsd %xmm1, %xmm0
callq 0x2140
mulsd 0x32ba(%rip), %xmm0     # 0x73f0
cvtsd2ss %xmm0, %xmm0
movq 0x8(%r14), %r15
leaq (,%r15,2), %rax
addq %rbp, %rax
imulq %r12, %rax
cqto
pushq $0x2
popq %rcx
idivq %rcx
shlq $0x2, %rax
addq 0x18(%r14), %rax
movss %xmm0, (%rax,%r13,4)
incq %r13
jmp 0x4091
movq 0x8(%rsp), %r12
jmp 0x4078
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x31ae(%rip), %rdi      # 0x754d
callq 0x20b0
movq 0x8(%r14), %r15
xorl %r12d, %r12d
cmpq %r15, %r12
jge 0x4530
leaq 0x1(%r12), %r13
movq %r12, %rbp
notq %rbp
movq %r13, 0x8(%rsp)
cmpq %r15, %r13
jge 0x4526
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
leaq 0x10(%rsp), %rcx
callq 0x465d
testq %rax, %rax
setne %cl
movq 0x10(%rsp), %rdx
cvtsi2ss %rax, %xmm1
testq %rdx, %rdx
cvtsi2ss %rdx, %xmm0
setne %al
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
andb %cl, %al
jne 0x4409
xorps %xmm0, %xmm0
movaps %xmm0, %xmm2
addss 0x2fac(%rip), %xmm2     # 0x73c0
movss 0x2f98(%rip), %xmm3     # 0x73b4
ucomiss %xmm0, %xmm3
jbe 0x4499
andps 0x2bf8(%rip), %xmm2     # 0x7020
movss 0x2bd8(%rip), %xmm3     # 0x7008
ucomiss %xmm2, %xmm3
ja 0x4499
andps 0x2be4(%rip), %xmm1     # 0x7020
movss 0x2bc4(%rip), %xmm2     # 0x7008
ucomiss %xmm1, %xmm2
setbe %cl
ucomiss 0x2f6b(%rip), %xmm0     # 0x73bc
jbe 0x44f9
andb %cl, %al
je 0x44f9
cvtss2sd %xmm0, %xmm1
movsd 0x2f6d(%rip), %xmm2     # 0x73d8
subsd %xmm1, %xmm2
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
divsd 0x2f89(%rip), %xmm0     # 0x7408
addsd %xmm2, %xmm0
callq 0x2140
cvtsd2ss %xmm0, %xmm0
xorps 0x2f8d(%rip), %xmm0     # 0x7420
movq 0x8(%r14), %r15
jmp 0x44f9
movaps %xmm0, %xmm1
addss 0x2f20(%rip), %xmm1     # 0x73c4
ucomiss 0x2f1d(%rip), %xmm0     # 0x73c8
jbe 0x44cb
andps 0x2b6c(%rip), %xmm1     # 0x7020
movss 0x2b4c(%rip), %xmm2     # 0x7008
ucomiss %xmm1, %xmm2
ja 0x44cb
movss 0x2ee7(%rip), %xmm0     # 0x73b0
jmp 0x44f9
cvtss2sd %xmm0, %xmm0
mulsd 0x2f39(%rip), %xmm0     # 0x7410
addsd 0x2f39(%rip), %xmm0     # 0x7418
cvttsd2si %xmm0, %eax
cltq
leaq 0x7c44(%rip), %rcx      # 0xc130
cvtsi2ssl (%rcx,%rax,4), %xmm0
divss 0x2ed3(%rip), %xmm0     # 0x73cc
leaq (,%r15,2), %rax
addq %rbp, %rax
imulq %r12, %rax
cqto
pushq $0x2
popq %rcx
idivq %rcx
shlq $0x2, %rax
addq 0x18(%r14), %rax
movss %xmm0, (%rax,%r13,4)
incq %r13
jmp 0x43c4
movq 0x8(%rsp), %r12
jmp 0x43ab
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rbp
leaq (,%rbp,2), %rax
movq %rax, (%rsp)
xorl %r15d, %r15d
testq %rbp, %rbp
movl $0x0, %eax
cmovgq %rbp, %rax
movq %rax, 0x8(%rsp)
cmpq 0x8(%rsp), %r15
je 0x45dc
leaq 0x1(%r15), %r13
movq %r15, %rax
notq %rax
addq (%rsp), %rax
imulq %r15, %rax
cqto
pushq $0x2
popq %rcx
idivq %rcx
movq %rax, %r12
shlq $0x2, %r12
movq %r13, 0x10(%rsp)
cmpq %rbp, %r13
jge 0x45d5
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x45eb
movss 0x2a4d(%rip), %xmm1     # 0x700c
subss %xmm0, %xmm1
movq 0x18(%r14), %rax
addq %r12, %rax
movss %xmm1, (%rax,%r13,4)
incq %r13
jmp 0x45a4
movq 0x10(%rsp), %r15
jmp 0x4577
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rax
imulq %rax, %rsi
imulq %rax, %rdx
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
xorl %r8d, %r8d
subq $0x1, %rax
jb 0x464b
movq 0x18(%rdi), %r9
movb (%r9,%rsi), %r10b
movb (%r9,%rdx), %r9b
movl %r10d, %r11d
xorb $0x3f, %r11b
movl %r9d, %ebx
xorb $0x3f, %bl
xorl %r14d, %r14d
orb %r11b, %bl
setne %r14b
cmpb %r9b, %r10b
sete %r9b
andb %r14b, %r9b
movzbl %r9b, %r9d
addq %r9, %rcx
addq %r14, %r8
incq %rdx
incq %rsi
jmp 0x4606
cvtsi2ss %rcx, %xmm0
cvtsi2ss %r8, %xmm1
divss %xmm1, %xmm0
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %r8
imulq %r8, %rsi
imulq %r8, %rdx
xorl %eax, %eax
testq %r8, %r8
cmovleq %rax, %r8
xorl %r9d, %r9d
subq $0x1, %r8
jb 0x46be
movq 0x18(%rdi), %r10
movb (%r10,%rsi), %r11b
movb (%r10,%rdx), %r10b
movl %r11d, %ebx
xorb $0x3f, %bl
movl %r10d, %ebp
xorb $0x3f, %bpl
xorl %r14d, %r14d
orb %bl, %bpl
setne %r14b
cmpb %r10b, %r11b
setne %r10b
andb %r14b, %r10b
movzbl %r10b, %r10d
addq %r10, %rax
addq %r14, %r9
incq %rdx
incq %rsi
jmp 0x4679
movq %r9, (%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq (%rdi), %rbp
xorl %r14d, %r14d
testq %rbp, %rbp
movl $0x0, %eax
cmovgq %rbp, %rax
movq %rax, (%rsp)
cmpq (%rsp), %r14
je 0x593c
leaq 0x1(%r14), %rbx
movq %rbx, %r12
cmpq %rbp, %r12
jge 0x5912
movq 0x10(%r15), %rax
movq (%rax,%r14,8), %r13
movq (%rax,%r12,8), %rsi
movq %r13, %rdi
callq 0x2170
testl %eax, %eax
je 0x5917
incq %r12
jmp 0x58f0
movq %rbx, %r14
jmp 0x58e3
movq 0x66da(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x211e(%rip), %rsi      # 0x7a46
xorl %ebx, %ebx
movq %r14, %rdx
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x2180
jmp 0x593f
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
leaq 0x2078(%rip), %rdi      # 0x7a2c
xorl %eax, %eax
callq 0x2100
leaq 0x22e7(%rip), %r14      # 0x7ca9
pushq $0xa
popq %rbp
xorl %r15d, %r15d
cmpq (%rbx), %r15
jge 0x5a0e
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2100
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
cmpq %rax, %r12
jge 0x5a02
imulq %r15, %rax
addq 0x18(%rbx), %rax
movsbl (%r12,%rax), %edi
callq 0x2050
incq %r12
jmp 0x59e2
movl %ebp, %edi
callq 0x2050
incq %r15
jmp 0x59c8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sheneman[P]clearcut/fasta.c
// Function: NJ_print_titles
void
NJ_print_titles(NJ_alignment *alignment) {

  int i;

  for(i=0;i<alignment->nseq;i++) {
    printf("%d: %s\n", i, alignment->titles[i]);
  }

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2062(%rip), %r14      # 0x7a88
xorl %r15d, %r15d
cmpq %r15, (%rbx)
jle 0x5a48
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x2100
incq %r15
jmp 0x5a29
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x6219
cmpl $0x65, %eax
je 0x6204
cmpl $0x64, %eax
jne 0x622d
movups 0x1e6a(%rip), %xmm0     # 0x8068
movaps %xmm0, (%rsp)
jmp 0x623b
movups 0x1e6d(%rip), %xmm0     # 0x8078
movaps %xmm0, (%rsp)
movl $0x736563, 0x10(%rsp)   # imm = 0x736563
jmp 0x623b
movups 0x1e6c(%rip), %xmm0     # 0x808c
movaps %xmm0, (%rsp)
movw $0x73, 0x10(%rsp)
jmp 0x623b
movabsq $0x4e574f4e4b4e55, %rax # imm = 0x4E574F4E4B4E55
movq %rax, (%rsp)
leaq 0x255d(%rip), %rdi      # 0x879f
callq 0x20b0
leaq 0x1e50(%rip), %rdi      # 0x809e
movq %rsp, %rsi
xorl %eax, %eax
callq 0x2100
cmpl $0x0, 0x28(%rbx)
je 0x626c
leaq 0x255b(%rip), %rdi      # 0x87c0
callq 0x20b0
jmp 0x627d
movq (%rbx), %rsi
leaq 0x1e38(%rip), %rdi      # 0x80ae
xorl %eax, %eax
callq 0x2100
cmpl $0x0, 0x2c(%rbx)
je 0x6291
leaq 0x2547(%rip), %rdi      # 0x87d1
callq 0x20b0
jmp 0x62a3
movq 0x8(%rbx), %rsi
leaq 0x1e22(%rip), %rdi      # 0x80be
xorl %eax, %eax
callq 0x2100
cmpl $0x64, 0x18(%rbx)
je 0x62c4
cmpl $0x0, 0x1c(%rbx)
leaq 0x2530(%rip), %rax      # 0x87e4
leaq 0x2546(%rip), %rdi      # 0x8801
cmoveq %rax, %rdi
callq 0x20b0
cmpl $0x0, 0x20(%rbx)
leaq 0x254f(%rip), %rax      # 0x881e
leaq 0x255a(%rip), %rdi      # 0x8830
cmoveq %rax, %rdi
callq 0x20b0
cmpl $0x0, 0x24(%rbx)
leaq 0x2557(%rip), %rax      # 0x8841
leaq 0x2560(%rip), %rdi      # 0x8851
cmoveq %rax, %rdi
callq 0x20b0
movl 0x48(%rbx), %esi
testl %esi, %esi
je 0x630f
leaq 0x1dc7(%rip), %rdi      # 0x80cf
xorl %eax, %eax
callq 0x2100
leaq 0x254a(%rip), %rdi      # 0x8860
callq 0x20b0
addq $0x20, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x66b6
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 0x659f
cmpq %r14, %rax
jae 0x669c
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x6c62
movq %rcx, %r9
cmpq %r8, %r9
jle 0x6c62
movq -0x8(%rdi,%r9,8), %r10
movq %r10, (%rdi,%r9,8)
decq %r9
jmp 0x6c4f
cmpl %edx, %esi
jge 0x6c79
cmpq %r8, %rcx
jge 0x6c79
movq 0x8(%rdi,%rcx,8), %rdx
movq %rdx, (%rdi,%rcx,8)
incq %rcx
jmp 0x6c66
movq %rax, (%rdi,%r8,8)
retq