LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: seg_put
void seg_put(asm_dict_t *d, uint32_t s, uint32_t k, uint64_t a, uint64_t b,
        uint32_t c, uint32_t x, uint32_t y, uint32_t t, uint32_t r)
{
    if (d->u == d->v) {
        d->v = d->v? d->v<<1 : 16;
        d->seg = (sd_seg_t *) realloc(d->seg, d->v * sizeof(sd_seg_t));
    }
    sd_seg_t seg = {s, k, a, b, c, x, y, t, r};
    d->seg[d->u++] = seg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jne 0x6869
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x6832
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
shll %eax
movl %eax, -0x5c(%rbp)
jmp 0x683c
movl $0x10, %eax
movl %eax, -0x5c(%rbp)
jmp 0x683c
movl -0x5c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
imulq $0x30, %rax, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x40(%rbp)
movl 0x10(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl 0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
movl 0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
movl 0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x18(%rcx)
movl %eax, %eax
imulq $0x30, %rax, %rax
addq %rax, %rdi
leaq -0x58(%rbp), %rsi
movl $0x30, %edx
callq 0x2220
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: make_asm_dict_from_sdict
asm_dict_t *make_asm_dict_from_sdict(sdict_t *sdict)
{
    uint32_t i;
    asm_dict_t *d;
    d = asm_init(sdict);
    d->index = (uint64_t *) calloc(sdict->n, sizeof(uint64_t));
    uint64_t *a = d->a;
    for (i = 0; i < sdict->n; ++i) {
        asm_put(d, sdict->s[i].name, sdict->s[i].len, 0, 1, i, 0, 0, 0, 0, 0, 0, 0);
        seg_put(d, i, 0, 0, 0, i<<1, 0, sdict->s[i].len, DEFAULT_AGP_SEQ_COMPONENT_TYPE, AGP_OT_PLUS);
        a[i] = (uint64_t) i << 32 | 1;
        d->index[i] = (uint64_t) sdict->s[i].len << 32 | i;
    }
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5160
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x21d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x6a61
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, %edx
movl -0xc(%rbp), %r9d
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %r8d
xorl %eax, %eax
movl $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
callq 0x64f0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0xc(%rbp), %r9d
shll %r9d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %r10d
movl 0xa83c(%rip), %eax      # 0x11220
xorl %edx, %edx
xorl %ecx, %ecx
movl %ecx, %r8d
movq %r8, %rcx
movl $0x0, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movl $0x2b5d0, 0x18(%rsp)    # imm = 0x2B5D0
callq 0x67e0
movl -0xc(%rbp), %eax
movl %eax, %edx
shlq $0x20, %rdx
orq $0x1, %rdx
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, %edx
shlq $0x20, %rdx
movl -0xc(%rbp), %eax
orq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl -0xc(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6929
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/./agp-spec.h
// Function: agp_component_type_key
static inline const uint32_t agp_component_type_key(const char *val)
{
    uint32_t key = AGPSpec_hash(val);
    int c = 0;
    switch ((AGP_CT_t) key) {
        case AGP_CT_A: c = check_collision(val, "A"); break;
        case AGP_CT_D: c = check_collision(val, "D"); break;
        case AGP_CT_F: c = check_collision(val, "F"); break;
        case AGP_CT_G: c = check_collision(val, "G"); break;
        case AGP_CT_O: c = check_collision(val, "O"); break;
        case AGP_CT_P: c = check_collision(val, "P"); break;
        case AGP_CT_W: c = check_collision(val, "W"); break;
        case AGP_CT_N: c = check_collision(val, "N"); break;
        case AGP_CT_U: c = check_collision(val, "U"); break;
        default:       AGPSpec_die("[E::%s] AGP component type VAL error: %s\n", __func__, val);
    }
    if (c) AGPSpec_die("[E::%s] AGP component type VAL error (hash collision): %s\n", __func__, val);
    return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb540
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0xfffd49fa, %eax       # imm = 0xFFFD49FA
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x16, %eax
ja 0x7e23
movq -0x18(%rbp), %rax
leaq 0x550b(%rip), %rcx      # 0xd25c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0x5b2e(%rip), %rsi      # 0xd893
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x7e3c
movq -0x8(%rbp), %rdi
leaq 0x5b18(%rip), %rsi      # 0xd895
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x7e3c
movq -0x8(%rbp), %rdi
leaq 0x5b02(%rip), %rsi      # 0xd897
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x7e3c
movq -0x8(%rbp), %rdi
leaq 0x5aec(%rip), %rsi      # 0xd899
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x7e3c
movq -0x8(%rbp), %rdi
leaq 0x5ad6(%rip), %rsi      # 0xd89b
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x7e3c
movq -0x8(%rbp), %rdi
leaq 0x5ac3(%rip), %rsi      # 0xd89d
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x7e3c
movq -0x8(%rbp), %rdi
leaq 0x5ab0(%rip), %rsi      # 0xd89f
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x7e3c
movq -0x8(%rbp), %rdi
leaq 0x5841(%rip), %rsi      # 0xd645
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x7e3c
movq -0x8(%rbp), %rdi
leaq 0x582e(%rip), %rsi      # 0xd647
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x7e3c
movq -0x8(%rbp), %rdx
leaq 0x5a73(%rip), %rdi      # 0xd8a1
leaq 0x5a96(%rip), %rsi      # 0xd8cb
movb $0x0, %al
callq 0xb630
cmpl $0x0, -0x10(%rbp)
je 0x7e5b
movq -0x8(%rbp), %rdx
leaq 0x5a95(%rip), %rdi      # 0xd8e2
leaq 0x5a77(%rip), %rsi      # 0xd8cb
movb $0x0, %al
callq 0xb630
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/./agp-spec.h
// Function: agp_linkage_key
static inline const uint32_t agp_linkage_key(const char *val)
{
    uint32_t key = AGPSpec_hash(val);
    int c = 0;
    switch ((AGP_LG_t) key) {
        case AGP_LG_YES: c = check_collision(val, "yes"); break;
        case AGP_LG_NO:  c = check_collision(val, "no"); break;
        default:         AGPSpec_die("[E::%s] AGP linkage VAL error: %s\n", __func__, val);
    }
    if (c) AGPSpec_die("[E::%s] AGP linkage VAL error (hash collision): %s\n", __func__, val);
    return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb540
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x5978e2, %eax         # imm = 0x5978E2
je 0x804f
jmp 0x802e
movl -0x14(%rbp), %eax
subl $0xb88c316, %eax        # imm = 0xB88C316
jne 0x8064
jmp 0x803a
movq -0x8(%rbp), %rdi
leaq 0x598e(%rip), %rsi      # 0xd9d3
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x807d
movq -0x8(%rbp), %rdi
leaq 0x597d(%rip), %rsi      # 0xd9d7
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x807d
movq -0x8(%rbp), %rdx
leaq 0x596b(%rip), %rdi      # 0xd9da
leaq 0x5987(%rip), %rsi      # 0xd9fd
movb $0x0, %al
callq 0xb630
cmpl $0x0, -0x10(%rbp)
je 0x809c
movq -0x8(%rbp), %rdx
leaq 0x597f(%rip), %rdi      # 0xda0d
leaq 0x5968(%rip), %rsi      # 0xd9fd
movb $0x0, %al
callq 0xb630
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/./agp-spec.h
// Function: agp_orientation_key
static inline const uint32_t agp_orientation_key(const char *val)
{
    uint32_t key = AGPSpec_hash(val);
    int c = 0;
    switch ((AGP_OT_t) key) {
        case AGP_OT_PLUS:    c = check_collision(val, "+"); break;
        case AGP_OT_MINUS:   c = check_collision(val, "-"); break;
        case AGP_OT_UNKNOWN: c = check_collision(val, "?"); break;
        case AGP_OT_ZERO:    c = check_collision(val, "0"); break;
        case AGP_OT_ZERO_S:  c = check_collision(val, "zero"); break;
        case AGP_OT_NA:      c = check_collision(val, "na"); break;
        default:             AGPSpec_die("[E::%s] AGP orientation VAL error: %s\n", __func__, val);
    }
    if (c) AGPSpec_die("[E::%s] AGP orientation VAL error (hash collision): %s\n", __func__, val);
    return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb540
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x2b5d0, %eax          # imm = 0x2B5D0
je 0x834d
jmp 0x830e
movl -0x14(%rbp), %eax
subl $0x2b5d2, %eax          # imm = 0x2B5D2
je 0x8365
jmp 0x831a
movl -0x14(%rbp), %eax
subl $0x2b5d5, %eax          # imm = 0x2B5D5
je 0x838f
jmp 0x8326
movl -0x14(%rbp), %eax
subl $0x2b5e4, %eax          # imm = 0x2B5E4
je 0x837a
jmp 0x8332
movl -0x14(%rbp), %eax
subl $0x5978d4, %eax         # imm = 0x5978D4
je 0x83b9
jmp 0x833e
movl -0x14(%rbp), %eax
subl $0x7ca1b285, %eax       # imm = 0x7CA1B285
je 0x83a4
jmp 0x83ce
movq -0x8(%rbp), %rdi
leaq 0x539d(%rip), %rsi      # 0xd6f5
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x83e7
movq -0x8(%rbp), %rdi
leaq 0x4e2c(%rip), %rsi      # 0xd19c
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x83e7
movq -0x8(%rbp), %rdi
leaq 0x5372(%rip), %rsi      # 0xd6f7
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x83e7
movq -0x8(%rbp), %rdi
leaq 0x4e1b(%rip), %rsi      # 0xd1b5
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x83e7
movq -0x8(%rbp), %rdi
leaq 0x578f(%rip), %rsi      # 0xdb3e
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x83e7
movq -0x8(%rbp), %rdi
leaq 0x5335(%rip), %rsi      # 0xd6f9
callq 0xb590
movl %eax, -0x10(%rbp)
jmp 0x83e7
movq -0x8(%rbp), %rdx
leaq 0x576a(%rip), %rdi      # 0xdb43
leaq 0x578a(%rip), %rsi      # 0xdb6a
movb $0x0, %al
callq 0xb630
cmpl $0x0, -0x10(%rbp)
je 0x8406
movq -0x8(%rbp), %rdx
leaq 0x5786(%rip), %rdi      # 0xdb7e
leaq 0x576b(%rip), %rsi      # 0xdb6a
movb $0x0, %al
callq 0xb630
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: add_unplaced_short_seqs
void add_unplaced_short_seqs(asm_dict_t *d, uint32_t min_len)
{
    uint32_t i;
    sdict_t *sdict;
    
    sdict = d->sdict;
    for (i = 0; i < sdict->n; ++i) {
        if (sdict->s[i].len >= min_len)
            continue;
        seg_put(d, d->n, 0, 0, 0, i<<1, 0, sdict->s[i].len, DEFAULT_AGP_SEQ_COMPONENT_TYPE, AGP_OT_PLUS);
        asm_put(d, sdict->s[i].name, sdict->s[i].len, 0, 1, d->u - 1, 0, 0, 0, 0, 0, 0, 0);
    }
    asm_index(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x854c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
cmpl -0xc(%rbp), %eax
jb 0x8460
jmp 0x853e
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
movl -0x10(%rbp), %r9d
shll %r9d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %r10d
movl 0x8d93(%rip), %eax      # 0x11220
xorl %edx, %edx
xorl %ecx, %ecx
movl %ecx, %r8d
movq %r8, %rcx
movl $0x0, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movl $0x2b5d0, 0x18(%rsp)    # imm = 0x2B5D0
callq 0x67e0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, %edx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %r9d
subl $0x1, %r9d
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %r8d
xorl %eax, %eax
movl $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
callq 0x64f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8432
movq -0x8(%rbp), %rdi
callq 0x6f10
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: cmp_uint64_d
int cmp_uint64_d (const void *a, const void *b) {
    // decreasing order
    uint64_t x, y;
    x = *(uint64_t *) a;
    y = *(uint64_t *) b;
    return (x < y) - (x > y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
cmpq -0x20(%rbp), %rcx
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: sd_stats
void sd_stats(sdict_t *d, uint64_t *n_stats, uint32_t *l_stats)
{
    // n_stats and l_stats are of at least size 10
    uint32_t i, n;
    uint64_t *s;

    n = d->n;
    s = (uint64_t *) calloc(n, sizeof(uint64_t));
    for (i = 0; i < n; ++i)
        s[i] = d->s[i].len;
    nl_stats(s, n, n_stats, l_stats);
    
    free(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x21d0
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x89bc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, %edx
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8987
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x89e0
movq -0x28(%rbp), %rdi
callq 0x2050
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: nl_stats
static void nl_stats(uint64_t *s, uint32_t n, uint64_t *n_stats, uint32_t *l_stats)
{
    uint32_t i, j;
    double b, a, bs;
    
    bs = 0;
    for (i = 0; i < n; ++i)
        bs += s[i];

    qsort(s, n, sizeof(uint64_t), cmp_uint64_d);

    b = 0;
    j = 0;
    a = .1 * (++j) * bs;
    for (i = 0; i < n; ++i) {
        b += s[i];
        while (b >= a) {
            l_stats[j - 1] = i + 1;
            n_stats[j - 1] = s[i];
            a = .1 * (++j) * bs;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x8a51
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %xmm0
movaps 0x490f(%rip), %xmm1     # 0xd330
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x4913(%rip), %xmm1     # 0xd340
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8a06
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq -0x161(%rip), %rcx      # 0x8900
movl $0x8, %edx
callq 0x20b0
movq $0x0, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
incl %eax
movl %eax, -0x28(%rbp)
cvtsi2sd %rax, %xmm1
movsd 0x4889(%rip), %xmm0     # 0xd318
mulsd %xmm1, %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x8b52
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %xmm0
movaps 0x486d(%rip), %xmm1     # 0xd330
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x4871(%rip), %xmm1     # 0xd340
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
ucomisd -0x38(%rbp), %xmm0
jb 0x8b42
movl -0x24(%rbp), %edx
incl %edx
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
decl %ecx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
decl %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
incl %eax
movl %eax, -0x28(%rbp)
cvtsi2sd %rax, %xmm1
movsd 0x47e6(%rip), %xmm0     # 0xd318
mulsd %xmm1, %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x8ae8
jmp 0x8b44
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8aa4
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: write_sorted_agp
void write_sorted_agp(asm_dict_t *dict, FILE *fo)
{
    int i, j;
    uint32_t s;
    char s_name[32];
    c_pair_t *c_pairs;

    c_pairs = (c_pair_t *) malloc(dict->n * sizeof(c_pair_t));
    for(i = 0; i < dict->n; ++i) {
        c_pair_t pair = {dict->s[i].len, i};
        c_pairs[i] = pair;
    }
    radix_sort_pair(c_pairs, c_pairs + dict->n);
    s = 0;
    for (i = dict->n - 1; i >= 0; --i) {
        j = c_pairs[i].y;
        sprintf(s_name, "scaffold_%u", ++s);
        write_segs_to_agp(dict->seg + dict->s[j].s, dict->s[j].n, &dict->s[j], dict->sdict, s_name, fo);
    }
    free(c_pairs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
shlq $0x4, %rdi
callq 0x2260
movq %rax, -0x48(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x9b33
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9adc
movq -0x48(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x8(%rbp), %rax
movl (%rax), %eax
shlq $0x4, %rax
addq %rax, %rsi
callq 0x6eb0
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x9c0c
movq -0x48(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl %eax, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
leaq 0x3c49(%rip), %rsi      # 0xd7dd
movb $0x0, %al
callq 0x2360
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movl 0x1c(%rax), %eax
imulq $0x30, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movl 0x18(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movslq -0x18(%rbp), %rax
imulq $0x58, %rax, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
leaq -0x40(%rbp), %r8
movq -0x10(%rbp), %r9
callq 0x9380
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9b60
movq -0x48(%rbp), %rdi
callq 0x2050
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: write_sdict_to_agp
void write_sdict_to_agp(sdict_t *sdict, FILE *fo)
{
    int i;
    for (i = 0; i < sdict->n; ++i)
        fprintf(fo, "scaffold_%u\t1\t%u\t1\t%s\t%s\t1\t%u\t+\n", i + 1, sdict->s[i].len, 
                agp_component_type_val(DEFAULT_AGP_SEQ_COMPONENT_TYPE), sdict->s[i].name, sdict->s[i].len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x9cd3
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
movl 0x75aa(%rip), %edi      # 0x11220
callq 0x9ce0
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl -0x18(%rbp), %ecx
movq %rax, %r8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rsi
imulq $0x18, %rsi, %rsi
addq %rsi, %rax
movq (%rax), %r9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rsi
imulq $0x18, %rsi, %rsi
addq %rsi, %rax
movl 0x10(%rax), %eax
leaq 0x3b2e(%rip), %rsi      # 0xd7e9
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2200
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9c37
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/./agp-spec.h
// Function: agp_component_type_val
static inline const char *agp_component_type_val(uint32_t key)
{
    switch ((AGP_CT_t) key) {
        case AGP_CT_A: return "A";
        case AGP_CT_D: return "D";
        case AGP_CT_F: return "F";
        case AGP_CT_G: return "G";
        case AGP_CT_O: return "O";
        case AGP_CT_P: return "P";
        case AGP_CT_W: return "W";
        case AGP_CT_N: return "N";
        case AGP_CT_U: return "U";
        default:       AGPSpec_die("[E::%s] AGP component type KEY error: %u\n", __func__, key);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0xfffd49fa, %eax       # imm = 0xFFFD49FA
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x16, %eax
ja 0x9d8e
movq -0x18(%rbp), %rax
leaq 0x35ab(%rip), %rcx      # 0xd2b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3b76(%rip), %rax      # 0xd893
movq %rax, -0x8(%rbp)
jmp 0x9dae
leaq 0x3b68(%rip), %rax      # 0xd895
movq %rax, -0x8(%rbp)
jmp 0x9dae
leaq 0x3b5d(%rip), %rax      # 0xd897
movq %rax, -0x8(%rbp)
jmp 0x9dae
leaq 0x3b52(%rip), %rax      # 0xd899
movq %rax, -0x8(%rbp)
jmp 0x9dae
leaq 0x3b47(%rip), %rax      # 0xd89b
movq %rax, -0x8(%rbp)
jmp 0x9dae
leaq 0x3b3c(%rip), %rax      # 0xd89d
movq %rax, -0x8(%rbp)
jmp 0x9dae
leaq 0x3b31(%rip), %rax      # 0xd89f
movq %rax, -0x8(%rbp)
jmp 0x9dae
leaq 0x38ca(%rip), %rax      # 0xd645
movq %rax, -0x8(%rbp)
jmp 0x9dae
leaq 0x38bf(%rip), %rax      # 0xd647
movq %rax, -0x8(%rbp)
jmp 0x9dae
movl -0xc(%rbp), %edx
leaq 0x3f42(%rip), %rdi      # 0xdcda
leaq 0x3f65(%rip), %rsi      # 0xdd04
movb $0x0, %al
callq 0xb630
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: write_asm_dict_to_fasta
uint64_t write_asm_dict_to_fasta(asm_dict_t *dict, int line_wd, FILE *fo)
{
    uint32_t i;
    uint64_t len = 0;
    for (i = 0; i < dict->n; ++i)
        len += write_segs_to_fasta(dict->seg + dict->s[i].s, dict->s[i].n, 
                &dict->s[i], dict->sdict, 0, line_wd, fo);
    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xa45a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movl 0x1c(%rax), %eax
imulq $0x30, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movl 0x18(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movl -0x1c(%rbp), %eax
imulq $0x58, %rax, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movl -0xc(%rbp), %r9d
movq -0x18(%rbp), %rax
xorl %r8d, %r8d
movq %rax, (%rsp)
callq 0x9dc0
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa3d2
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: write_fasta_file_from_agp
void write_fasta_file_from_agp(const char *fa, const char *agp, FILE *fo, int line_wd, int allow_unknown_oris)
{
    sdict_t *sdict = make_sdict_from_fa(fa, 0);
    asm_dict_t *dict = make_asm_dict_from_agp(sdict, agp, allow_unknown_oris);
    uint64_t len = write_asm_dict_to_fasta(dict, line_wd, fo);
    fprintf(stderr, "[I::%s] Number sequences: %u\n", __func__, dict->n);
    fprintf(stderr, "[I::%s] Number bases: %lu\n", __func__, len);
    asm_destroy(dict);
    sd_destroy(sdict);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5c30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x7140
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xa3b0
movq %rax, -0x38(%rbp)
movq 0x6b2f(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movl (%rax), %ecx
leaq 0x3367(%rip), %rsi      # 0xd840
leaq 0x337e(%rip), %rdx      # 0xd85e
movb $0x0, %al
callq 0x2200
movq 0x6b0a(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x38(%rbp), %rcx
leaq 0x337c(%rip), %rsi      # 0xd878
leaq 0x335b(%rip), %rdx      # 0xd85e
movb $0x0, %al
callq 0x2200
movq -0x30(%rbp), %rdi
callq 0x5360
movq -0x28(%rbp), %rdi
callq 0x5230
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: write_sequence_dictionary
uint64_t write_sequence_dictionary(FILE *fo, sdict_t *dict)
{
    uint32_t i;
    uint64_t l;
    // write number of sequences
    fwrite(&dict->n, sizeof(uint32_t), 1, fo);
    // write sequence lengths
    for (i = 0; i < dict->n; ++i)
        fwrite(&dict->s[i].len, sizeof(uint32_t), 1, fo);
    l = dict->n;
    for (i = 0; i < dict->n; ++i)
        l += strlen(dict->s[i].name);
    // write total length of sequence names
    fwrite(&l, sizeof(uint64_t), 1, fo);
    // write sequence name with a appending white space
    const unsigned char space = ' ';
    for (i = 0; i < dict->n; ++i) {
        fwrite(dict->s[i].name, 1, strlen(dict->s[i].name), fo);
        fwrite(&space, 1, 1, fo);
    }

    return sizeof(uint32_t) * (dict->n + 3) + l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x2390
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xa59d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x2390
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa55e
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xa5e6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2110
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa5ae
movq -0x8(%rbp), %rcx
leaq -0x20(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x2390
movb $0x20, -0x21(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xa67b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2110
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x2390
movq -0x8(%rbp), %rcx
leaq -0x21(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x2390
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa608
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x3, %eax
movl %eax, %eax
shlq $0x2, %rax
addq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: file_seek_skip_sdict
void file_seek_skip_sdict(FILE *fp)
{
    uint32_t n;
    uint64_t l, m;
    m = fread(&n, sizeof(uint32_t), 1, fp);
    if (m != 1) bin_fread_error();
    fseek(fp, sizeof(uint32_t) * n, SEEK_CUR);
    m = fread(&l, sizeof(uint64_t), 1, fp);
    if (m != 1) bin_fread_error();
    fseek(fp, l, SEEK_CUR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
leaq -0xc(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x20c0
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
je 0xa6d5
movb $0x0, %al
callq 0x2a80
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
shlq $0x2, %rsi
movl $0x1, %edx
callq 0x2280
movq -0x8(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x20c0
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
je 0xa715
movb $0x0, %al
callq 0x2a80
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x2280
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/./agp-spec.h
// Function: DJB_hash
static inline uint32_t DJB_hash(const char *str)
{
    uint32_t c, hash = 5381;
    while ((c = tolower(*str++)))
        hash = ((hash << 5) + hash) + c;
    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1505, -0x10(%rbp)    # imm = 0x1505
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %edi
callq 0x2250
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0xb583
movl -0x10(%rbp), %eax
shll $0x5, %eax
addl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xb553
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/./agp-spec.h
// Function: check_collision
static inline int check_collision(const char *t_val, const char *p_val)
{
    // case insensitive string comparison
    const unsigned char *p1 = (const unsigned char *) t_val;
    const unsigned char *p2 = (const unsigned char *) p_val;
    int result;
    if (p1 == p2)
        return 0;
    while ((result = tolower (*p1) - tolower(*p2++)) == 0)
        if (*p1++ == '\0')
            break;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0xb5c3
movl $0x0, -0x4(%rbp)
jmp 0xb61b
jmp 0xb5c5
movq -0x20(%rbp), %rax
movzbl (%rax), %edi
callq 0x2250
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %edi
callq 0x2250
movl %eax, %ecx
movl -0x30(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0xb615
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xb613
jmp 0xb615
jmp 0xb5c5
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/./agp-spec.h
// Function: AGPSpec_die
static inline void AGPSpec_die(char *format, ...)
{
    va_list args;
    va_start(args, format);
    vfprintf(stderr, format, args);
    va_end(args);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xb665
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x5941(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2320
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/./agp-spec.h
// Function: agp_gap_type_val
static inline const char *agp_gap_type_val(uint32_t key)
{
    switch ((AGP_GT_t) key) {
        case AGP_GT_SCAFFOLD:        return "scaffold";
        case AGP_GT_CONTIG:          return "contig";
        case AGP_GT_CENTROMERE:      return "centromere";
        case AGP_GT_SHORT_ARM:       return "short_arm";
        case AGP_GT_HETEROCHROMATIN: return "heterochromatin";
        case AGP_GT_TELOMERE:        return "telomere";
        case AGP_GT_REPEAT:          return "repeat";
        case AGP_GT_CONTAMINATION:   return "contamination";
        default:                     AGPSpec_die("[E::%s] AGP gap type KEY error: %u\n", __func__, key);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0xb3971714, %eax       # imm = 0xB3971714
je 0xb77d
jmp 0xb6fe
movl -0x10(%rbp), %eax
subl $0xd066abb9, %eax       # imm = 0xD066ABB9
je 0xb7b1
jmp 0xb70e
movl -0x10(%rbp), %eax
subl $0xec44fe02, %eax       # imm = 0xEC44FE02
je 0xb797
jmp 0xb71a
movl -0x10(%rbp), %eax
subl $0xf6e4a809, %eax       # imm = 0xF6E4A809
je 0xb763
jmp 0xb726
movl -0x10(%rbp), %eax
subl $0x1297c4f1, %eax       # imm = 0x1297C4F1
je 0xb78a
jmp 0xb732
movl -0x10(%rbp), %eax
subl $0x192dec66, %eax       # imm = 0x192DEC66
je 0xb7a4
jmp 0xb73e
movl -0x10(%rbp), %eax
subl $0x328bce39, %eax       # imm = 0x328BCE39
je 0xb770
jmp 0xb74a
movl -0x10(%rbp), %eax
subl $0x4bbf6747, %eax       # imm = 0x4BBF6747
jne 0xb7be
jmp 0xb756
leaq 0x21c0(%rip), %rax      # 0xd91d
movq %rax, -0x8(%rbp)
jmp 0xb7de
leaq 0x231d(%rip), %rax      # 0xda87
movq %rax, -0x8(%rbp)
jmp 0xb7de
leaq 0x21af(%rip), %rax      # 0xd926
movq %rax, -0x8(%rbp)
jmp 0xb7de
leaq 0x21ad(%rip), %rax      # 0xd931
movq %rax, -0x8(%rbp)
jmp 0xb7de
leaq 0x21aa(%rip), %rax      # 0xd93b
movq %rax, -0x8(%rbp)
jmp 0xb7de
leaq 0x21ad(%rip), %rax      # 0xd94b
movq %rax, -0x8(%rbp)
jmp 0xb7de
leaq 0x21a9(%rip), %rax      # 0xd954
movq %rax, -0x8(%rbp)
jmp 0xb7de
leaq 0x21a3(%rip), %rax      # 0xd95b
movq %rax, -0x8(%rbp)
jmp 0xb7de
movl -0xc(%rbp), %edx
leaq 0x240c(%rip), %rdi      # 0xdbd4
leaq 0x2429(%rip), %rsi      # 0xdbf8
movb $0x0, %al
callq 0xb630
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/./agp-spec.h
// Function: agp_linkage_val
static inline const char *agp_linkage_val(uint32_t key)
{
    switch ((AGP_LG_t) key) {
        case AGP_LG_YES: return "yes";
        case AGP_LG_NO:  return "no";
        default:         AGPSpec_die("[E::%s] AGP linkage KEY error: %u\n", __func__, key);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x5978e2, %eax         # imm = 0x5978E2
je 0xb823
jmp 0xb80a
movl -0x10(%rbp), %eax
subl $0xb88c316, %eax        # imm = 0xB88C316
jne 0xb830
jmp 0xb816
leaq 0x21b6(%rip), %rax      # 0xd9d3
movq %rax, -0x8(%rbp)
jmp 0xb850
leaq 0x21ad(%rip), %rax      # 0xd9d7
movq %rax, -0x8(%rbp)
jmp 0xb850
movl -0xc(%rbp), %edx
leaq 0x23cf(%rip), %rdi      # 0xdc09
leaq 0x23eb(%rip), %rsi      # 0xdc2c
movb $0x0, %al
callq 0xb630
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/./agp-spec.h
// Function: agp_orientation_val
static inline const char *agp_orientation_val(uint32_t key)
{
    switch ((AGP_OT_t) key) {
        case AGP_OT_PLUS:    return "+";
        case AGP_OT_MINUS:   return "-";
        case AGP_OT_UNKNOWN:
        case AGP_OT_ZERO:
        case AGP_OT_ZERO_S:  return "?";
        case AGP_OT_NA:      return "na";
        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, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x2b5d0, %eax          # imm = 0x2B5D0
je 0xba56
jmp 0xba1a
movl -0x10(%rbp), %eax
subl $0x2b5d2, %eax          # imm = 0x2B5D2
je 0xba63
jmp 0xba26
movl -0x10(%rbp), %eax
subl $0x2b5d5, %eax          # imm = 0x2B5D5
je 0xba70
jmp 0xba32
movl -0x10(%rbp), %eax
subl $0x2b5e4, %eax          # imm = 0x2B5E4
je 0xba70
jmp 0xba3e
movl -0x10(%rbp), %eax
subl $0x5978d4, %eax         # imm = 0x5978D4
je 0xba7d
jmp 0xba4a
movl -0x10(%rbp), %eax
subl $0x7ca1b285, %eax       # imm = 0x7CA1B285
je 0xba70
jmp 0xba8a
leaq 0x1c98(%rip), %rax      # 0xd6f5
movq %rax, -0x8(%rbp)
jmp 0xbaaa
leaq 0x1732(%rip), %rax      # 0xd19c
movq %rax, -0x8(%rbp)
jmp 0xbaaa
leaq 0x1c80(%rip), %rax      # 0xd6f7
movq %rax, -0x8(%rbp)
jmp 0xbaaa
leaq 0x1c75(%rip), %rax      # 0xd6f9
movq %rax, -0x8(%rbp)
jmp 0xbaaa
movl -0xc(%rbp), %edx
leaq 0x220b(%rip), %rdi      # 0xdc9f
leaq 0x222b(%rip), %rsi      # 0xdcc6
movb $0x0, %al
callq 0xb630
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/agp_to_fasta.c
// Function: print_help
static void print_help(FILE *fp_help)
{
    fprintf(fp_help, "Usage: agp_to_fasta [options] <scaffolds.agp> <contigs.fa>\n");
    fprintf(fp_help, "Options:\n");
    fprintf(fp_help, "    -l INT            line width [60]\n");
    fprintf(fp_help, "    -u                allow sequence components with unknown orientations\n");
    fprintf(fp_help, "    -o STR            output to file [stdout]\n");
    fprintf(fp_help, "    --version         show version number\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1f23(%rip), %rsi      # 0xde3a
movb $0x0, %al
callq 0x2200
movq -0x8(%rbp), %rdi
leaq 0x1f4d(%rip), %rsi      # 0xde76
movb $0x0, %al
callq 0x2200
movq -0x8(%rbp), %rdi
leaq 0x1f45(%rip), %rsi      # 0xde80
movb $0x0, %al
callq 0x2200
movq -0x8(%rbp), %rdi
leaq 0x1f5a(%rip), %rsi      # 0xdea7
movb $0x0, %al
callq 0x2200
movq -0x8(%rbp), %rdi
leaq 0x1f93(%rip), %rsi      # 0xdef2
movb $0x0, %al
callq 0x2200
movq -0x8(%rbp), %rdi
leaq 0x1fb0(%rip), %rsi      # 0xdf21
movb $0x0, %al
callq 0x2200
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dropletzhu[P]msuite/mlistener6.c
// Function: usage
void usage()
{
	printf("Usage: ./mlistener -s source -i interface -g group -p port -l length \n");
	printf(" -s souurce	use the source to select bind device\n");
	printf(" -i ifname	interface name\n");
	printf(" -g group	the group to listen\n");
	printf(" -p port	the port to listen\n");
	printf(" -l length	the packet length, default length is 256 bytes\n");
	printf(" Version 	%s\n", version);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xded(%rip), %rdi       # 0x2038
movb $0x0, %al
callq 0x1070
leaq 0xe26(%rip), %rdi       # 0x207f
movb $0x0, %al
callq 0x1070
leaq 0xe4a(%rip), %rdi       # 0x20b1
movb $0x0, %al
callq 0x1070
leaq 0xe57(%rip), %rdi       # 0x20cc
movb $0x0, %al
callq 0x1070
leaq 0xe68(%rip), %rdi       # 0x20eb
movb $0x0, %al
callq 0x1070
leaq 0xe77(%rip), %rdi       # 0x2108
movb $0x0, %al
callq 0x1070
leaq 0xea4(%rip), %rdi       # 0x2143
leaq 0xeab(%rip), %rsi       # 0x2151
movb $0x0, %al
callq 0x1070
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_09/scdu_modlut.c
// Function: mod_crypt
void mod_crypt(char *text, size_t n)
{
        int i;

	for (i = 0; i < n; i++) {
                if ((text[i] >= 'a') && (text[i] <= 'z'))
                        text[i] = lut[text[i] - 'a' + 26];
                else if ((text[i] >= 'A') && (text[i] <= 'Z'))
                        text[i] = lut[text[i] - 'A'];
                else
                        continue;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x10ee
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x108f
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7a, %eax
jg 0x108f
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x61, %eax
addl $0x1a, %eax
movslq %eax, %rcx
movq 0x2f79(%rip), %rax      # 0x3ff8
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x10de
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x10da
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5a, %eax
jg 0x10da
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x41, %eax
movslq %eax, %rcx
movq 0x2f2e(%rip), %rax      # 0x3ff8
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x10dc
jmp 0x10e0
jmp 0x10de
jmp 0x10e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1033
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_09/scdu_modlut.c
// Function: mod_decrypt
void mod_decrypt(char *text, size_t n)
{
        int i;
	char *ptr;
	int base;

        for (i = 0; i < n; i++) {
		ptr = strchr(lut, text[i]);
		if (!ptr)
			continue;

        	base = ptr - lut;
		if (base < 26)
			text[i] = base + 'A';
		else if (base >= 26)
			text[i] = base - 26 + 'a';
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1190
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %esi
movq 0x2ed4(%rip), %rdi      # 0x3ff8
callq 0x1010
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1136
jmp 0x1182
movq -0x20(%rbp), %rax
movq 0x2eb7(%rip), %rcx      # 0x3ff8
subq %rcx, %rax
movl %eax, -0x24(%rbp)
cmpl $0x1a, -0x24(%rbp)
jge 0x1162
movl -0x24(%rbp), %eax
addl $0x41, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x1180
cmpl $0x1a, -0x24(%rbp)
jl 0x117e
movl -0x24(%rbp), %eax
subl $0x1a, %eax
addl $0x61, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x1180
jmp 0x1182
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1107
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-zoe/kojimasound/kojimasound.c
// Function: vagPrepareHeader
void vagPrepareHeader( vagHeader *header, uint32_t size, uint32_t samplerate ) {
	header->version[3] = 0x20;
	memset( header->name, 0, 0x10 );
	header->size[0] = (size >> 24) & 0xFF; header->size[1] = (size >> 16) & 0xFF; header->size[2] = (size >> 8) & 0xFF; header->size[3] = size & 0xFF;
	header->samplerate[0] = 0; header->samplerate[1] = 0; header->samplerate[2] = (samplerate >> 8) & 0xFF; header->samplerate[3] = samplerate & 0xFF;
	memset( header->reserved1, 0, 4 );
	memset( header->reserved2, 0, 12 );
	strncpy( header->magic, "VAGp", 4 );
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x20, 0x7(%rax)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1080
movl -0xc(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xc(%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xd(%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xe(%rax)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xf(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x11(%rax)
movl -0x10(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x12(%rax)
movl -0x10(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x13(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x1080
movq -0x8(%rbp), %rdi
addq $0x14, %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0x1080
movq -0x8(%rbp), %rdi
leaq 0xd41(%rip), %rsi       # 0x2004
movl $0x4, %edx
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)