LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/io-test.c
// Function: on_read_fixed_len_req__slave_from_master
static int on_read_fixed_len_req__slave_from_master(struct io_req *req, int err)
{
	int len = buf_len(&req->buf);
	char msg[len];
	int nb;

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

	printf("  FIXED LEN MSG: len=%d, msg='%.*s'\n", len, len, msg);
	io_req_put(req);

	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x28(%rdi), %r13
movq %r13, %rdi
callq 0x2f0e
movl %eax, %r15d
movl %eax, %eax
movq %rsp, %r12
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
cmpl $0x9, %ebx
jne 0x1c43
movslq %r15d, %rcx
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2f60
cmpl %r15d, %eax
jne 0x1c62
leaq 0x36c7(%rip), %rdi      # 0x52e1
movl %r15d, %esi
movl %r15d, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x1090
movq %r14, %rdi
callq 0x4262
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x362f(%rip), %rdi      # 0x5279
leaq 0x34e0(%rip), %rsi      # 0x5131
leaq 0x363c(%rip), %rcx      # 0x5294
movl $0x4b, %edx
callq 0x10a0
leaq 0x366e(%rip), %rdi      # 0x52d7
leaq 0x34c1(%rip), %rsi      # 0x5131
leaq 0x361d(%rip), %rcx      # 0x5294
movl $0x4d, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/rouming[P]io/io-test.c
// Function: on_write_vari_len_req1_1__master_to_slave
static int on_write_vari_len_req1_1__master_to_slave(struct io_req *req, int len)
{
	int rc;
	struct io_req *m_s_req2;
	struct loop_ctx *ctx = req->data;

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

	/* Write master->slave, part2 */
	m_s_req2 = io_req_create(&ctx->master, REQ_WR, ctx,
				 on_write_vari_len_req1_2__master_to_slave);
	assert(m_s_req2);
	m_s_req2->buf = (struct io_buf){
		.iov[0] = {
			.iov_base = "</msg>",
			.iov_len  = strlen("</msg>")
		},
		.iov[1] = {
			.iov_base = "<msg>",
			.iov_len  = strlen("<msg>")
		},
		.iov_num  = 2,
		.is_vari_len = false
	};
	rc = io_queue_submit(m_s_req2);
	assert(rc == 0);

	return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
testl %esi, %esi
jle 0x1d45
movl %esi, %ebx
movq 0x18(%rdi), %r14
callq 0x4262
leaq 0x245(%rip), %rcx       # 0x1eee
movq %r14, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x41cc
testq %rax, %rax
je 0x1d64
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 0x5f0b(%rip), %rsi      # 0x7bf8
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
callq 0x1140
movl $0x120, %edx            # imm = 0x120
movq %r15, %rdi
movq %r12, %rsi
callq 0x1140
movq $0x2, 0x148(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r14)
movups %xmm0, 0x160(%r14)
movq %r14, %rdi
callq 0x3ef1
testl %eax, %eax
jne 0x1d83
movl %ebx, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x34e3(%rip), %rdi      # 0x522f
leaq 0x33de(%rip), %rsi      # 0x5131
leaq 0x35eb(%rip), %rcx      # 0x5345
movl $0xc2, %edx
callq 0x10a0
leaq 0x34af(%rip), %rdi      # 0x521a
leaq 0x33bf(%rip), %rsi      # 0x5131
leaq 0x35cc(%rip), %rcx      # 0x5345
movl $0xc8, %edx
callq 0x10a0
leaq 0x344f(%rip), %rdi      # 0x51d9
leaq 0x33a0(%rip), %rsi      # 0x5131
leaq 0x35ad(%rip), %rcx      # 0x5345
movl $0xd6, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2f60
cmpl %r12d, %eax
jne 0x1eb0
movslq %eax, %rsi
leaq 0x3607(%rip), %rdx      # 0x5402
movl $0x6, %ecx
movq %r13, %rdi
callq 0x1120
testq %rax, %rax
je 0x1e9e
movq %rax, %r12
subl %r13d, %r12d
addl $0x6, %r12d
subl %r12d, %r15d
leaq 0x366d(%rip), %rdi      # 0x5492
movl %r15d, %esi
movl %r12d, %edx
movl %r12d, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x1090
movq %rbx, %rdi
callq 0x4262
movq -0x30(%rbp), %rdx
leaq 0x178(%rdx), %rdi
leaq 0x1ec(%rip), %rcx       # 0x203e
xorl %esi, %esi
callq 0x41cc
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 0x3ef1
movl %r12d, %r14d
testl %eax, %eax
jne 0x1ecf
movl %r14d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3420(%rip), %rdi      # 0x52d7
leaq 0x3273(%rip), %rsi      # 0x5131
leaq 0x3588(%rip), %rcx      # 0x544d
movl $0xf9, %edx
callq 0x10a0
leaq 0x3303(%rip), %rdi      # 0x51d9
leaq 0x3254(%rip), %rsi      # 0x5131
leaq 0x3569(%rip), %rcx      # 0x544d
movl $0x112, %edx            # imm = 0x112
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1fb2
movl %esi, %ebx
movq 0x18(%rdi), %r14
callq 0x4262
leaq 0xf9(%rip), %rcx        # 0x200f
movq %r14, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x41cc
testq %rax, %rax
je 0x1fd1
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 0x5d9e(%rip), %rsi      # 0x7cf8
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 0x3ef1
testl %eax, %eax
jne 0x1ff0
movl %ebx, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3276(%rip), %rdi      # 0x522f
leaq 0x3171(%rip), %rsi      # 0x5131
leaq 0x33c2(%rip), %rcx      # 0x5389
movl $0x9a, %edx
callq 0x10a0
leaq 0x33f5(%rip), %rdi      # 0x53cd
leaq 0x3152(%rip), %rsi      # 0x5131
leaq 0x33a3(%rip), %rcx      # 0x5389
movl $0xa0, %edx
callq 0x10a0
leaq 0x31e2(%rip), %rdi      # 0x51d9
leaq 0x3133(%rip), %rsi      # 0x5131
leaq 0x3384(%rip), %rcx      # 0x5389
movl $0xb7, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/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, %r13
xorl %r12d, %r12d
xorl %esi, %esi
movq %r15, %rdx
movq %r13, %rcx
callq 0x2f60
cmpl %r13d, %eax
jne 0x20e3
movslq %eax, %rsi
leaq 0x3375(%rip), %rdx      # 0x5402
movl $0x6, %ecx
movq %r15, %rdi
callq 0x1120
testq %rax, %rax
je 0x20d1
movq %rax, %r13
subl %r15d, %r13d
addl $0x6, %r13d
subl %r13d, %r14d
leaq 0x3457(%rip), %rdi      # 0x550a
movl %r14d, %esi
movl %r13d, %edx
movl %r13d, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x1090
movq %rbx, %rdi
callq 0x4262
movl %r13d, %r12d
movl %r12d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31ed(%rip), %rdi      # 0x52d7
leaq 0x3040(%rip), %rsi      # 0x5131
leaq 0x33cd(%rip), %rcx      # 0x54c5
movl $0xe1, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2f60
cmpl %r14d, %eax
jne 0x21cb
movslq %eax, %r14
leaq 0x31db(%rip), %rdx      # 0x532f
movl $0x5, %ecx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1120
testq %rax, %rax
je 0x21b9
movq %rax, %r13
leaq 0x328f(%rip), %rdx      # 0x5402
movl $0x6, %ecx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1120
testq %rax, %rax
je 0x21b9
subl %eax, %r15d
leal (%rbx,%r15), %esi
addl $-0x6, %esi
subl %r13d, %eax
addl $0x6, %eax
leaq 0x340c(%rip), %rdi      # 0x55ab
movl %eax, %edx
movl %eax, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x1090
movq -0x30(%rbp), %rdi
callq 0x4262
movl %ebx, %r12d
movl %r12d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3105(%rip), %rdi      # 0x52d7
leaq 0x2f58(%rip), %rsi      # 0x5131
leaq 0x3388(%rip), %rcx      # 0x5568
movl $0x144, %edx            # imm = 0x144
callq 0x10a0
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x3ba2
movq 0x9433(%rip), %rax      # 0xcfd0
movq (%rax), %r12
jmp 0x3bc8
testq %rcx, %rcx
movq 0x8(%rbx), %rdi
leaq 0x465d(%rip), %rax      # 0x820d
leaq 0x505d(%rip), %rsi      # 0x8c14
cmoveq %rax, %rsi
callq 0x2200
movq %rax, %r12
testq %rax, %rax
je 0x3c1a
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x4620
leaq 0x4651(%rip), %rdi      # 0x8234
movl $0x3, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x2240
cmpl $0x0, 0x2c(%rbx)
je 0x3c07
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 %rbx, %rdi
callq 0x230b
// File: /workspace/github_c_makefile_star2_O1/sheneman[P]clearcut/clearcut.c
// Function: NJ_free_dmat
void
NJ_free_dmat(DMAT *dmat) {
  
  long int i;
  
  if(dmat) {
    
    if(dmat->taxaname) {

      for(i=0;i<dmat->ntaxa;i++) {
	if(dmat->taxaname[i]) {
	  free(dmat->taxaname[i]);
	}
      }

      free(dmat->taxaname);
    }

    if(dmat->valhandle) {
      free(dmat->valhandle);
    }

    if(dmat->rhandle) {
      free(dmat->rhandle);
    }

    if(dmat->r2handle) {
      free(dmat->r2handle);
    }

    free(dmat);
  }
  
  return;
}

// Assembly:
testq %rdi, %rdi
je 0x3cc8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x3c8f
cmpq $0x0, (%rbx)
jle 0x3c86
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x3c7e
callq 0x2040
incq %r14
cmpq (%rbx), %r14
jl 0x3c6c
movq 0x10(%rbx), %rdi
callq 0x2040
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3c9d
callq 0x2040
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x3cab
callq 0x2040
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x3cb9
callq 0x2040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x8(%rdi), %rax
cmpq $0x2, %rax
jl 0x3d3f
movq 0x28(%rdi), %rcx
leaq -0x2(%rax), %rdx
cvtsi2ss %rdx, %xmm0
movq 0x30(%rdi), %rsi
movq 0x18(%rdi), %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
leaq 0x1(%r8), %r10
incq %r9
movq %r10, %r11
movss (%rdi,%r9,4), %xmm1
addss (%rcx,%r8,4), %xmm1
movss %xmm1, (%rcx,%r8,4)
movss (%rdi,%r9,4), %xmm1
addss (%rcx,%r11,4), %xmm1
movss %xmm1, (%rcx,%r11,4)
incq %r11
incq %r9
cmpq %rax, %r11
jl 0x3cf8
movss (%rcx,%r8,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%rsi,%r8,4)
cmpq %rdx, %r8
movq %r10, %r8
jne 0x3cee
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0x20, %esi
callq 0x2160
movq %rax, %rbx
movq (%r14), %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x2160
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %r14, 0x18(%rbx)
testq %r14, %r14
jle 0x3dac
movq %rax, %r15
xorl %r12d, %r12d
movl $0x1, %edi
movl $0x20, %esi
callq 0x2160
movq %rax, (%r15,%r12,8)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r12, 0x18(%rax)
incq %r12
cmpq %r12, %r14
jne 0x3d87
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sheneman[P]clearcut/clearcut.c
// Function: NJ_min_transform
float
NJ_min_transform(DMAT *dmat,
		 long int *ret_i,
		 long int *ret_j) {

  long int i, j;   /* indices used for looping        */
  long int tmp_i = 0;/* to limit pointer dereferencing  */
  long int tmp_j = 0;/* to limit pointer dereferencing  */
  float smallest;  /* track the smallest trans. dist  */
  float curval;    /* the current trans. dist in loop */

  float *ptr;      /* pointer into distance matrix    */
  float *r2;       /* pointer to r2 matrix for computing transformed dists */
  
  smallest = (float)HUGE_VAL;

  /* track these here to limit pointer dereferencing in inner loop */
  ptr = dmat->val;
  r2  = dmat->r2;

  /* for every row */
  for(i=0;i<dmat->size;i++) {
    ptr++;  /* skip diagonal */
    for(j=i+1;j<dmat->size;j++) {   /* for every column */

      /* find transformed distance in matrix at i, j */
      curval = *(ptr++) - (r2[i] + r2[j]);

      /* if the transformed distanance is less than the known minimum */
      if(curval < smallest) {

	smallest = curval;
	tmp_i = i;
	tmp_j = j;
      }
    }
  }
  
  /* pass back (by reference) the coords of the min. transformed distance */
  *ret_i = tmp_i;
  *ret_j = tmp_j;
  
  return(smallest);  /* return the min transformed distance */
}

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x3e34
movq 0x30(%rdi), %r8
movq 0x18(%rdi), %r9
movss 0x422f(%rip), %xmm1     # 0x8004
xorl %r10d, %r10d
xorl %edi, %edi
xorl %ecx, %ecx
movq %r10, %r11
incq %r10
addq $0x4, %r9
cmpq %rax, %r10
jge 0x3e27
movss (%r8,%r11,4), %xmm2
movq %r10, %rbx
movss (%r9), %xmm0
movss (%r8,%rbx,4), %xmm3
addss %xmm2, %xmm3
subss %xmm3, %xmm0
ucomiss %xmm0, %xmm1
cmovaq %r11, %rcx
cmovaq %rbx, %rdi
minss %xmm1, %xmm0
incq %rbx
addq $0x4, %r9
movaps %xmm0, %xmm1
cmpq %rax, %rbx
jl 0x3df4
jmp 0x3e2a
movaps %xmm1, %xmm0
movaps %xmm0, %xmm1
cmpq %rax, %r10
jne 0x3ddc
jmp 0x3e40
movss 0x41c8(%rip), %xmm0     # 0x8004
xorl %ecx, %ecx
xorl %edi, %edi
movq %rcx, (%rsi)
movq %rdi, (%rdx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %rsi, %rbx
movq 0x8(%rdi), %rcx
movq %rdx, %rax
notq %rax
leaq (%rax,%rcx,2), %rcx
imulq %rdx, %rcx
movq %rcx, %rdx
shrq $0x3f, %rdx
addq %rcx, %rdx
andq $-0x2, %rdx
addq %rdx, %rdx
addq 0x18(%rdi), %rdx
movss (%rdx,%r14,4), %xmm0
testl %r8d, %r8d
jne 0x3eb5
movss 0x4177(%rip), %xmm1     # 0x8010
mulss %xmm1, %xmm0
movq 0x30(%rdi), %rcx
movss (%rcx,%r15,4), %xmm2
subss (%rcx,%r14,4), %xmm2
mulss %xmm1, %xmm2
addss %xmm2, %xmm0
movq (%rbx), %r12
movq (%r12,%r15,8), %r13
movss %xmm0, 0x10(%r13)
movq 0x8(%rdi), %rcx
leaq (%rax,%rcx,2), %rax
imulq %r15, %rax
movq %rax, %rcx
shrq $0x3f, %rcx
addq %rax, %rcx
andq $-0x2, %rcx
addq %rcx, %rcx
addq 0x18(%rdi), %rcx
movss (%rcx,%r14,4), %xmm0
testl %ebp, %ebp
jne 0x3f11
movss 0x411b(%rip), %xmm1     # 0x8010
mulss %xmm1, %xmm0
movq 0x30(%rdi), %rax
movss (%rax,%r14,4), %xmm2
subss (%rax,%r15,4), %xmm2
mulss %xmm1, %xmm2
addss %xmm2, %xmm0
movq (%r12,%r14,8), %rax
movss %xmm0, 0x10(%rax)
movl $0x1, %edi
movl $0x20, %esi
callq 0x2160
movq %r13, (%rax)
movq (%r12,%r14,8), %rcx
movq %rcx, 0x8(%rax)
movq $-0x1, 0x18(%rax)
testl %ebp, %ebp
jne 0x3f56
movq %rax, (%r12,%r15,8)
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_O1/sheneman[P]clearcut/clearcut.c
// Function: NJ_free_vertex
void
NJ_free_vertex(NJ_VERTEX *vertex) {
  
  if(vertex) {
    if(vertex->nodes_handle) {
      free(vertex->nodes_handle);
    }
    free(vertex);
  }

  return;
}

// Assembly:
testq %rdi, %rdi
je 0x446d
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4464
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3d47(%rip), %rdi      # 0x81cd
xorl %eax, %eax
callq 0x2100
movq 0x8(%rbx), %rsi
leaq 0x3d41(%rip), %rdi      # 0x81d9
xorl %eax, %eax
callq 0x2100
cmpq $0x0, 0x8(%rbx)
jle 0x4608
leaq 0x3d34(%rip), %r14      # 0x81e5
leaq 0x3d37(%rip), %r15      # 0x81ef
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
testq %rax, %rax
jle 0x4518
movq %r13, %r12
notq %r12
xorl %ebp, %ebp
cmpq %r13, %rbp
jbe 0x4502
leaq (%r12,%rax,2), %rax
imulq %r13, %rax
movq %rax, %rcx
shrq $0x3f, %rcx
addq %rax, %rcx
andq $-0x2, %rcx
addq %rcx, %rcx
addq 0x18(%rbx), %rcx
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rbp,4), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x2100
jmp 0x450c
movq %r15, %rdi
xorl %eax, %eax
callq 0x2100
incq %rbp
movq 0x8(%rbx), %rax
cmpq %rax, %rbp
jl 0x44cc
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x45fb
cmpq $0x0, 0x30(%rbx)
je 0x45fb
xorps %xmm0, %xmm0
cvtss2sd (%rax,%r13,4), %xmm0
leaq 0x3cba(%rip), %rdi      # 0x81fa
movb $0x1, %al
callq 0x2100
movq 0x30(%rbx), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%r13,4), %xmm0
leaq 0x3ca0(%rip), %rdi      # 0x81fb
movb $0x1, %al
callq 0x2100
movl $0xa, %edi
callq 0x2050
movq 0x8(%rbx), %rax
testq %rax, %rax
jle 0x45ef
movq %r13, %rbp
notq %rbp
xorl %r12d, %r12d
cmpq %r13, %r12
jbe 0x45d5
leaq (,%rax,2), %rax
addq %rbp, %rax
imulq %r13, %rax
movq %rax, %rcx
shrq $0x3f, %rcx
addq %rax, %rcx
andq $-0x2, %rcx
addq %rcx, %rcx
addq 0x18(%rbx), %rcx
movss (%rcx,%r12,4), %xmm0
movq 0x30(%rbx), %rax
movss (%rax,%r13,4), %xmm1
addss (%rax,%r12,4), %xmm1
subss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x3c1a(%rip), %rdi      # 0x81e6
movb $0x1, %al
callq 0x2100
jmp 0x45e3
leaq 0x3c26(%rip), %rdi      # 0x8202
xorl %eax, %eax
callq 0x2100
incq %r12
movq 0x8(%rbx), %rax
cmpq %rax, %r12
jl 0x457e
leaq 0x4863(%rip), %rdi      # 0x8e59
callq 0x20b0
incq %r13
cmpq 0x8(%rbx), %r13
jl 0x44bb
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 0x4705
movq %r8, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdx), %rax
cmpq $-0x1, %rax
je 0x466d
cmpl $0x0, 0x60(%r15)
movq 0x10(%r13), %rcx
movq (%rcx,%rax,8), %rdx
cvtss2sd 0x10(%r14), %xmm0
je 0x470f
leaq 0x3bd0(%rip), %rsi      # 0x8238
jmp 0x4716
movq %rcx, %r12
cmpq $0x0, (%r14)
je 0x468a
cmpq $0x0, 0x8(%r14)
je 0x468a
movl $0x28, %edi
movq %rbx, %rsi
callq 0x2150
movq (%r14), %rdx
testq %rdx, %rdx
je 0x46a3
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
movq %r13, %r8
callq 0x4620
cmpq $0x0, (%r14)
je 0x46bd
cmpq $0x0, 0x8(%r14)
je 0x46bd
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x2150
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x46d7
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
movq %r13, %r8
callq 0x4620
cmpq %r14, (%r12)
je 0x4729
cmpq $0x0, (%r14)
je 0x4705
cmpq $0x0, 0x8(%r14)
je 0x4705
cmpq %r12, %r14
je 0x4729
cmpl $0x0, 0x60(%r15)
cvtss2sd 0x10(%r14), %xmm0
je 0x473f
leaq 0x3b41(%rip), %rsi      # 0x8244
jmp 0x4746
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3b28(%rip), %rsi      # 0x823e
movq %rbx, %rdi
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2180
movl $0x29, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2150
leaq 0x3b03(%rip), %rsi      # 0x8249
movq %rbx, %rdi
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O1/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 0x3ae2(%rip), %rdi      # 0x824e
xorl %eax, %eax
callq 0x2100
cmpq $0x0, 0x10(%rbx)
jle 0x47a2
leaq 0x3aea(%rip), %r14      # 0x826b
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 0x4784
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 0x47f7
xorl %r14d, %r14d
leaq 0x3a9c(%rip), %r15      # 0x8270
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 0x47d4
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 0x3a68(%rip), %rdi      # 0x8280
xorl %eax, %eax
callq 0x2100
cmpq $0x0, (%rbx)
jle 0x484c
leaq 0x3a69(%rip), %r14      # 0x8295
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 0x482f
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 0x4894
leaq -0x1(%rbx), %r12
leaq 0x3a66(%rip), %r15      # 0x82e1
xorl %r13d, %r13d
movq (%r14,%r13,8), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2100
incq %r13
cmpq %r13, %r12
jne 0x487e
movq -0x8(%r14,%rbx,8), %rsi
leaq 0x3f51(%rip), %rdi      # 0x87f1
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0x8(%rdi)
jle 0x4bd7
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), %rax
movq %rax, 0x8(%rsp)
cmpq 0x8(%r14), %rax
jge 0x4bba
movq %r12, %rbp
notq %rbp
movq 0x8(%rsp), %r13
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x524c
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x51d1
movss 0x34e0(%rip), %xmm1     # 0x800c
subss %xmm0, %xmm1
ucomiss 0x387d(%rip), %xmm1     # 0x83b4
movss 0x3871(%rip), %xmm0     # 0x83b0
ja 0x4b69
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x3888(%rip), %xmm0     # 0x83d8
addsd 0x3888(%rip), %xmm0     # 0x83e0
callq 0x2140
mulsd 0x3883(%rip), %xmm0     # 0x83e8
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, %xmm1
andps 0x34ad(%rip), %xmm1     # 0x8020
movq 0x8(%r14), %rax
cmpltss 0x3488(%rip), %xmm1     # 0x8008
andnps %xmm0, %xmm1
leaq (,%rax,2), %rax
addq %rbp, %rax
imulq %r12, %rax
movq %rax, %rcx
shrq $0x3f, %rcx
addq %rax, %rcx
andq $-0x2, %rcx
addq %rcx, %rcx
addq 0x18(%r14), %rcx
movss %xmm1, (%rcx,%r13,4)
incq %r13
cmpq 0x8(%r14), %r13
jl 0x4b05
movq 0x8(%rsp), %r12
cmpq 0x8(%r14), %r12
jl 0x4ae6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0x8(%rdi)
jle 0x4d1d
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), %rax
movq %rax, 0x8(%rsp)
cmpq 0x8(%r14), %rax
jge 0x4d00
movq %r12, %rbp
notq %rbp
movq 0x8(%rsp), %r13
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x524c
testq %rax, %rax
setne %dl
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
setne %sil
andb %dl, %sil
xorps %xmm0, %xmm0
cmpb $0x1, %sil
jne 0x4cc5
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %rcx, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x3783(%rip), %xmm0     # 0x83f0
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
movaps %xmm1, %xmm0
addss 0x3739(%rip), %xmm0     # 0x83b8
ucomiss 0x3386(%rip), %xmm1     # 0x800c
jbe 0x4ca4
andps 0x3391(%rip), %xmm0     # 0x8020
movss 0x3371(%rip), %xmm2     # 0x8008
ucomiss %xmm0, %xmm2
movss 0x370e(%rip), %xmm0     # 0x83b0
jbe 0x4cc5
cvtss2sd %xmm1, %xmm1
movsd 0x3730(%rip), %xmm0     # 0x83e0
subsd %xmm1, %xmm0
callq 0x2140
mulsd 0x3737(%rip), %xmm0     # 0x83f8
cvtsd2ss %xmm0, %xmm0
movq 0x8(%r14), %rax
leaq (,%rax,2), %rax
addq %rbp, %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 0x8(%r14), %r13
jl 0x4c1e
movq 0x8(%rsp), %r12
cmpq 0x8(%r14), %r12
jl 0x4bff
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x51c2
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 0x51b8
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 0x51d1
movss 0x2e6d(%rip), %xmm1     # 0x800c
subss %xmm0, %xmm1
movq 0x18(%r14), %rax
addq %rbp, %rax
movss %xmm1, (%rax,%r12,4)
incq %r12
cmpq %r13, %r12
jl 0x5189
movq 0x8(%rsp), %r15
cmpq %r13, %r15
jne 0x5156
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5243
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 0x51f6
cvtsi2ss %r8, %xmm0
cvtsi2ss %rdi, %xmm1
divss %xmm1, %xmm0
popq %rbx
popq %r14
retq
movss 0x3185(%rip), %xmm0     # 0x83d0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x52b3
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 0x5272
popq %rbx
popq %r14
popq %rbp
jmp 0x52b7
xorl %eax, %eax
xorl %edi, %edi
movq %rdi, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6445
xorl %r15d, %r15d
movq %r15, %rbx
incq %r15
cmpq %rbp, %r15
jge 0x6414
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 0x6421
incq %r13
cmpq %rbp, %r13
jl 0x63fc
cmpq %rbp, %r15
jne 0x63e2
movl $0x1, %r14d
jmp 0x6445
movq 0x6bd0(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2614(%rip), %rsi      # 0x8a46
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_O1/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 0x64b3
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x6496
cmpq $0x0, (%rbx)
jle 0x648d
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x6485
callq 0x2040
incq %r14
cmpq (%rbx), %r14
jl 0x6473
movq 0x10(%rbx), %rdi
callq 0x2040
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x64a4
callq 0x2040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x255f(%rip), %rdi      # 0x8a2c
xorl %eax, %eax
callq 0x2100
cmpq $0x0, (%rbx)
jle 0x6532
leaq 0x27c8(%rip), %r14      # 0x8ca9
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 0x6520
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 0x6502
movl $0xa, %edi
callq 0x2050
incq %r15
cmpq (%rbx), %r15
jl 0x64e4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6c24
cmpl $0x65, %eax
je 0x6c0f
cmpl $0x64, %eax
jne 0x6c38
movups 0x245f(%rip), %xmm0     # 0x9068
movaps %xmm0, (%rsp)
jmp 0x6c46
movups 0x2462(%rip), %xmm0     # 0x9078
movaps %xmm0, (%rsp)
movl $0x736563, 0x10(%rsp)   # imm = 0x736563
jmp 0x6c46
movups 0x2461(%rip), %xmm0     # 0x908c
movaps %xmm0, (%rsp)
movw $0x73, 0x10(%rsp)
jmp 0x6c46
movabsq $0x4e574f4e4b4e55, %rax # imm = 0x4E574F4E4B4E55
movq %rax, (%rsp)
leaq 0x2b52(%rip), %rdi      # 0x979f
callq 0x20b0
leaq 0x2445(%rip), %rdi      # 0x909e
movq %rsp, %rsi
xorl %eax, %eax
callq 0x2100
cmpl $0x0, 0x28(%rbx)
je 0x6c77
leaq 0x2b50(%rip), %rdi      # 0x97c0
callq 0x20b0
jmp 0x6c88
movq (%rbx), %rsi
leaq 0x242d(%rip), %rdi      # 0x90ae
xorl %eax, %eax
callq 0x2100
cmpl $0x0, 0x2c(%rbx)
je 0x6c9c
leaq 0x2b3c(%rip), %rdi      # 0x97d1
callq 0x20b0
jmp 0x6cae
movq 0x8(%rbx), %rsi
leaq 0x2417(%rip), %rdi      # 0x90be
xorl %eax, %eax
callq 0x2100
cmpl $0x64, 0x18(%rbx)
je 0x6ccf
cmpl $0x0, 0x1c(%rbx)
leaq 0x2b25(%rip), %rax      # 0x97e4
leaq 0x2b3b(%rip), %rdi      # 0x9801
cmoveq %rax, %rdi
callq 0x20b0
cmpl $0x0, 0x20(%rbx)
leaq 0x2b44(%rip), %rax      # 0x981e
leaq 0x2b4f(%rip), %rdi      # 0x9830
cmoveq %rax, %rdi
callq 0x20b0
cmpl $0x0, 0x24(%rbx)
leaq 0x2b4c(%rip), %rax      # 0x9841
leaq 0x2b55(%rip), %rdi      # 0x9851
cmoveq %rax, %rdi
callq 0x20b0
movl 0x48(%rbx), %esi
testl %esi, %esi
je 0x6d1a
leaq 0x23bc(%rip), %rdi      # 0x90cf
xorl %eax, %eax
callq 0x2100
leaq 0x2b3f(%rip), %rdi      # 0x9860
callq 0x20b0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7126
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 0x6e83
shrq %rax
cmpq %r14, %rax
jae 0x7109
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_O1/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 0x7714
movslq %esi, %r9
movq -0x8(%rdi,%r9,8), %r10
movq %r10, (%rdi,%r9,8)
decq %r9
cmpq %r8, %r9
jg 0x7703
cmpl %edx, %esi
jge 0x772d
movq 0x8(%rdi,%rcx,8), %rdx
movq %rdx, (%rdi,%rcx,8)
leaq 0x1(%rcx), %rdx
movq %rdx, %rcx
cmpq %rdx, %r8
jne 0x7718
movq %rax, (%rdi,%r8,8)
retq