LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/bamlite.c
// Function: bam_header_destroy
void bam_header_destroy(bam_header_t *header)
{
    int32_t i;
    if (header == 0) return;
    if (header->target_name) {
        for (i = 0; i < header->n_targets; ++i)
            if (header->target_name[i]) free(header->target_name[i]);
        if (header->target_len) free(header->target_len);
        free(header->target_name);
    }
    if (header->text) free(header->text);
    free(header);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3588
jmp 0x3620
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x35ff
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x35da
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x35cd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2050
jmp 0x35cf
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x359a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x35f2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3617
movq -0x8(%rbp), %rax
movq 0x28(%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/bamlite.c
// Function: bamlite_gzread
int bamlite_gzread(gzFile file, void *ptr, unsigned int len) {
    int ret = gzread(file, ptr, len);
    
    if (ret < 0) {
        int errnum = 0;
        const char *msg = gzerror(file, &errnum);
        fprintf(stderr, "gzread error: %s\n",
                Z_ERRNO == errnum ? strerror(errno) : msg);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x22b0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x392c
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x2370
movq %rax, -0x28(%rbp)
movq 0x3570d(%rip), %rax     # 0x38ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x1c(%rbp), %eax
jne 0x390e
callq 0x2070
movl (%rax), %edi
callq 0x2530
movq %rax, -0x38(%rbp)
jmp 0x3916
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x2d84d(%rip), %rsi     # 0x31172
movb $0x0, %al
callq 0x22c0
movl -0x18(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/bamlite.c
// Function: get_target_end
int get_target_end(bam1_t *b)
{
    int i, s;
    uint8_t c;
    uint32_t n_cigar, *cigar;
    s = b->core.pos;
    cigar = bam1_cigar(b);
    n_cigar = b->core.n_cigar;
    for (i = 0; i < n_cigar; ++i) {
        c = cigar[i] & BAM_CIGAR_MASK;
        if (c == BAM_CMATCH || c == BAM_CDEL)
            s += cigar[i] >> BAM_CIGAR_SHIFT;
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x18, %rcx
andq $0xff, %rcx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x30, %rax
movl %eax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x41d9
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
je 0x41b8
movzbl -0x11(%rbp), %eax
cmpl $0x2, %eax
jne 0x41cc
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x4, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x41ce
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x418d
movl -0x10(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/bamlite.c
// Function: bamlite_gzopen
gzFile bamlite_gzopen(const char *fn, const char *mode) {
    gzFile fp;
    if (strcmp(fn, "-") == 0) {
        fp = gzdopen(fileno((strstr(mode, "r"))? stdin : stdout), mode);
        if (!fp) {
            fprintf(stderr, "Couldn't open %s : %s",
                    (strstr(mode, "r"))? "stdin" : "stdout",
                    strerror(errno));
        }
        return fp;
    }
    if ((fp = gzopen(fn, mode)) == 0) {
        fprintf(stderr, "Couldn't open %s : %s\n", fn,
                errno ? strerror(errno) : "Out of memory");
    }
    return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2d10e(%rip), %rsi     # 0x31309
callq 0x22a0
cmpl $0x0, %eax
jne 0x42c6
movq -0x18(%rbp), %rdi
leaq 0x2e0fd(%rip), %rsi     # 0x32311
callq 0x2550
cmpq $0x0, %rax
je 0x422f
movq 0x34db2(%rip), %rax     # 0x38fd8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x423d
movq 0x34d9a(%rip), %rax     # 0x38fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2310
movl %eax, %edi
movq -0x18(%rbp), %rsi
callq 0x2130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x42bc
movq 0x34d95(%rip), %rax     # 0x38ff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2e09c(%rip), %rsi     # 0x32311
callq 0x2550
movq %rax, %rdx
leaq 0x2cec2(%rip), %rax     # 0x31146
leaq 0x2ceb5(%rip), %rcx     # 0x31140
cmpq $0x0, %rdx
cmovneq %rcx, %rax
movq %rax, -0x30(%rbp)
callq 0x2070
movl (%rax), %edi
callq 0x2530
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0x2ce75(%rip), %rsi     # 0x3112a
movb $0x0, %al
callq 0x22c0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x433e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x23c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4336
movq 0x34d14(%rip), %rax     # 0x38ff8
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x2070
cmpl $0x0, (%rax)
je 0x430f
callq 0x2070
movl (%rax), %edi
callq 0x2530
movq %rax, -0x50(%rbp)
jmp 0x431c
leaq 0x2ce4e(%rip), %rax     # 0x31164
movq %rax, -0x50(%rbp)
jmp 0x431c
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rcx
leaq 0x2ce1e(%rip), %rsi     # 0x3114d
movb $0x0, %al
callq 0x22c0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/bamlite.c
// Function: bamlite_gzclose
int bamlite_gzclose(gzFile file) {
    int ret = gzclose(file);
    if (Z_OK != ret) {
        fprintf(stderr, "gzclose error: %s\n",
                          Z_ERRNO == ret ? strerror(errno) : zError(ret));
    }
    
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2040
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
je 0x43bb
movq 0x34c82(%rip), %rax     # 0x38ff8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0xc(%rbp), %eax
jne 0x4399
callq 0x2070
movl (%rax), %edi
callq 0x2530
movq %rax, -0x20(%rbp)
jmp 0x43a5
movl -0xc(%rbp), %edi
callq 0x2190
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x2cdd0(%rip), %rsi     # 0x31184
movb $0x0, %al
callq 0x22c0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/break.c
// Function: link_mat_init
link_mat_t *link_mat_init(asm_dict_t *dict, uint32_t b)
{
    link_mat_t *link_mat = (link_mat_t *) malloc(sizeof(link_mat_t));
    link_mat->b = b;
    link_mat->n = dict->n;
    link_mat->link = (link_t *) malloc(sizeof(link_t) * link_mat->n);

    uint32_t i;
    for (i = 0; i < link_mat->n; ++i)
        link_init(link_mat->link + i, i, div_ceil(dict->s[i].len, b));
    
    return link_mat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x10, %edi
callq 0x2340
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edi
shlq $0x4, %rdi
callq 0x2340
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x45f6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x2aa0
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
movl %eax, %edx
callq 0x4600
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4597
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/break.c
// Function: link_init
static void link_init(link_t *link, uint32_t s, uint32_t n)
{
    link->s = s;
    link->n = n;
    int64_t *link_c = (int64_t *) malloc(sizeof(int64_t) * n);
    int64_t i;
    for (i = 0; i < n; ++i)
        link_c[i] = i << 32;
    link->link = link_c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x2340
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
cmpq %rcx, %rax
jge 0x466d
movq -0x20(%rbp), %rdx
shlq $0x20, %rdx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x463f
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/break.c
// Function: link_mat_destroy
void link_mat_destroy(link_mat_t *link_mat)
{
    if (!link_mat) return;
    uint32_t i;
    for (i = 0; i < link_mat->n; ++i)
        free(link_mat->link[i].link);
    free(link_mat->link);
    free(link_mat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4695
jmp 0x46e4
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x46ce
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x469c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/break.c
// Function: add_break_point
KDQ_INIT(int64_t)

static void add_break_point(bp_t *bp, uint64_t p)
{
    if (bp->n == bp->m) {
        bp->m <<= 1;
        bp->p = (uint64_t *) realloc(bp->p, bp->m * sizeof(uint64_t));
    }
    bp->p[bp->n] = p;
    ++bp->n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x56d0
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
shll %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x23a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/break.c
// Function: print_link_mat
void print_link_mat(link_mat_t *link_mat, asm_dict_t *dict, FILE *fp)
{
    int i, j, n;
    int64_t *link;
    for (i = 0; i < link_mat->n; ++i) {
        link = link_mat->link[i].link;
        n = link_mat->link[i].n;
        fprintf(fp, "%s:", dict->s[link_mat->link[i].s].name);
        for (j = 0; j < n; ++j)
            fprintf(fp, " %d", (int32_t) link[j]);
        fprintf(fp, "\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x62d2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl (%rcx), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x2afc4(%rip), %rsi     # 0x31235
movb $0x0, %al
callq 0x22c0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x62b2
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %edx
leaq 0x2af99(%rip), %rsi     # 0x31239
movb $0x0, %al
callq 0x22c0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x627f
movq -0x18(%rbp), %rdi
leaq 0x2b2ae(%rip), %rsi     # 0x3156b
movb $0x0, %al
callq 0x22c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x61fb
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/break.c
// Function: print_break_point
void print_break_point(bp_t *bp, asm_dict_t *dict, FILE *fp)
{
    int i;
    fprintf(fp, "%s[%u]:", dict->s[bp->s].name, bp->n);
    for (i = 0; i < bp->n; ++i)
        fprintf(fp, " %lu", bp->p[i]);
    fprintf(fp, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
leaq 0x2af1f(%rip), %rsi     # 0x3123d
movb $0x0, %al
callq 0x22c0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x6364
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x2aef3(%rip), %rsi     # 0x31245
movb $0x0, %al
callq 0x22c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x632c
movq -0x18(%rbp), %rdi
leaq 0x2b1fc(%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/graph.c
// Function: graph_destroy
void graph_destroy(graph_t *g)
{
    if (!g) return;
    if (g == 0)
        return;
    if (g->arc)
        free(g->arc);
    if (g->idx)
        free(g->idx);
    free(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x80c5
jmp 0x8107
cmpq $0x0, -0x8(%rbp)
jne 0x80ce
jmp 0x8107
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x80e6
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x80fe
movq -0x8(%rbp), %rax
movq 0x28(%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/graph.c
// Function: graph_arc_is_sorted
int graph_arc_is_sorted(const graph_t *g)
{
    uint64_t e;
    for (e = 1; e < g->n_arc; ++e)
        if (g->arc[e-1].v > g->arc[e].v)
            break;
    return (e == g->n_arc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x8580
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq -0x10(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jbe 0x8570
jmp 0x8580
jmp 0x8572
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8530
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/graph.c
// Function: graph_arc_index_core
uint64_t *graph_arc_index_core(size_t max_seq, size_t n, const graph_arc_t *a)
{
    size_t i, last;
    uint64_t *idx;
    idx = (uint64_t *) calloc(max_seq * 2, 8);
    for (i = 1, last = 0; i <= n; ++i)
        if (i == n || graph_arc_head(a[i - 1]) != graph_arc_head(a[i]))
            idx[graph_arc_head(a[i - 1])] = (uint64_t) last<<32 | (i - last), last = i;
    return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
shlq %rdi
movl $0x8, %esi
callq 0x2290
movq %rax, -0x30(%rbp)
movq $0x1, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x86a0
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x8655
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
je 0x868d
movq -0x28(%rbp), %rdx
shlq $0x20, %rdx
movq -0x20(%rbp), %rax
subq -0x28(%rbp), %rax
orq %rax, %rdx
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rsi
subq $0x1, %rsi
shlq $0x5, %rsi
addq %rsi, %rcx
movl (%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x868f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8619
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/graph.c
// Function: read_graph_from_gfa
graph_t *read_graph_from_gfa(char *gfa)
{
    iostream_t *fp;
    char *line;
    char c0[1024], c1[1024], s0[4], s1[4], wts[1024];
    double wt;

    graph_t *g;
    g = graph_init();
    g->sdict = make_asm_dict_from_sdict(make_sdict_from_gfa(gfa, 0));
    
    fp = iostream_open(gfa);
    if (fp == NULL) {
        fprintf(stderr, "[E::%s] cannot open file %s for reading\n", __func__, gfa);
        exit(EXIT_FAILURE);
    }

    while ((line = iostream_getline(fp)) != NULL) {
        if (line[0] == 'L') {
            sscanf(line, "%*s %s %s %s %s %*s %s", c0, s0, c1, s1, wts);
            wt = strtof(wts + 5, NULL);
            graph_add_arc(g, (asm_sd_get(g->sdict, c0)<<1) | (s0[0]=='-'), (asm_sd_get(g->sdict, c1)<<1) | (s1[0]=='-'), -1, 0, wt);
        }
    }
    iostream_close(fp);

    graph_arc_sort(g);
    graph_arc_index(g);

    return g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc60, %rsp            # imm = 0xC60
movq %rdi, -0x8(%rbp)
callq 0x8080
movq %rax, -0xc40(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x177a0
movq %rax, %rdi
callq 0x17d00
movq %rax, %rcx
movq -0xc40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x2d80
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x878d
movq 0x30891(%rip), %rax     # 0x38ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rcx
leaq 0x28a5b(%rip), %rsi     # 0x311d0
leaq 0x28b98(%rip), %rdx     # 0x31314
movb $0x0, %al
callq 0x22c0
movl $0x1, %edi
callq 0x24c0
jmp 0x878f
movq -0x10(%rbp), %rdi
callq 0x3000
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x88a9
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4c, %eax
jne 0x88a4
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rdx
leaq -0x824(%rbp), %rcx
leaq -0x820(%rbp), %r8
leaq -0x828(%rbp), %r9
leaq -0xc30(%rbp), %rax
leaq 0x28b44(%rip), %rsi     # 0x31328
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2360
leaq -0xc30(%rbp), %rdi
addq $0x5, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21e0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0xc38(%rbp)
movq -0xc40(%rbp), %rax
movq %rax, -0xc50(%rbp)
movq -0xc40(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x420(%rbp), %rsi
callq 0x17ba0
shll %eax
movsbl -0x824(%rbp), %ecx
cmpl $0x2d, %ecx
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
movl %eax, -0xc44(%rbp)
movq -0xc40(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x820(%rbp), %rsi
callq 0x17ba0
movq -0xc50(%rbp), %rdi
movl -0xc44(%rbp), %esi
movl %eax, %edx
shll %edx
movsbl -0x828(%rbp), %eax
cmpl $0x2d, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
orl %eax, %edx
movsd -0xc38(%rbp), %xmm0
movq $-0x1, %rcx
xorl %r8d, %r8d
callq 0x8330
jmp 0x878f
movq -0x10(%rbp), %rdi
callq 0x2f20
movq -0xc40(%rbp), %rdi
callq 0x85a0
movq -0xc40(%rbp), %rdi
callq 0x86b0
movq -0xc40(%rbp), %rax
addq $0xc60, %rsp            # imm = 0xC60
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/graph.c
// Function: graph_clean
void graph_clean(graph_t *g, int shear)
{
    uint64_t n_arc, n;
    graph_arc_t *arc, *a;
    arc = g->arc;
    n_arc = g->n_arc;
    n = 0;
    for(a = arc; a < arc + n_arc; ++a) {
        if (!a->del) {
            memmove(arc + n, a, sizeof(graph_arc_t));
            ++n;
        }
    }
    g->n_arc = n;
#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] graph cleaned: #arcs %lu -> %ld\n", __func__, n_arc, n);
#endif
    if (shear) {
        uint64_t m = 16;
#ifdef DEBUG_GRAPH_PRUNE
        uint64_t m_arc = g->m_arc;
#endif
        while (m < n) 
            m <<= 1;
        g->arc = (graph_arc_t *) realloc(g->arc, m * sizeof(graph_arc_t));
        g->m_arc = m;
#ifdef DEBUG_GRAPH_PRUNE
        fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] memory sheared: #arcs %lu -> %ld\n", __func__, m_arc, m);
#endif
    }

    graph_arc_sort(g);
    graph_arc_index(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x8982
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x3e, %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x8972
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x30(%rbp), %rcx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8974
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0x8917
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpl $0x0, -0xc(%rbp)
je 0x89df
movq $0x10, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x89b3
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x899c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x38(%rbp), %rsi
shlq $0x5, %rsi
callq 0x23a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x85a0
movq -0x8(%rbp), %rdi
callq 0x86b0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/graph.c
// Function: graph_print_gv
void graph_print_gv(const graph_t *g, FILE *fp)
{
    uint64_t k;
    char *seq;

    fprintf(fp, "digraph {\n");
    fprintf(fp, "\t{\n");
    for (k = 0; k < g->sdict->n; ++k) {
        seq = g->sdict->s[k].name;
        fprintf(fp, "\t\t\"%s%c\" [style=filled fillcolor = salmon];\n", seq, '-');
        fprintf(fp, "\t\t\"%s%c\";\n", seq, '+');
    }
    fprintf(fp, "\t}\n");
    for (k = 0; k < g->n_arc; ++k) {
        const graph_arc_t *a = &g->arc[k];
        if (a->del) 
            continue;
        fprintf(fp, "\t\"%s%c\" -> \"%s%c\"[label=\"%.3f\"];\n", g->sdict->s[a->v>>1].name, "+-"[a->v&1], g->sdict->s[a->w>>1].name, "+-"[a->w&1], a->wt);
    }
    fprintf(fp, "}\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x28924(%rip), %rsi     # 0x3133f
movb $0x0, %al
callq 0x22c0
movq -0x10(%rbp), %rdi
leaq 0x2891d(%rip), %rsi     # 0x3134a
movb $0x0, %al
callq 0x22c0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x8aae
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
imulq $0x58, -0x18(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x288d5(%rip), %rsi     # 0x3134e
movl $0x2d, %ecx
movb $0x0, %al
callq 0x22c0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x288e7(%rip), %rsi     # 0x3137b
movl $0x2b, %ecx
movb $0x0, %al
callq 0x22c0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x8a3c
movq -0x10(%rbp), %rdi
leaq 0x288cd(%rip), %rsi     # 0x31386
movb $0x0, %al
callq 0x22c0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x8bab
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x3e, %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x8b0c
jmp 0x8b9a
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x287c4(%rip), %rax     # 0x31308
movsbl (%rax,%rcx), %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rsi
movl 0x4(%rsi), %esi
shrl %esi
movl %esi, %esi
imulq $0x58, %rsi, %rsi
addq %rsi, %rax
movq (%rax), %r8
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x2878a(%rip), %rax     # 0x31308
movsbl (%rax,%rsi), %r9d
movq -0x28(%rbp), %rax
movsd 0x10(%rax), %xmm0
leaq 0x287f7(%rip), %rsi     # 0x3138a
movb $0x1, %al
callq 0x22c0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x8ac8
movq -0x10(%rbp), %rdi
leaq 0x287d1(%rip), %rsi     # 0x31387
movb $0x0, %al
callq 0x22c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/graph.c
// Function: graph_remove_multi_arcs
int graph_remove_multi_arcs(graph_t *g)
{
    uint32_t nv, na, v, n_del;
    graph_arc_t *av, *a, *b;

    nv = graph_n_vtx(g);
    nv <<= 1;
    n_del = 0;
    for (v = 0; v < nv; ++v) {
        na = graph_arc_n(g, v);
        if (na > 0) {
            av = graph_arc_a(g, v);
            for (a = av; a < av + na; ++a) {
                if (a->del) 
                    continue;
                for(b = a + 1; b < av + na; ++b) {
                    if (b->del) 
                        continue;
                    if (a->w == b->w) {
                        b->del = 1;
                        ++n_del;
                    }
                }
            }
        }
    }
#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] number multi-arcs deleted: %d\n", __func__, n_del);
#endif
    graph_clean(g, 1);
    return n_del;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x8d37
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jbe 0x8d27
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%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, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x8d25
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x3e, %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x8c8b
jmp 0x8d14
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x8d12
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x3e, %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x8cc6
jmp 0x8d04
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x8d02
movq -0x30(%rbp), %rax
movabsq $-0x4000000000000001, %rcx # imm = 0xBFFFFFFFFFFFFFFF
andq 0x18(%rax), %rcx
movabsq $0x4000000000000000, %rdx # imm = 0x4000000000000000
orq %rdx, %rcx
movq %rcx, 0x18(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8d04
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0x8c97
jmp 0x8d14
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
jmp 0x8c55
jmp 0x8d27
jmp 0x8d29
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8bff
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x88e0
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/./graph.h
// Function: graph_arc
static inline graph_arc_t *graph_arc(graph_t *g, uint32_t v, uint32_t w)
{
    uint32_t i, nv = graph_arc_n(g, v);
    graph_arc_t *av = graph_arc_a(g, v);
    for (i = 0; i < nv; ++i)
        if (av[i].w == w) 
            return av + i;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x20(%rbp)
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, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x8f9c
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x8f8f
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x8fa4
jmp 0x8f91
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8f5d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/./graph.h
// Function: graph_arc_del_existed
static inline int graph_arc_del_existed(graph_t *g, graph_arc_t *a)
{
    if (a->del) 
        return 0;
    a->del = 1;
    graph_arc_del(g, a->w^1, a->v^1, 1);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x3e, %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x980f
movl $0x0, -0x4(%rbp)
jmp 0x985a
movq -0x18(%rbp), %rax
movabsq $-0x4000000000000001, %rcx # imm = 0xBFFFFFFFFFFFFFFF
andq 0x18(%rax), %rcx
movabsq $0x4000000000000000, %rdx # imm = 0x4000000000000000
orq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
xorl $0x1, %esi
movq -0x18(%rbp), %rax
movl (%rax), %edx
xorl $0x1, %edx
movl $0x1, %ecx
callq 0xa250
movl $0x1, -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/graph.c
// Function: trim_graph_tips
int trim_graph_tips(graph_t *g)
{
    uint32_t v, nv, n_del;
    graph_arc_t *av;
    nv = graph_n_vtx(g);
    nv <<= 1;
    n_del = 0;

    for (v = 0; v < nv; ++v) {
        if (graph_arc_n(g, v^1) != 1 || graph_arc_n(g, v) > 0)
            continue;
        av = graph_arc_a(g, v^1);
        if (graph_arc_n(g, av->w^1) > 1 && !is_mwt(g, av->w^1, v))
            n_del += graph_arc_del_existed(g, av);
    }

    graph_clean(g, 1);

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

    return n_del;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x9960
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
xorl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
cmpl $0x1, %eax
jne 0x98d8
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
cmpl $0x0, %eax
jbe 0x98da
jmp 0x9952
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0xc(%rbp), %edx
xorl $0x1, %edx
movl %edx, %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %ecx
xorl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
cmpl $0x1, %eax
jbe 0x9950
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
xorl $0x1, %esi
movl -0xc(%rbp), %edx
callq 0x9980
cmpl $0x0, %eax
jne 0x9950
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x97e0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x9952
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x989f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x88e0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/graph.c
// Function: is_mwt
static int is_mwt(graph_t *g, uint32_t v, uint32_t w)
{
    int b;
    uint32_t na;
    double mwt;
    graph_arc_t *a, *av;

    na = graph_arc_n(g, v);
    if (na == 0)
        return 0;
    av = graph_arc_a(g, v);
    b = 0;
    mwt = 0;
    for (a = av; a < av + na; ++a) {
        if (a->wt > mwt) {
            mwt = a->wt;
            if (a->w == w)
                b = 1;
        }
    }
    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x99b2
movl $0x0, -0x4(%rbp)
jmp 0x9a4f
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)
movl $0x0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movl -0x20(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x9a49
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x9a39
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x9a37
movl $0x1, -0x1c(%rbp)
jmp 0x9a39
jmp 0x9a3b
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0x99ef
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/graph.c
// Function: trim_graph_blunts
int trim_graph_blunts(graph_t *g)
{
    uint32_t v, nv, na, n_del;
    uint8_t del;
    graph_arc_t *a, *av;
    nv = graph_n_vtx(g);
    nv <<= 1;
    n_del = 0;

    for (v = 0; v < nv; ++v) {
        if (graph_arc_n(g, v^1) > 0)
            continue;
        na = graph_arc_n(g, v);
        if (na > 1) {
            av = graph_arc_a(g, v);
            del = 1;
            for (a = av; a < av + na; ++a) {
                if (graph_arc_n(g, a->w) < 1) {
                    del = 0;
                    break;
                }
            }
            if (del)
                for (a = av; a < av + na; ++a)
                    n_del += graph_arc_del_existed(g, a);
        }
    }

    graph_clean(g, 1);

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

    return n_del;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x9ba6
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
xorl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
cmpl $0x0, %eax
jbe 0x9ab9
jmp 0x9b98
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jbe 0x9b96
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0xc(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movb $0x1, -0x19(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x9b4c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq (%rax,%rcx,8), %rax
cmpl $0x1, %eax
jae 0x9b3c
movb $0x0, -0x19(%rbp)
jmp 0x9b4c
jmp 0x9b3e
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
jmp 0x9b07
cmpb $0x0, -0x19(%rbp)
je 0x9b94
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x9b92
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x97e0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
jmp 0x9b5a
jmp 0x9b94
jmp 0x9b96
jmp 0x9b98
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9a8f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x88e0
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/graph.c
// Function: trim_graph_self_loops
int trim_graph_self_loops(graph_t *g)
{
    uint32_t n_del;
    graph_arc_t *a, *aw;
    n_del = 0;
    for (a = g->arc; a < g->arc + g->n_arc; ++a) {
        // might have bugs here
        if (graph_arc_n(g, a->v) > 1) 
            continue;
        aw = graph_arc(g, a->w, a->v);
        if (aw) 
            n_del += graph_arc_del_existed(g, aw);
    }

    graph_clean(g, 1);

#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] #del self loops: %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 0x9e1c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
cmpl $0x1, %eax
jbe 0x9dd8
jmp 0x9e0e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x18(%rbp), %rax
movl (%rax), %edx
callq 0x8f10
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9e0c
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x97e0
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x9e0e
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0x9d9f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x88e0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/graph.c
// Function: trim_graph_transitive_edges
int trim_graph_transitive_edges(graph_t *g)
{
    // TODO a more sophisticated implemetation for transitive edges > 2
    uint32_t v, nv, na, n_del;
    graph_arc_t *a1, *a2, *av;
    nv = graph_n_vtx(g);
    nv <<= 1;
    n_del = 0;

    for (v = 0; v < nv; ++v) {
        na = graph_arc_n(g, v);
        if (na < 2) 
            continue;
        av = graph_arc_a(g, v);
        for (a1 = av; a1 < av + na; ++a1) {
            for (a2 = av; a2 < av + na; ++a2) {
                if (a1 == a2) 
                    continue;
                if (graph_arc(g, a1->w, a2->w))
                    n_del += graph_arc_del_existed(g, a2);
            }
        }
    }

    graph_clean(g, 1);

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

    return n_del;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x9f6b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jae 0x9e98
jmp 0x9f5d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0xc(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x9f5b
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x9f48
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x9f08
jmp 0x9f3a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x8f10
cmpq $0x0, %rax
je 0x9f38
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x97e0
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x9f3a
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
jmp 0x9ee5
jmp 0x9f4a
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0x9ec6
jmp 0x9f5d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9e6f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x88e0
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/graph.c
// Function: trim_graph_pop_undirected
int trim_graph_pop_undirected(graph_t *g)
{
    uint32_t v, w, 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)
            continue;
        v = a->v;
        w = a->w;
        if (graph_arc(g, v^1, w) &&
                graph_arc_n(g, v^1) > 1 &&
                graph_arc_n(g, w) > 0) {
            ++n_del;
            graph_arc_del(g, w^1, v, 1);
            graph_arc_del(g, v^1, w, 1);
        }
    }

    graph_clean(g, 1);

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

    return n_del;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%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 0xa231
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
cmpl $0x1, %eax
je 0xa18f
jmp 0xa220
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x8f10
cmpq $0x0, %rax
je 0xa21e
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
xorl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
cmpl $0x1, %eax
jbe 0xa21e
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rax
cmpl $0x0, %eax
jbe 0xa21e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
xorl $0x1, %esi
movl -0xc(%rbp), %edx
movl $0x1, %ecx
callq 0xa250
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
xorl $0x1, %esi
movl -0x10(%rbp), %edx
movl $0x1, %ecx
callq 0xa250
jmp 0xa220
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0xa14f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x88e0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/./graph.h
// Function: graph_arc_del
static inline void graph_arc_del(graph_t *g, uint32_t v, uint32_t w, int del)
{
    uint32_t i, nv = graph_arc_n(g, v);
    graph_arc_t *av = graph_arc_a(g, v);
    for (i = 0; i < nv; ++i)
        if (av[i].w == w) 
            av[i].del = !!del;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0xc(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0xa30c
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0xa2ff
cmpl $0x0, -0x14(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rdx
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rcx
andq $0x1, %rdx
shlq $0x3e, %rdx
movabsq $-0x4000000000000001, %rsi # imm = 0xBFFFFFFFFFFFFFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, 0x18(%rax)
jmp 0xa301
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa2a0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/graph.c
// Function: trim_graph_weak_edges
int trim_graph_weak_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 (exist_strong_edge(g, a->v, a->wt) && exist_strong_edge(g, a->w^1, a->wt))
            n_del += graph_arc_del_existed(g, a);

    graph_clean(g, 1);

#ifdef DEBUG_GRAPH_PRUNE
    fprintf(stderr, "[DEBUG_GRAPH_PRUNE::%s] #del weak 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 0xa3b3
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
callq 0xa3d0
cmpl $0x0, %eax
je 0xa3a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
xorl $0x1, %esi
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
callq 0xa3d0
cmpl $0x0, %eax
je 0xa3a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x97e0
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xa3a2
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0xa32f
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x88e0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)