LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x3c50
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
movslq -0xc(%rbp), %rcx
movl $0x9, %eax
cmpq %rcx, %rax
jne 0x1e25
jmp 0x1e44
leaq 0x634e(%rip), %rdi      # 0x817a
leaq 0x61ff(%rip), %rsi      # 0x8032
movl $0x4b, %edx
leaq 0x6356(%rip), %rcx      # 0x8195
callq 0x1090
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movslq -0x10(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x3ce0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0x1e6a
jmp 0x1e89
leaq 0x6367(%rip), %rdi      # 0x81d8
leaq 0x61ba(%rip), %rsi      # 0x8032
movl $0x4d, %edx
leaq 0x6311(%rip), %rcx      # 0x8195
callq 0x1090
movq -0x30(%rbp), %rcx
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x6348(%rip), %rdi      # 0x81e2
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rdi
callq 0x4ec0
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x1ee6
jmp 0x1f05
leaq 0x6243(%rip), %rdi      # 0x8130
leaq 0x613e(%rip), %rsi      # 0x8032
movl $0xc2, %edx
leaq 0x6346(%rip), %rcx      # 0x8246
callq 0x1090
movq -0x8(%rbp), %rdi
callq 0x4ec0
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1, %esi
leaq 0x28e(%rip), %rcx       # 0x21b0
callq 0x4e10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1f34
jmp 0x1f53
leaq 0x61e0(%rip), %rdi      # 0x811b
leaq 0x60f0(%rip), %rsi      # 0x8032
movl $0xc8, %edx
leaq 0x62f8(%rip), %rcx      # 0x8246
callq 0x1090
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x170(%rbp)
leaq -0x168(%rbp), %rdi
xorl %esi, %esi
movl $0x148, %edx            # imm = 0x148
callq 0x10a0
leaq -0x168(%rbp), %rdi
leaq 0x9c75(%rip), %rsi      # 0xbbf8
movl $0x100, %edx            # imm = 0x100
callq 0x1140
movq -0x170(%rbp), %rdi
movq $0x2, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
leaq -0x168(%rbp), %rsi
movl $0x148, %edx            # imm = 0x148
callq 0x1140
movq -0x18(%rbp), %rdi
callq 0x4950
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x1fc5
jmp 0x1fe4
leaq 0x610e(%rip), %rdi      # 0x80da
leaq 0x605f(%rip), %rsi      # 0x8032
movl $0xd6, %edx
leaq 0x6267(%rip), %rcx      # 0x8246
callq 0x1090
movl -0xc(%rbp), %eax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x21d6
jmp 0x21f5
leaq 0x5f53(%rip), %rdi      # 0x8130
leaq 0x5e4e(%rip), %rsi      # 0x8032
movl $0x9a, %edx
leaq 0x609a(%rip), %rcx      # 0x828a
callq 0x1090
movq -0x8(%rbp), %rdi
callq 0x4ec0
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1, %esi
leaq 0xce(%rip), %rcx        # 0x22e0
callq 0x4e10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2224
jmp 0x2243
leaq 0x60a3(%rip), %rdi      # 0x82ce
leaq 0x5e00(%rip), %rsi      # 0x8032
movl $0xa0, %edx
leaq 0x604c(%rip), %rcx      # 0x828a
callq 0x1090
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x170(%rbp)
leaq -0x168(%rbp), %rdi
xorl %esi, %esi
movl $0x148, %edx            # imm = 0x148
callq 0x10a0
leaq -0x168(%rbp), %rdi
leaq 0x9a85(%rip), %rsi      # 0xbcf8
movl $0x100, %edx            # imm = 0x100
callq 0x1140
movq -0x170(%rbp), %rdi
movq $0x4, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
leaq -0x168(%rbp), %rsi
movl $0x148, %edx            # imm = 0x148
callq 0x1140
movq -0x18(%rbp), %rdi
callq 0x4950
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x22b5
jmp 0x22d4
leaq 0x5e1e(%rip), %rdi      # 0x80da
leaq 0x5d6f(%rip), %rsi      # 0x8032
movl $0xb7, %edx
leaq 0x5fbb(%rip), %rcx      # 0x828a
callq 0x1090
movl -0xc(%rbp), %eax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0x48(%rbp)
movq %rdx, %rsp
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x3ce0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x2389
jmp 0x23a8
leaq 0x5e48(%rip), %rdi      # 0x81d8
leaq 0x5c9b(%rip), %rsi      # 0x8032
movl $0xe1, %edx
leaq 0x6023(%rip), %rcx      # 0x83c6
callq 0x1090
movq -0x48(%rbp), %rdi
movslq -0x18(%rbp), %rsi
leaq 0x5f4c(%rip), %rdx      # 0x8303
movl $0x6, %ecx
callq 0x1120
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x23dc
movl $0x0, -0x4(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0x242a
movq -0x48(%rbp), %r8
movq -0x38(%rbp), %rax
subq %r8, %rax
addq $0x6, %rax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x5ffe(%rip), %rdi      # 0x840b
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rdi
callq 0x4ec0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x3c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0x50(%rbp)
movq %rdx, %rsp
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x3ce0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x2499
jmp 0x24b8
leaq 0x5d38(%rip), %rdi      # 0x81d8
leaq 0x5b8b(%rip), %rsi      # 0x8032
movl $0x144, %edx            # imm = 0x144
leaq 0x5fb6(%rip), %rcx      # 0x8469
callq 0x1090
movq -0x50(%rbp), %rdi
movslq -0x18(%rbp), %rsi
leaq 0x5d69(%rip), %rdx      # 0x8230
movl $0x5, %ecx
callq 0x1120
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x24ef
movl $0x0, -0x4(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x2581
movq -0x50(%rbp), %rdi
movslq -0x18(%rbp), %rsi
leaq 0x5e05(%rip), %rdx      # 0x8303
movl $0x6, %ecx
callq 0x1120
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x2523
movl $0x0, -0x4(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x2581
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %rax
subq %rcx, %rax
addq $0x6, %rax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
addq $0x6, %rax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x18(%rbp), %ecx
movq -0x38(%rbp), %r8
leaq 0x5f48(%rip), %rdi      # 0x84ac
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rdi
callq 0x4ec0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x44(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3450
movq -0x18(%rbp), %rdi
callq 0x3570
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2ca2
movq 0xc374(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x84c7(%rip), %rsi      # 0xb155
movb $0x0, %al
callq 0x2150
movq $0x0, -0x8(%rbp)
jmp 0x2d2d
jmp 0x2ca4
movq -0x28(%rbp), %rax
cmpq $0x2, 0x10(%rax)
jle 0x2d05
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x3670
movss %xmm0, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
xorl %r8d, %r8d
callq 0x37a0
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x3a00
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x3c30
jmp 0x2ca4
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movl $0x65, %r8d
callq 0x37a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x3252
movq 0xbd87(%rip), %rax      # 0xefd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x32be
cmpq $0x0, -0x20(%rbp)
jne 0x3273
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7fd0(%rip), %rsi      # 0xb238
callq 0x21c0
movq %rax, -0x28(%rbp)
jmp 0x328b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x8a7a(%rip), %rsi      # 0xbcfc
callq 0x21c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x32bc
movq 0xbd5f(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x7f8f(%rip), %rsi      # 0xb23a
movb $0x0, %al
callq 0x2150
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
jmp 0x32be
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x4bb0
movq -0x28(%rbp), %rdi
leaq 0x7f7d(%rip), %rsi      # 0xb25f
movb $0x0, %al
callq 0x2150
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x32fc
movq -0x28(%rbp), %rdi
callq 0x20b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sheneman[P]clearcut/clearcut.c
// Function: NJ_free_tree
void
NJ_free_tree(NJ_TREE *node) {

  if(!node) {
    return;
  }
  
  if(node->left) {
    NJ_free_tree(node->left);
  }
  
  if(node->right) {
    NJ_free_tree(node->right);
  }
  
  free(node);

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3325
jmp 0x335c
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x333b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3310
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3353
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3310
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x343d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x33ec
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x33df
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x33cf
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
jmp 0x33d1
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x339a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3404
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x341c
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x3434
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
subq $0x2, %rax
cvtsi2ss %rax, %xmm0
movss %xmm0, -0x4c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x48(%rbp), %rax
jge 0x356e
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x353e
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
addss (%rax,%rcx,4), %xmm0
movss %xmm0, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x34dc
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
divss -0x4c(%rbp), %xmm0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x34b6
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x2130
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x8, %esi
callq 0x2130
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x365f
movl $0x1, %edi
movl $0x20, %esi
callq 0x2130
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x35df
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movss 0x7988(%rip), %xmm0     # 0xb020
movss %xmm0, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x3777
movq -0x48(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x3764
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x48(%rbp)
movss (%rax), %xmm0
movq -0x50(%rbp), %rax
movq -0x20(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
addss (%rax,%rcx,4), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x40(%rbp), %xmm1
movss -0x3c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x3754
movss -0x40(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x3756
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x36e7
jmp 0x3766
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x36bd
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movss -0x3c(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x41d9
movq 0xae3a(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x71b9(%rip), %rsi      # 0xb381
movb $0x0, %al
callq 0x2150
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x4209
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x41e1
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jge 0x4290
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
subq -0x18(%rbp), %rdi
callq 0x9440
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x4280
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x4282
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4211
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sheneman[P]clearcut/./common.h
// Function: NJ_FLT_EQ
static inline
int
NJ_FLT_EQ(float x,
	  float y) {
  
  if(fabs(x - y)<FLT_EPSILON) {
    return(1);
  } else {
    return(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
subss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movaps 0x6a0d(%rip), %xmm0     # 0xb030
pand %xmm0, %xmm1
movsd 0x69e9(%rip), %xmm0     # 0xb018
ucomisd %xmm1, %xmm0
jbe 0x463e
movl $0x1, -0x4(%rbp)
jmp 0x4645
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sheneman[P]clearcut/./common.h
// Function: NJ_FLT_LT
static inline
int
NJ_FLT_LT(float x,
	  float y) {
  
  if(NJ_FLT_EQ(x, y)) {
    return(0);
  } else {
    if(x < y) {
      return(1);
    } else {
      return(0);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
callq 0x4600
cmpl $0x0, %eax
je 0x467f
movl $0x0, -0x4(%rbp)
jmp 0x469e
movss -0x8(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4697
movl $0x1, -0x4(%rbp)
jmp 0x469e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4934
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x492b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x64b0(%rip), %rdi      # 0xb27b
movb $0x0, %al
callq 0x20e0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x4e17
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rsi
leaq 0x6496(%rip), %rdi      # 0xb298
movb $0x0, %al
callq 0x20e0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4dda
leaq 0x6418(%rip), %rdi      # 0xb236
movb $0x0, %al
callq 0x20e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x63f3(%rip), %rdi      # 0xb236
movb $0x0, %al
callq 0x20e0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x4e95
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x641d(%rip), %rdi      # 0xb29d
movb $0x1, %al
callq 0x20e0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4e52
leaq 0x639a(%rip), %rdi      # 0xb236
movb $0x0, %al
callq 0x20e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x63e3(%rip), %rdi      # 0xb2ad
movb $0x0, %al
callq 0x20e0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x4f16
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x63c1(%rip), %rdi      # 0xb2c2
movb $0x0, %al
callq 0x20e0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4ed9
leaq 0x6319(%rip), %rdi      # 0xb236
movb $0x0, %al
callq 0x20e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x4f81
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x63a2(%rip), %rdi      # 0xb30e
movb $0x0, %al
callq 0x20e0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4f48
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x6845(%rip), %rdi      # 0xb7dd
movb $0x0, %al
callq 0x20e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss 0x5cd0(%rip), %xmm0     # 0xb3b8
movss %xmm0, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x5876
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x5863
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x6110
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5ff0
cvtss2sd %xmm0, %xmm1
movsd 0x58ad(%rip), %xmm0     # 0xb008
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
ucomiss -0x30(%rbp), %xmm0
jbe 0x5782
movss 0x5c41(%rip), %xmm0     # 0xb3bc
movss %xmm0, -0x34(%rbp)
jmp 0x57c0
movss -0x2c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5c3d(%rip), %xmm1     # 0xb3d0
mulsd %xmm1, %xmm0
movsd 0x5869(%rip), %xmm1     # 0xb008
addsd %xmm1, %xmm0
callq 0x2120
movaps %xmm0, %xmm1
movsd 0x5c15(%rip), %xmm0     # 0xb3c8
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x34(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movaps 0x5860(%rip), %xmm0     # 0xb030
pand %xmm0, %xmm1
movsd 0x583c(%rip), %xmm0     # 0xb018
ucomisd %xmm1, %xmm0
jbe 0x5814
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x60d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x5850
movss -0x34(%rbp), %xmm0
movss %xmm0, -0x54(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x60d0
movss -0x54(%rbp), %xmm0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movss %xmm0, (%rax,%rcx,4)
jmp 0x5852
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5713
jmp 0x5865
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x56f5
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x59e9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x59d6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x6110
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x58ef
cmpq $0x0, -0x28(%rbp)
jne 0x58fc
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
jmp 0x5989
cvtsi2ssq -0x30(%rbp), %xmm0
cvtsi2ssq -0x28(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x34(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x5ab6(%rip), %xmm0     # 0xb3d8
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x38(%rbp), %xmm0
movss 0x56ec(%rip), %xmm1     # 0xb028
callq 0x61f0
cmpl $0x0, %eax
je 0x5955
movss 0x5a6e(%rip), %xmm0     # 0xb3bc
movss %xmm0, -0x34(%rbp)
jmp 0x5987
movss -0x38(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x56a2(%rip), %xmm0     # 0xb008
subsd %xmm1, %xmm0
callq 0x2120
movaps %xmm0, %xmm1
movsd 0x5a66(%rip), %xmm0     # 0xb3e0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
jmp 0x5989
movss -0x34(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x60d0
movss -0x44(%rbp), %xmm0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movss %xmm0, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x58b6
jmp 0x59d8
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5898
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x5fde
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x5fcb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5ff0
cvtss2sd %xmm0, %xmm1
movsd 0x5097(%rip), %xmm0     # 0xb008
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x60d0
movss -0x34(%rbp), %xmm0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movss %xmm0, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5f46
jmp 0x5fcd
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5f28
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x60b3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
imulq 0x8(%rdx), %rcx
addq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x39(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
imulq 0x8(%rdx), %rcx
addq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x3a(%rbp)
movsbl -0x39(%rbp), %eax
cmpl $0x3f, %eax
jne 0x607a
movsbl -0x3a(%rbp), %eax
cmpl $0x3f, %eax
je 0x60a0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movsbl -0x39(%rbp), %eax
movsbl -0x3a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x609e
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x60a0
jmp 0x60a2
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6018
cvtsi2ssq -0x38(%rbp), %xmm0
cvtsi2ssq -0x30(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x61d7
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
imulq 0x8(%rdx), %rcx
addq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
imulq 0x8(%rdx), %rcx
addq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x32(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x3f, %eax
jne 0x619e
movsbl -0x32(%rbp), %eax
cmpl $0x3f, %eax
je 0x61c4
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movsbl -0x31(%rbp), %eax
movsbl -0x32(%rbp), %ecx
cmpl %ecx, %eax
je 0x61c2
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x61c4
jmp 0x61c6
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x613c
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sheneman[P]clearcut/./common.h
// Function: NJ_FLT_GT
static inline
int
NJ_FLT_GT(float x,
	  float y) {
  
  if(NJ_FLT_EQ(x, y)) {
    return(0);
  } else {
    if(x > y) {
      return(1);
    } else {
      return(0);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
callq 0x6440
cmpl $0x0, %eax
je 0x621f
movl $0x0, -0x4(%rbp)
jmp 0x623a
movss -0x8(%rbp), %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x6233
movl $0x1, -0x4(%rbp)
jmp 0x623a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sheneman[P]clearcut/dmat.c
// Function: NJ_is_whitespace
static inline
int
NJ_is_whitespace(char c) {

  if( c == ' '  ||   /* space           */
      c == '\n' ||   /* newline         */
      c == '\r' ||   /* carriage-return */
      c == '\v' ||   /* vertical tab    */
      c == '\f' ||   /* form feed       */
      c == '\t' ) {  /* horizontal tab  */
    return(1);
  } else {
    return(0);
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x20, %eax
je 0x72d0
movsbl -0x5(%rbp), %eax
cmpl $0xa, %eax
je 0x72d0
movsbl -0x5(%rbp), %eax
cmpl $0xd, %eax
je 0x72d0
movsbl -0x5(%rbp), %eax
cmpl $0xb, %eax
je 0x72d0
movsbl -0x5(%rbp), %eax
cmpl $0xc, %eax
je 0x72d0
movsbl -0x5(%rbp), %eax
cmpl $0x9, %eax
jne 0x72d9
movl $0x1, -0x4(%rbp)
jmp 0x72e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sheneman[P]clearcut/dmat.c
// Function: NJ_is_number
static inline
int
NJ_is_number(char c) {
  if(c >= '0' && c <= '9') {
    return(1);
  } else {
    return(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0x7565
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x7565
movl $0x1, -0x4(%rbp)
jmp 0x756c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sheneman[P]clearcut/fasta.c
// Function: NJ_is_dna
static inline
int
NJ_is_dna(char c) {

  int i;
  char up_c;
  
  up_c = toupper(c);
  
  for(i=0;i<NJ_NUM_DNA_SYMS;i++) {
    if(up_c == NJ_dna_syms[i]) {
      return(1);
    }
  }

  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %edi
callq 0x2090
movb %al, -0xd(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
jge 0x7e34
movsbl -0xd(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0x3c6a(%rip), %rcx      # 0xba80
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x7e27
movl $0x1, -0x4(%rbp)
jmp 0x7e3b
jmp 0x7e29
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7e01
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sheneman[P]clearcut/fasta.c
// Function: NJ_is_dna_ambiguity
static inline
int
NJ_is_dna_ambiguity(char c) {
  
  int i;
  char up_c;
  
  up_c = toupper(c);
  
  for(i=0;i<NJ_NUM_DNA_AMBIGUITY_SYMS;i++) {
    if(up_c == NJ_dna_ambiguity_syms[i]) {
      return(1);
    }
  }
  
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %edi
callq 0x2090
movb %al, -0xd(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xe, -0xc(%rbp)
jge 0x7ea4
movsbl -0xd(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0x3bff(%rip), %rcx      # 0xba85
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x7e97
movl $0x1, -0x4(%rbp)
jmp 0x7eab
jmp 0x7e99
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7e71
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sheneman[P]clearcut/fasta.c
// Function: NJ_is_protein
static inline
int
NJ_is_protein(char c) {

  int i;
  char up_c;
  
  up_c = toupper(c);
  
  for(i=0;i<NJ_NUM_PROTEIN_SYMS;i++) {
    if(up_c == NJ_protein_syms[i]) {
      return(1);
    }
  }
  
  return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %edi
callq 0x2090
movb %al, -0xd(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0x7f14
movsbl -0xd(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0x3baa(%rip), %rcx      # 0xbaa0
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x7f07
movl $0x1, -0x4(%rbp)
jmp 0x7f1b
jmp 0x7f09
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7ee1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)