LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/graph.c
// Function: exist_strong_edge
static inline int exist_strong_edge(graph_t *g, uint32_t v, double wt)
{
    uint32_t na;
    graph_arc_t *a, *av;
    na = graph_arc_n(g, v);
    if (na < 2) 
        return 0;
    av = graph_arc_a(g, v);
    for (a = av; a < av + na; ++a)
        if (a->wt > wt)
            return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
jae 0xa401
movl $0x0, -0x4(%rbp)
jmp 0xa476
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0x14(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0xa46f
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0xa45f
movl $0x1, -0x4(%rbp)
jmp 0xa476
jmp 0xa461
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0xa42f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/graph.c
// Function: trim_graph_ambiguous_edges
int trim_graph_ambiguous_edges(graph_t *g)
{
    uint32_t n_del;
    graph_arc_t *a;
    n_del = 0;
    for (a = g->arc; a < g->arc + g->n_arc; ++a)
        if (graph_arc_n(g, a->v) > 1 || graph_arc_n(g, a->w^1) > 1)
            n_del += graph_arc_del_existed(g, a);

    graph_clean(g, 1);

#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] #del ambiguous edges: %u\n", __func__, n_del);
#endif

    return n_del;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x18(%rdx), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0xa516
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
cmpl $0x1, %eax
ja 0xa4f3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
xorl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
cmpl $0x1, %eax
jbe 0xa506
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x97e0
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xa508
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0xa49f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x88e0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/./agp-spec.h
// Function: agp_orientation_rev
static inline AGP_OT_t agp_orientation_rev(uint32_t key)
{
    switch ((AGP_OT_t) key) {
        case AGP_OT_PLUS:    return AGP_OT_MINUS;
        case AGP_OT_MINUS:   return AGP_OT_PLUS;
        case AGP_OT_UNKNOWN:
        case AGP_OT_ZERO:
        case AGP_OT_ZERO_S:
        case AGP_OT_NA:      return key;
        default:             AGPSpec_die("[E::%s] AGP orientation KEY error: %u\n", __func__, key);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x2b5d0, %eax          # imm = 0x2B5D0
je 0xb776
jmp 0xb73a
movl -0xc(%rbp), %eax
subl $0x2b5d2, %eax          # imm = 0x2B5D2
je 0xb77f
jmp 0xb746
movl -0xc(%rbp), %eax
subl $0x2b5d5, %eax          # imm = 0x2B5D5
je 0xb788
jmp 0xb752
movl -0xc(%rbp), %eax
subl $0x2b5e4, %eax          # imm = 0x2B5E4
je 0xb788
jmp 0xb75e
movl -0xc(%rbp), %eax
subl $0x5978d4, %eax         # imm = 0x5978D4
je 0xb788
jmp 0xb76a
movl -0xc(%rbp), %eax
subl $0x7ca1b285, %eax       # imm = 0x7CA1B285
je 0xb788
jmp 0xb790
movl $0x2b5d2, -0x4(%rbp)    # imm = 0x2B5D2
jmp 0xb7af
movl $0x2b5d0, -0x4(%rbp)    # imm = 0x2B5D0
jmp 0xb7af
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb7af
movl -0x8(%rbp), %edx
leaq 0x25c7e(%rip), %rdi     # 0x31418
leaq 0x25c9e(%rip), %rsi     # 0x3143f
movb $0x0, %al
callq 0xbb30
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/link.c
// Function: intra_link_mat_destroy
KHASH_SET_INIT_STR(str)

void intra_link_mat_destroy(intra_link_mat_t *link_mat)
{
    if (!link_mat) return;
    uint32_t i;
    for (i = 0; i < link_mat->n; ++i)
        if (link_mat->links[i].n)
            free(link_mat->links[i].link);
    if (link_mat->links)
        free(link_mat->links);
    free(link_mat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xd8f5
jmp 0xd968
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xd947
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x4(%rax)
je 0xd93a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2050
jmp 0xd93c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd8fc
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd95f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/link.c
// Function: inter_link_mat_destroy
void inter_link_mat_destroy(inter_link_mat_t *link_mat)
{
    if (!link_mat) return;
    uint32_t i, j;
    for (i = 0; i < link_mat->n; ++i) {
        if (link_mat->links[i].n) {
            for (j = 0; j < 4; ++j) {
                free(link_mat->links[i].link[j]);
                free(link_mat->links[i].linkb[j]);
            }
        }
    }
    if (link_mat->links)
        free(link_mat->links);
    free(link_mat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xd988
jmp 0xda3f
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xda1e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
cmpl $0x0, 0x14(%rax)
je 0xda0e
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jae 0xda0c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movl -0x10(%rbp), %ecx
movq 0x20(%rax,%rcx,8), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movl -0x10(%rbp), %ecx
movq 0x40(%rax,%rcx,8), %rdi
callq 0x2050
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd9bd
jmp 0xda0e
jmp 0xda10
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd98f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xda36
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/link.c
// Function: estimate_intra_link_mat_init_rss
long estimate_intra_link_mat_init_rss(void *dict, uint32_t resolution, int use_gap_seq)
{
    long bytes, p;
    uint32_t i, n, b;
    uint64_t len;

    n = use_gap_seq? ((asm_dict_t *) dict)->n : ((sdict_t *) dict)->n;

    bytes = 0;
    bytes += sizeof(intra_link_mat_t);
    bytes += n * sizeof(intra_link_t);

    for (i = 0; i < n; ++i) {
        len = use_gap_seq? ((asm_dict_t *) dict)->s[i].len : ((sdict_t *) dict)->s[i].len;
        if (len < resolution)
            continue;
        b = div_ceil(len, resolution);
        p = (long) b * (b + 1) / 2;
        if (p > UINT32_MAX)
            return -1;

        bytes += p * sizeof(double);
    }
    return bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xe243
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0xe24c
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
shlq $0x4, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jae 0xe338
cmpl $0x0, -0x18(%rbp)
je 0xe2aa
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x2c(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xe2c3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x2c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jae 0xe2d9
jmp 0xe32a
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2aa0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x28(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x28(%rbp)
jle 0xe31a
movq $-0x1, -0x8(%rbp)
jmp 0xe340
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xe27c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/link.c
// Function: norm_destroy
void norm_destroy(norm_t *norm)
{
    if (!norm) return;
    //uint32_t i;
    free(norm->bs);
    //for (i = 0; i < norm->n; ++i)
    //    free(norm->link[i]);
    //free(norm->link);
    free(norm->linkc);
    free(norm->norms);
    free(norm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x10085
jmp 0x100b5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/link.c
// Function: print_inter_link_norms
void print_inter_link_norms(FILE *fp, inter_link_mat_t *link_mat, asm_dict_t *dict)
{
    uint32_t i, n;
    inter_link_t *link;

    n = link_mat->n;
    for (i = 0; i < n; ++i) {
        link = &link_mat->links[i];
        if (link->n)
            fprintf(fp, "NORM: %s %s (%u) [%.3f %.3f %.3f %.3f]\n", dict->s[link->c0].name, dict->s[link->c1].name, link->n0, link->norms[0], link->norms[1], link->norms[2], link->norms[3]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x107cf
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x107bf
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movl 0x4(%rcx), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movl 0x18(%rax), %r8d
movq -0x28(%rbp), %rax
movsd 0x60(%rax), %xmm0
movq -0x28(%rbp), %rax
movsd 0x68(%rax), %xmm1
movq -0x28(%rbp), %rax
movsd 0x70(%rax), %xmm2
movq -0x28(%rbp), %rax
movsd 0x78(%rax), %xmm3
leaq 0x2100a(%rip), %rsi     # 0x317c2
movb $0x4, %al
callq 0x22c0
jmp 0x107c1
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10724
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/link.c
// Function: print_inter_link_bands
void print_inter_link_bands(FILE *fp, inter_link_mat_t *link_mat, asm_dict_t *dict)
{
    uint32_t i, j, k, n;
    inter_link_t *link;
    
    n = link_mat->n;
    for (i = 0; i < n; ++i) {
        link = &link_mat->links[i];
        if (link->n) {
            for (j = 0; j < 4; ++j) {
                fprintf(fp, "BAND [%u %u]: %s%s %s%s (%u, %u) [%.3f]", i, j, dict->s[link->c0].name, j < 2? "-" : "+", dict->s[link->c1].name, j & 1? "-" : "+", link->n0, link->r, link->norms[j]);
                for (k = 0; k < link->r; ++k)
                    fprintf(fp, " %.0f", link->linkb[j][k]);
                fprintf(fp, "\n");
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jae 0x1096a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x2c(%rbp), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x1095a
movl $0x0, -0x30(%rbp)
cmpl $0x4, -0x30(%rbp)
jae 0x10958
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x40(%rbp), %rsi
movl (%rsi), %esi
imulq $0x58, %rsi, %rsi
addq %rsi, %rax
movq (%rax), %r8
movl -0x30(%rbp), %esi
leaq 0x20f9e(%rip), %r9      # 0x31812
leaq 0x20a8e(%rip), %rax     # 0x31309
cmpl $0x2, %esi
cmovbq %rax, %r9
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x40(%rbp), %rsi
movl 0x4(%rsi), %esi
imulq $0x58, %rsi, %rsi
addq %rsi, %rax
movq (%rax), %rbx
movl -0x30(%rbp), %esi
andl $0x1, %esi
leaq 0x20f6a(%rip), %r11     # 0x31812
leaq 0x20a5a(%rip), %rax     # 0x31309
cmpl $0x0, %esi
cmovneq %rax, %r11
movq -0x40(%rbp), %rax
movl 0x18(%rax), %r10d
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x40(%rbp), %rsi
movl -0x30(%rbp), %r14d
movsd 0x60(%rsi,%r14,8), %xmm0
leaq 0x20f0f(%rip), %rsi     # 0x317ea
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movb $0x1, %al
callq 0x22c0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x40(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x10938
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rax
movl -0x30(%rbp), %ecx
movq 0x40(%rax,%rcx,8), %rax
movl -0x34(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
leaq 0x20eee(%rip), %rsi     # 0x31814
movb $0x1, %al
callq 0x22c0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x108fb
movq -0x18(%rbp), %rdi
leaq 0x20c28(%rip), %rsi     # 0x3156b
movb $0x0, %al
callq 0x22c0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1083e
jmp 0x1095a
jmp 0x1095c
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x10807
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/link.c
// Function: get_max_inter_norms
double *get_max_inter_norms(inter_link_mat_t *link_mat, asm_dict_t *dict)
{
    uint32_t i, j, n, c0, c1;
    double *max_norms;
    inter_link_t *link;

    n = link_mat->n;
    max_norms = (double *) calloc(dict->n, sizeof(double));
    for (i = 0; i < n; ++i) {
        link = &link_mat->links[i];
        if (link->n) {
            c0 = link->c0;
            c1 = link->c1;
            for (j = 0; j < 4; ++j) {
                max_norms[c0] = MAX(max_norms[c0], link->norms[j]);
                max_norms[c1] = MAX(max_norms[c1], link->norms[j]);
            }
        }
    }
    return max_norms;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x2290
movq %rax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x10acc
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x10abc
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jae 0x10aba
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
movq -0x38(%rbp), %rax
movl -0x18(%rbp), %ecx
ucomisd 0x60(%rax,%rcx,8), %xmm0
jbe 0x10a38
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x10a4a
movq -0x38(%rbp), %rax
movl -0x18(%rbp), %ecx
movsd 0x60(%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
movsd %xmm0, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
movq -0x38(%rbp), %rax
movl -0x18(%rbp), %ecx
ucomisd 0x60(%rax,%rcx,8), %xmm0
jbe 0x10a89
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x10a9b
movq -0x38(%rbp), %rax
movl -0x18(%rbp), %ecx
movsd 0x60(%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x10a00
jmp 0x10abc
jmp 0x10abe
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x109b6
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/link.c
// Function: print_norms
void print_norms(FILE *fp, norm_t *norm)
{
    uint32_t i/**, j, n**/;
    //uint64_t link_count;
    //double *link;

    //link_count = 0;

    fprintf(fp, "norms:");
    for (i = 0; i < norm->n; ++i)
        fprintf(fp, " %.1f", norm->norms[i]);
    fprintf(fp, "\n");
    
    fprintf(fp, "links:");
    for (i = 0; i < norm->n; ++i)
        fprintf(fp, " %.0f", norm->linkc[i]);
    fprintf(fp, "\n");

    /***
    for (i = 0; i < norm->n; ++i) {
        fprintf(fp, "band %d:", i);
        n = norm->bs[i];
        link = norm->link[i];
        for (j = 0; j < n; ++j) {
            link_count += link[j];
            fprintf(fp, " %.0f", link[j]);
        }
        fprintf(fp, "\n");
    }
    **/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x20d1f(%rip), %rsi     # 0x3181a
movb $0x0, %al
callq 0x22c0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x10b41
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
leaq 0x20cf2(%rip), %rsi     # 0x31821
movb $0x1, %al
callq 0x22c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10b09
movq -0x8(%rbp), %rdi
leaq 0x20a1f(%rip), %rsi     # 0x3156b
movb $0x0, %al
callq 0x22c0
movq -0x8(%rbp), %rdi
leaq 0x20cc9(%rip), %rsi     # 0x31827
movb $0x0, %al
callq 0x22c0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x10ba4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x14(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
leaq 0x20c82(%rip), %rsi     # 0x31814
movb $0x1, %al
callq 0x22c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10b6c
movq -0x8(%rbp), %rdi
leaq 0x209bc(%rip), %rsi     # 0x3156b
movb $0x0, %al
callq 0x22c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/link.c
// Function: parse_bam_rec
static char *parse_bam_rec(bam1_t *b, bam_header_t *h, int32_t *s, int32_t *e, uint8_t *q, char **cname)
{
    // 0x4 0x100 0x200 0x400 0x800
    if ((b->core.flag & 0xF04) || (!b->core.flag))
        return 0;
    *cname = h->target_name[b->core.tid];
    *s = b->core.pos;
    *e = get_target_end(b);
    *q = b->core.qual;

    return strdup(bam1_qname(b));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
andl $0xf04, %eax            # imm = 0xF04
cmpl $0x0, %eax
jne 0x136a3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
cmpl $0x0, %eax
jne 0x136ad
movq $0x0, -0x8(%rbp)
jmp 0x13710
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x4140
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2520
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/link.c
// Function: parse_bam_rec1
static int parse_bam_rec1(bam1_t *b, bam_header_t *h, char **cname0, int32_t *s0, int32_t *e0, char **cname1, int32_t *s1)
{
    // 0x4 0x8 [0x40] 0x100 0x200 0x400 0x800
    // if (b->core.flag & 0xF4C)
    if ((b->core.flag & 0xF0C) || (!b->core.flag))
        return -1;

    *cname0 = h->target_name[b->core.tid];
    *s0 = b->core.pos;
    *e0 = get_target_end(b);
    *cname1 = h->target_name[b->core.mtid];
    *s1 = b->core.mpos;

    return (b->core.flag & 0x40)? 1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
andl $0xf0c, %eax            # imm = 0xF0C
cmpl $0x0, %eax
jne 0x13ad7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
cmpl $0x0, %eax
jne 0x13ae3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13b6a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x4140
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x14(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, %edx
andl $0x40, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/cov.c
// Function: cov_init
cov_t *cov_init(uint32_t n)
{
    cov_t *cov = (cov_t *) malloc(sizeof(cov_t));
    cov->n = n;
    cov->p = (pos_t *) malloc(sizeof(pos_t) * n);
    uint32_t i;
    for (i = 0; i < n; ++i)
        kv_init(cov->p[i]);

    return cov;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x2340
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %eax
imulq $0x18, %rax, %rdi
callq 0x2340
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x1cf80
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1cf20
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/cov.c
// Function: cov_destroy
void cov_destroy(cov_t* cov)
{
    if (!cov) return;
    uint32_t i;
    for (i = 0; i < cov->n; ++i)
        kv_destroy(cov->p[i]);
    free(cov->p);
    free(cov);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1cfa5
jmp 0x1cff3
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x1cfdd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1cfac
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/cov.c
// Function: cov_norm_destroy
void cov_norm_destroy(cov_norm_t *cov_norm)
{
    if (!cov_norm) return;
    free(cov_norm->norm[0]);
    free(cov_norm->norm);
    free(cov_norm);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1d015
jmp 0x1d03b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/cov.c
// Function: diff_target_length
static int diff_target_length(uint32_t *target_len, sdict_t *sdict)
{
    uint32_t i;
    for (i = 0; i < sdict->n; ++i)
        if (target_len[i] != sdict->s[i].len)
            return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x1d945
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl -0x1c(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
je 0x1d938
movl $0x1, -0x4(%rbp)
jmp 0x1d94c
jmp 0x1d93a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1d903
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/cov.c
// Function: diff_target_name
static int diff_target_name(char **target_name, sdict_t *sdict)
{
    uint32_t i;
    for (i = 0; i < sdict->n; ++i)
        if (strcmp(target_name[i], sdict->s[i].name))
            return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x1d9c2
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x22a0
cmpl $0x0, %eax
je 0x1d9b5
movl $0x1, -0x4(%rbp)
jmp 0x1d9c9
jmp 0x1d9b7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1d977
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/cov.c
// Function: kh_ctab_put1
static void kh_ctab_put1(kh_ctab_t *ctab, int32_t c, int cnt)
{
    int absent;
    khint_t k;
    k = kh_put_ctab(ctab, c, &absent);
    if (absent)
        kh_val(ctab, k) = cnt;
    else
        kh_val(ctab, k) += cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x1f800
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1e9c1
movslq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x18(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x1e9d8
movslq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x18(%rbp), %ecx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/cov.c
// Function: print_cov_in_bed
void print_cov_in_bed(cov_t *cov, sdict_t *sdict, FILE *fo)
{
    size_t i, j, s;
    int32_t c;
    uint32_t p, p1;
    uint64_t *a;

    for (i = 0; i < cov->n; ++i) {
        a = cov->p[i].a;
        s = cov->p[i].n;

        p = 0, c = 0;
        for (j = 0; j < s; ++j) {
            p1 = (uint32_t) (a[j] >> 32);
            if (p1 > p)
                fprintf(fo, "%s\t%u\t%u\t%d\n", sdict->s[i].name, p, p1, c);
            p = p1;
            c += (int32_t) a[j];
        }

        if (p < sdict->s[i].len)
            fprintf(fo, "%s\t%u\t%u\t%d\n", sdict->s[i].name, p, sdict->s[i].len, 0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x1f389
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x1f31f
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x20, %rax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jbe 0x1f2f9
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdx
movl -0x38(%rbp), %ecx
movl -0x3c(%rbp), %r8d
movl -0x34(%rbp), %r9d
leaq 0x1347f(%rip), %rsi     # 0x32771
movb $0x0, %al
callq 0x22c0
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1f2a4
movl -0x38(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
imulq $0x18, -0x20(%rbp), %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jae 0x1f376
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdx
movl -0x38(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x18, -0x20(%rbp), %rsi
addq %rsi, %rax
movl 0x10(%rax), %r8d
leaq 0x13405(%rip), %rsi     # 0x32771
xorl %r9d, %r9d
movb $0x0, %al
callq 0x22c0
jmp 0x1f378
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1f24c
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/binomlite.c
// Function: rexpm1
double rexpm1(double x)
{
/* ----------------------------------------------------------------------- */
/*            EVALUATION OF THE FUNCTION EXP(X) - 1 */
/* ----------------------------------------------------------------------- */

    static double p1 = 9.14041914819518e-10;
    static double p2 = .0238082361044469;
    static double q1 = -.499999999085958;
    static double q2 = .107141568980644;
    static double q3 = -.0119041179760821;
    static double q4 = 5.95130811860248e-4;

    if (fabs(x) <= 0.15) {
    return x * (((p2 * x + p1) * x + 1.) /
            ((((q4 * x + q3) * x + q2) * x + q1) * x + 1.));
    }
    else { /* |x| > 0.15 : */
    double w = exp(x);
    if (x > 0.)
        return w * (0.5 - 1. / w + 0.5);
    else
        return w - 0.5 - 0.5;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm1
movaps 0x11407(%rip), %xmm0    # 0x32af0
pand %xmm0, %xmm1
movsd 0x1110b(%rip), %xmm0    # 0x32800
ucomisd %xmm1, %xmm0
jb 0x217a1
movsd -0x10(%rbp), %xmm0
movsd 0x17d1c(%rip), %xmm1    # 0x39428
movsd -0x10(%rbp), %xmm3
movsd 0x17d07(%rip), %xmm2    # 0x39420
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd -0x10(%rbp), %xmm2
mulsd %xmm2, %xmm1
movsd 0xfec6(%rip), %xmm2     # 0x315f8
addsd %xmm2, %xmm1
movsd 0x17d0a(%rip), %xmm2    # 0x39448
movsd -0x10(%rbp), %xmm4
movsd 0x17cf5(%rip), %xmm3    # 0x39440
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
movsd -0x10(%rbp), %xmm4
movsd 0x17cd8(%rip), %xmm3    # 0x39438
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
movsd -0x10(%rbp), %xmm4
movsd 0x17cbb(%rip), %xmm3    # 0x39430
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
movsd -0x10(%rbp), %xmm3
mulsd %xmm3, %xmm2
movsd 0xfe6a(%rip), %xmm3     # 0x315f8
addsd %xmm3, %xmm2
divsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x21815
movsd -0x10(%rbp), %xmm0
callq 0x2560
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x217f3
movsd -0x18(%rbp), %xmm0
movsd 0xfe2d(%rip), %xmm2     # 0x315f8
divsd -0x18(%rbp), %xmm2
movsd 0xfe28(%rip), %xmm1     # 0x31600
subsd %xmm2, %xmm1
movsd 0xfe1c(%rip), %xmm2     # 0x31600
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x21815
movsd -0x18(%rbp), %xmm0
movsd 0xfe00(%rip), %xmm1     # 0x31600
subsd %xmm1, %xmm0
movsd 0xfdf4(%rip), %xmm1     # 0x31600
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/binomlite.c
// Function: apser
static double apser(double a, double b, double x, double eps)
{
/* -----------------------------------------------------------------------
 *     apser() yields the incomplete beta ratio  I_{1-x}(b,a)  for
 *     a <= min(eps,eps*b), b*x <= 1, and x <= 0.5,  i.e., a is very small.
 *     Use only if above inequalities are satisfied.
 * ----------------------------------------------------------------------- */

    static double const g = .577215664901533;

    double tol, c, j, s, t, aj;
    double bx = b * x;

    t = x - bx;
    if (b * eps <= 0.02)
        c = log(x) + psi(b) + g + t;
    else // b > 2e13 : psi(b) ~= log(b)
        c = log(bx) + g + t;

    tol = eps * 5. * fabs(c);
    j = 1.;
    s = 0.;
    do {
        j += 1.;
        t *= x - bx / j;
        aj = t / j;
        s += aj;
    } while (fabs(aj) > tol);

    return -a * (c + s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x10(%rbp), %xmm1
mulsd -0x20(%rbp), %xmm1
movsd 0x10f9c(%rip), %xmm0    # 0x32808
ucomisd %xmm1, %xmm0
jb 0x218af
movsd -0x18(%rbp), %xmm0
callq 0x2250
movsd %xmm0, -0x60(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x24f40
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd 0x10f71(%rip), %xmm1    # 0x32810
addsd %xmm1, %xmm0
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x218cf
movsd -0x58(%rbp), %xmm0
callq 0x2250
movsd 0x10f4f(%rip), %xmm1    # 0x32810
addsd %xmm1, %xmm0
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x10f41(%rip), %xmm0    # 0x32818
mulsd -0x20(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movaps 0x11208(%rip), %xmm2    # 0x32af0
pand %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0xfcfb(%rip), %xmm0     # 0x315f8
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0xfce6(%rip), %xmm0     # 0x315f8
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
divsd -0x38(%rbp), %xmm1
subsd %xmm1, %xmm0
mulsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
divsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x50(%rbp), %xmm0
movaps 0x1118d(%rip), %xmm1    # 0x32af0
pand %xmm1, %xmm0
ucomisd -0x28(%rbp), %xmm0
ja 0x2190a
movsd -0x8(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd -0x30(%rbp), %xmm1
addsd -0x40(%rbp), %xmm1
mulsd %xmm1, %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/binomlite.c
// Function: pbeta
double pbeta(double x, double a, double b, int lower_tail, int log_p)
{
    if (x <= 0)
    return R_DT_0;
    if (x >= 1)
    return R_DT_1;

    return pbeta_raw(x, a, b, lower_tail, log_p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movl %edi, -0x24(%rbp)
movl %esi, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jb 0x24753
cmpl $0x0, -0x24(%rbp)
je 0x24713
movl -0x28(%rbp), %eax
movsd 0xe095(%rip), %xmm0     # 0x32780
xorps %xmm1, %xmm1
movsd %xmm1, -0x38(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x30(%rbp)
jne 0x24707
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x24744
movl -0x28(%rbp), %eax
xorps %xmm0, %xmm0
movsd 0xced7(%rip), %xmm1     # 0x315f8
movsd %xmm1, -0x50(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x48(%rbp)
jne 0x2473a
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x247fb
movsd -0x10(%rbp), %xmm0
movsd 0xce98(%rip), %xmm1     # 0x315f8
ucomisd %xmm1, %xmm0
jb 0x247dc
cmpl $0x0, -0x24(%rbp)
je 0x2479f
movl -0x28(%rbp), %eax
xorps %xmm0, %xmm0
movsd 0xce7e(%rip), %xmm1     # 0x315f8
movsd %xmm1, -0x60(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x58(%rbp)
jne 0x24793
movsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
jmp 0x247d0
movl -0x28(%rbp), %eax
movsd 0xdfd6(%rip), %xmm0     # 0x32780
xorps %xmm1, %xmm1
movsd %xmm1, -0x78(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x70(%rbp)
jne 0x247c6
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x70(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x247fb
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
callq 0x24270
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/binomlite.c
// Function: pbinom
double pbinom(double x, double n, double p, int lower_tail, int log_p)
{
    n = round(n);

    if (x < 0) return R_DT_0;
    x = floor(x + 1e-7);
    if (n <= x) return R_DT_1;
    return pbeta(p, x + 1, n - x, !lower_tail, log_p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movl %edi, -0x24(%rbp)
movl %esi, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x2080
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x248c2
cmpl $0x0, -0x24(%rbp)
je 0x24882
movl -0x28(%rbp), %eax
movsd 0xdf26(%rip), %xmm0     # 0x32780
xorps %xmm1, %xmm1
movsd %xmm1, -0x38(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x30(%rbp)
jne 0x24876
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x248b3
movl -0x28(%rbp), %eax
xorps %xmm0, %xmm0
movsd 0xcd68(%rip), %xmm1     # 0x315f8
movsd %xmm1, -0x50(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x48(%rbp)
jne 0x248a9
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x24996
movsd 0xe14e(%rip), %xmm0     # 0x32a18
addsd -0x10(%rbp), %xmm0
callq 0x2480
movsd %xmm0, -0x10(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x2495f
cmpl $0x0, -0x24(%rbp)
je 0x24922
movl -0x28(%rbp), %eax
xorps %xmm0, %xmm0
movsd 0xccfb(%rip), %xmm1     # 0x315f8
movsd %xmm1, -0x60(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x58(%rbp)
jne 0x24916
movsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
jmp 0x24953
movl -0x28(%rbp), %eax
movsd 0xde53(%rip), %xmm0     # 0x32780
xorps %xmm1, %xmm1
movsd %xmm1, -0x78(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x70(%rbp)
jne 0x24949
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x70(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x24996
movsd -0x20(%rbp), %xmm0
movsd 0xcc8c(%rip), %xmm1     # 0x315f8
addsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
subsd -0x10(%rbp), %xmm2
cmpl $0x0, -0x24(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edi
movl -0x28(%rbp), %esi
callq 0x246b0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/binomlite.c
// Function: do_search
static double do_search(double y, double *z, double p, double n, double pr, double incr)
{
    if (*z >= p) {
        /* search to the left */
        for (;;) {
            double newz;
            if (y == 0 || (newz = pbinom(y - incr, n, pr, 1, 0)) < p)
                return y;
            y = fmax2(0, y - incr);
            *z = newz;
        }
    } else {
        /* search to the right */
        for (;;) {
            y = fmin2(y + incr, n);
            if (y == n || (*z = pbinom(y, n, pr, 1, 0)) >= p)
                return y;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x38(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd -0x20(%rbp), %xmm0
jb 0x24e66
jmp 0x24dca
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x24ddc
jp 0x24ddc
jmp 0x24e0f
movsd -0x10(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movl $0x1, %edi
xorl %esi, %esi
callq 0x24810
movaps %xmm0, %xmm1
movsd %xmm1, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x24e1e
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x24eed
movsd -0x10(%rbp), %xmm1
subsd -0x38(%rbp), %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x24e3b
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x24e4a
movsd -0x10(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x24dca
jmp 0x24e68
movsd -0x10(%rbp), %xmm1
addsd -0x38(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x24e8e
movsd -0x10(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
jmp 0x24e98
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jne 0x24eb2
jp 0x24eb2
jmp 0x24edc
movsd -0x10(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movl $0x1, %edi
xorl %esi, %esi
callq 0x24810
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
ucomisd -0x20(%rbp), %xmm0
jb 0x24ee8
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x24eed
jmp 0x24e68
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/binomlite.c
// Function: alnrel
static double alnrel(double a)
{
/* -----------------------------------------------------------------------
 *            Evaluation of the function ln(1 + a)
 * ----------------------------------------------------------------------- */

    if (fabs(a) > 0.375)
    return log(1. + a);
    // else : |a| <= 0.375
    static double
    p1 = -1.29418923021993,
    p2 = .405303492862024,
    p3 = -.0178874546012214,
    q1 = -1.62752256355323,
    q2 = .747811014037616,
    q3 = -.0845104217945565;
    double
    t = a / (a + 2.),
    t2 = t * t,
    w = (((p3 * t2 + p2) * t2 + p1) * t2 + 1.) /
    (((q3 * t2 + q2) * t2 + q1) * t2 + 1.);
    return t * 2. * w;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movaps 0xcb17(%rip), %xmm1     # 0x32af0
pand %xmm1, %xmm0
movsd 0xc84b(%rip), %xmm1     # 0x32830
ucomisd %xmm1, %xmm0
jbe 0x26007
movsd 0xb605(%rip), %xmm0     # 0x315f8
addsd -0x10(%rbp), %xmm0
callq 0x2250
movsd %xmm0, -0x8(%rbp)
jmp 0x260df
movsd -0x10(%rbp), %xmm0
movsd 0xb1ac(%rip), %xmm1     # 0x311c0
addsd -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x134ef(%rip), %xmm0    # 0x39528
movsd -0x20(%rbp), %xmm2
movsd 0x134da(%rip), %xmm1    # 0x39520
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm2
movsd 0x134bd(%rip), %xmm1    # 0x39518
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0xb584(%rip), %xmm1     # 0x315f8
addsd %xmm1, %xmm0
movsd 0x134c0(%rip), %xmm1    # 0x39540
movsd -0x20(%rbp), %xmm3
movsd 0x134ab(%rip), %xmm2    # 0x39538
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd -0x20(%rbp), %xmm3
movsd 0x1348e(%rip), %xmm2    # 0x39530
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm1
movsd 0xb53d(%rip), %xmm2     # 0x315f8
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0xb0f0(%rip), %xmm0     # 0x311c0
mulsd -0x18(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/binomlite.c
// Function: esum
static double esum(int mu, double x, int give_log)
{
/* ----------------------------------------------------------------------- */
/*                    EVALUATION OF EXP(MU + X) */
/* ----------------------------------------------------------------------- */

    if(give_log)
    return x + (double) mu;

    // else :
    double w;
    if (x > 0.) { /* L10: */
    if (mu > 0)  return exp((double) mu) * exp(x);
    w = mu + x;
    if (w < 0.) return exp((double) mu) * exp(x);
    }
    else { /* x <= 0 */
    if (mu < 0)  return exp((double) mu) * exp(x);
    w = mu + x;
    if (w > 0.) return exp((double) mu) * exp(x);
    }
    return exp(w);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x26791
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x268aa
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2681e
cmpl $0x0, -0xc(%rbp)
jle 0x267d4
cvtsi2sdl -0xc(%rbp), %xmm0
callq 0x2560
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x2560
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x268aa
cvtsi2sdl -0xc(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x2681c
cvtsi2sdl -0xc(%rbp), %xmm0
callq 0x2560
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x2560
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x268aa
jmp 0x2689b
cmpl $0x0, -0xc(%rbp)
jge 0x26850
cvtsi2sdl -0xc(%rbp), %xmm0
callq 0x2560
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x2560
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x268aa
cvtsi2sdl -0xc(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x26899
cvtsi2sdl -0xc(%rbp), %xmm0
callq 0x2560
movsd %xmm0, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x2560
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x268aa
jmp 0x2689b
movsd -0x28(%rbp), %xmm0
callq 0x2560
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)