LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/dvb/si/datetime.h
// Function: dvb_time_decode_UTC
static inline time_t dvb_time_decode_UTC(uint64_t UTC_time) {
    struct tm tm;
    uint16_t mjd = (UTC_time >> 24) & 0xffff;
    uint32_t bcd = UTC_time & 0xffffff;

    dvb_mjd_get(mjd, &tm.tm_year, &tm.tm_mon, &tm.tm_mday);
    /* DVB months are 1..12, struct tm needs 0..11 */
    tm.tm_mon  -= 1;

    dvb_time_decode_bcd(bcd, NULL, &tm.tm_hour, &tm.tm_min, &tm.tm_sec);

    return timegm(&tm);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, %rax
shrq $0x18, %rax
movzwl %ax, %r8d
imull $0x14, %r8d, %eax
addl $0xfffb6604, %eax       # imm = 0xFFFB6604
movl $0x1c89, %ecx           # imm = 0x1C89
cltd
idivl %ecx
movl %eax, %ecx
imull $0x5b5, %eax, %eax      # imm = 0x5B5
pushq $-0x4
popq %rsi
cltd
idivl %esi
movl %eax, %esi
addl %r8d, %esi
imull $0x2710, %esi, %r8d     # imm = 0x2710
leal -0x8ea1ea8(%r8), %eax
movl $0x4ab51, %r9d          # imm = 0x4AB51
cltd
idivl %r9d
addl $0xf6d482ea, %r8d       # imm = 0xF6D482EA
cmpl $0x956a2, %r8d          # imm = 0x956A2
adcl $0x0, %ecx
leal -0xc(%rax), %r9d
cmpl $0x956a2, %r8d          # imm = 0x956A2
cmovael %eax, %r9d
imull $0x4ab51, %eax, %eax    # imm = 0x4AB51
movl $0xffffd8f0, %r8d       # imm = 0xFFFFD8F0
cltd
idivl %r8d
leal (%rax,%rsi), %edx
addl $0xffffc594, %edx       # imm = 0xFFFFC594
movq %rsp, %rax
movl %edx, 0xc(%rax)
movl %ecx, 0x14(%rax)
addl $-0x2, %r9d
movl %r9d, 0x10(%rax)
movl %edi, %ecx
shrl $0x10, %ecx
movl %edi, %edx
shrl $0x14, %edx
andl $0xf, %edx
imull $0xa, %edx, %edx
andl $0xf, %ecx
addl %edx, %ecx
movl %ecx, 0x8(%rax)
movl %edi, %ecx
shrl $0x8, %ecx
movl %edi, %edx
shrl $0xc, %edx
andl $0xf, %edx
imull $0xa, %edx, %edx
andl $0xf, %ecx
addl %edx, %ecx
movl %ecx, 0x4(%rax)
movl %edi, %ecx
shrl $0x4, %ecx
andl $0xf, %ecx
imull $0xa, %ecx, %ecx
andl $0xf, %edi
addl %ecx, %edi
movl %edi, (%rax)
movq %rax, %rdi
callq 0x10b0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/dvb/si/desc_58.h
// Function: desc58_next_lto
static inline uint8_t *desc58_next_lto(const uint8_t *p_desc,
                                       const uint8_t *p_desc_n)
{
    if (!p_desc_n)
        p_desc_n = p_desc + DESC58_HEADER_SIZE;
    else
        p_desc_n += DESC58_LTO_SIZE;
    return desc_check(p_desc, p_desc_n, DESC58_LTO_SIZE);
}

// Assembly:
leaq 0xd(%rsi), %rcx
leaq 0x2(%rdi), %rdx
testq %rsi, %rsi
cmoveq %rdx, %rcx
testq %rdi, %rdi
sete %al
cmpq %rcx, %rdx
seta %sil
orb %al, %sil
je 0x5bda
xorl %eax, %eax
retq
leaq 0xd(%rcx), %rsi
movzbl 0x1(%rdi), %eax
addq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rsi
cmovbeq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/dvb/si/desc_58.h
// Function: desc58n_set_time_of_change
static inline void desc58n_set_time_of_change(uint8_t *p_desc_n, uint64_t i_time_of_change)
{
    p_desc_n[6] = (i_time_of_change >> 32) & 0xff;
    p_desc_n[7] = (i_time_of_change >> 24) & 0xff;
    p_desc_n[8] = (i_time_of_change >> 16) & 0xff;
    p_desc_n[9] = (i_time_of_change >> 8) & 0xff;
    p_desc_n[10] = i_time_of_change & 0xff;
}

// Assembly:
movq %rsi, %rax
movq %rsi, %rcx
shrq $0x20, %rcx
movb %cl, 0x6(%rdi)
movl %eax, %ecx
shrl $0x18, %ecx
movb %cl, 0x7(%rdi)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x8(%rdi)
movb %ah, 0x9(%rdi)
movb %al, 0xa(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/dvb/si/rst.h
// Function: rst_get_status
static inline uint8_t *rst_get_status(uint8_t *p_rst, uint8_t n)
{
    uint8_t *p_rst_n = p_rst + RST_HEADER_SIZE + n * RST_STATUS_SIZE;
    if (p_rst_n + RST_STATUS_SIZE - p_rst
         > psi_get_length(p_rst) + PSI_HEADER_SIZE)
        return NULL;
    return p_rst_n;
}

// Assembly:
movl %esi, %eax
leaq (%rax,%rax,8), %rcx
addq %rdi, %rcx
addq $0x3, %rcx
leaq (%rax,%rax,8), %rdx
addq $0xc, %rdx
movzbl 0x1(%rdi), %eax
andl $0xf, %eax
shll $0x8, %eax
movzbl 0x2(%rdi), %esi
addq %rax, %rsi
addq $0x3, %rsi
xorl %eax, %eax
cmpq %rsi, %rdx
cmovleq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/dvb_gen_si.c
// Function: build_desc46
static void build_desc46(uint8_t *desc) {
    uint8_t k = 0;
    uint8_t *lang_n;

    desc46_init(desc);
    desc_set_length(desc, 255);

    lang_n = desc46_get_language(desc, k++);
    desc46n_set_code(lang_n, (uint8_t *)"eng");
    desc46n_set_teletexttype(lang_n, 1);
    desc46n_set_teletextmagazine(lang_n, 3);
    desc46n_set_teletextpage(lang_n, 255);

    lang_n = desc46_get_language(desc, k++);
    desc46n_set_code(lang_n, (uint8_t *)"bul");
    desc46n_set_teletexttype(lang_n, 2);
    desc46n_set_teletextmagazine(lang_n, 2);
    desc46n_set_teletextpage(lang_n, 127);

    lang_n = desc46_get_language(desc, k++);
    desc46n_set_code(lang_n, (uint8_t *)"fre");
    desc46n_set_teletexttype(lang_n, 3);
    desc46n_set_teletextmagazine(lang_n, 1);
    desc46n_set_teletextpage(lang_n, 64);

    lang_n = desc46_get_language(desc, k);
    desc_set_length(desc, lang_n - desc - DESC_HEADER_SIZE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movw $0xff46, (%rdi)         # imm = 0xFF46
leaq 0x148(%rip), %r14       # 0x5dd1
xorl %esi, %esi
movq %r14, %rdx
callq 0x500e
movl $0xb676e65, (%rax)      # imm = 0xB676E65
movb $-0x1, 0x4(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x500e
movl $0x126c7562, (%rax)     # imm = 0x126C7562
movb $0x7f, 0x4(%rax)
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x500e
movl $0x19657266, (%rax)     # imm = 0x19657266
movb $0x40, 0x4(%rax)
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x500e
subl %ebx, %eax
addb $-0x2, %al
movb %al, 0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/mpeg/psi/pmt.h
// Function: pmt_next_es
static inline uint8_t *pmt_next_es(uint8_t *p_pmt, uint8_t *p_pmt_n)
{
    uint16_t i_section_size =
        psi_get_length(p_pmt) + PSI_HEADER_SIZE - PSI_CRC_SIZE;
    if (!p_pmt_n)
        p_pmt_n = p_pmt + PMT_HEADER_SIZE + pmt_get_desclength(p_pmt);
    else {
        if (p_pmt_n + PMT_ES_SIZE - p_pmt > i_section_size) return NULL;
        p_pmt_n += PMT_ES_SIZE + pmtn_get_desclength(p_pmt_n);
    }
    return (p_pmt_n - p_pmt < i_section_size) ? p_pmt_n : NULL;
}

// Assembly:
movzbl 0x1(%rdi), %eax
andl $0xf, %eax
shll $0x8, %eax
movzbl 0x2(%rdi), %ecx
addl %ecx, %eax
decl %eax
testq %rsi, %rsi
je 0x5d16
movq %rsi, %rdx
subq %rdi, %rdx
addq $0x5, %rdx
movzwl %ax, %ecx
cmpq %rcx, %rdx
jle 0x5d33
xorl %eax, %eax
retq
movzbl 0xa(%rdi), %ecx
andl $0xf, %ecx
shll $0x8, %ecx
movzbl 0xb(%rdi), %edx
orq %rcx, %rdx
addq %rdi, %rdx
addq $0xc, %rdx
movzwl %ax, %ecx
jmp 0x5d4b
movzbl 0x3(%rsi), %eax
andl $0xf, %eax
shll $0x8, %eax
movzbl 0x4(%rsi), %edx
orq %rax, %rdx
addq %rsi, %rdx
addq $0x5, %rdx
movq %rdx, %rsi
subq %rdi, %rsi
xorl %eax, %eax
cmpq %rcx, %rsi
cmovlq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/mpeg/psi/desc_0a.h
// Function: desc0a_next_language
static inline uint8_t *desc0a_next_language(const uint8_t *p_desc,
                                            const uint8_t *p_desc_n)
{
    if (!p_desc_n)
        p_desc_n = p_desc + DESC0A_HEADER_SIZE;
    else
        p_desc_n += DESC0A_LANGUAGE_SIZE;
    return desc_check(p_desc, p_desc_n, DESC0A_LANGUAGE_SIZE);
}

// Assembly:
leaq 0x4(%rsi), %rcx
leaq 0x2(%rdi), %rdx
testq %rsi, %rsi
cmoveq %rdx, %rcx
testq %rdi, %rdi
sete %al
cmpq %rcx, %rdx
seta %sil
orb %al, %sil
je 0x5d7f
xorl %eax, %eax
retq
leaq 0x4(%rcx), %rsi
movzbl 0x1(%rdi), %eax
addq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rsi
cmovbeq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/dvb/si/desc_5e.h
// Function: desc5e_next_data
static inline uint8_t *desc5e_next_data(const uint8_t *p_desc,
                                        const uint8_t *p_desc_n)
{
    if (!p_desc_n)
        p_desc_n = p_desc + DESC5E_HEADER_SIZE;
    else
        p_desc_n += DESC5E_DATA_SIZE + desc5en_get_text_length(p_desc_n);
    return desc_check(p_desc, p_desc_n, DESC5E_DATA_SIZE);
}

// Assembly:
testq %rsi, %rsi
je 0x5da7
movzbl 0x3(%rsi), %eax
leaq (%rsi,%rax), %rcx
addq $0x4, %rcx
jmp 0x5dab
leaq 0x3(%rdi), %rcx
testq %rdi, %rdi
je 0x5db9
leaq 0x2(%rdi), %rdx
cmpq %rcx, %rdx
jbe 0x5dbc
xorl %eax, %eax
retq
leaq 0x4(%rcx), %rsi
movzbl 0x1(%rdi), %eax
addq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rsi
cmovbeq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/dvb/si/desc_46.h
// Function: desc46_next_language
static inline uint8_t *desc46_next_language(const uint8_t *p_desc,
                                            const uint8_t *p_desc_n)
{
    if (!p_desc_n)
        p_desc_n = p_desc + DESC46_HEADER_SIZE;
    else
        p_desc_n += DESC46_LANGUAGE_SIZE;
    return desc_check(p_desc, p_desc_n, DESC46_LANGUAGE_SIZE);
}

// Assembly:
leaq 0x5(%rsi), %rcx
leaq 0x2(%rdi), %rdx
testq %rsi, %rsi
cmoveq %rdx, %rcx
testq %rdi, %rdi
sete %al
cmpq %rcx, %rdx
seta %sil
orb %al, %sil
je 0x5df5
xorl %eax, %eax
retq
leaq 0x5(%rcx), %rsi
movzbl 0x1(%rdi), %eax
addq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rsi
cmovbeq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/dvb/si/desc_45.h
// Function: desc45_next_data
static inline uint8_t *desc45_next_data(const uint8_t *p_desc,
                                        const uint8_t *p_desc_n)
{
    if (!p_desc_n)
        p_desc_n = p_desc + DESC45_HEADER_SIZE;
    else
        p_desc_n += DESC45_DATA_SIZE + desc45n_get_data_length(p_desc_n);
    return desc_check(p_desc, p_desc_n, DESC45_DATA_SIZE);
}

// Assembly:
movq %rdi, %rcx
testq %rsi, %rsi
je 0x5e19
movzbl 0x1(%rsi), %ecx
addq %rsi, %rcx
xorl %eax, %eax
testq %rdi, %rdi
je 0x5e42
cmpq %rdi, %rcx
jb 0x5e42
leaq 0x2(%rcx), %rdx
addq $0x4, %rcx
movzbl 0x1(%rdi), %eax
leaq (%rdi,%rax), %rsi
addq $0x2, %rsi
xorl %eax, %eax
cmpq %rsi, %rcx
cmovbeq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/dvb/si/desc_59.h
// Function: desc59_next_language
static inline uint8_t *desc59_next_language(const uint8_t *p_desc,
                                            const uint8_t *p_desc_n)
{
    if (!p_desc_n)
        p_desc_n = p_desc + DESC59_HEADER_SIZE;
    else
        p_desc_n += DESC59_LANGUAGE_SIZE;
    return desc_check(p_desc, p_desc_n, DESC59_LANGUAGE_SIZE);
}

// Assembly:
leaq 0x8(%rsi), %rcx
leaq 0x2(%rdi), %rdx
testq %rsi, %rsi
cmoveq %rdx, %rcx
testq %rdi, %rdi
sete %al
cmpq %rcx, %rdx
seta %sil
orb %al, %sil
je 0x5e67
xorl %eax, %eax
retq
leaq 0x8(%rcx), %rsi
movzbl 0x1(%rdi), %eax
addq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rsi
cmovbeq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/mpeg/psi/desc_1f.h
// Function: desc1f_next_entry
static inline uint8_t *desc1f_next_entry(const uint8_t *p_desc,
                                         const uint8_t *p_desc_n)
{
    if (!p_desc_n)
        p_desc_n = p_desc + DESC1F_HEADER_SIZE;
    else
        p_desc_n += DESC1F_ENTRY_SIZE;
    return desc_check(p_desc, p_desc_n, DESC1F_ENTRY_SIZE);
}

// Assembly:
leaq 0x3(%rsi), %rcx
leaq 0x2(%rdi), %rdx
testq %rsi, %rsi
cmoveq %rdx, %rcx
testq %rdi, %rdi
sete %al
cmpq %rcx, %rdx
seta %sil
orb %al, %sil
je 0x5ea0
xorl %eax, %eax
retq
leaq 0x3(%rcx), %rsi
movzbl 0x1(%rdi), %eax
addq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rsi
cmovbeq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/mpeg/psi/desc_21.h
// Function: desc21_next_entry
static inline uint8_t *desc21_next_entry(const uint8_t *p_desc,
                                         const uint8_t *p_desc_n)
{
    if (!p_desc_n)
        p_desc_n = p_desc + DESC21_HEADER_SIZE;
    else
        p_desc_n += 1 + desc21n_get_length(p_desc_n);
    return desc_check(p_desc, p_desc_n, 1);
}

// Assembly:
testq %rsi, %rsi
je 0x5ec6
movzbl (%rsi), %eax
leaq (%rsi,%rax), %rcx
incq %rcx
jmp 0x5eca
leaq 0x2(%rdi), %rcx
testq %rdi, %rdi
je 0x5ed8
leaq 0x2(%rdi), %rdx
cmpq %rcx, %rdx
jbe 0x5edb
xorl %eax, %eax
retq
leaq 0x1(%rcx), %rsi
movzbl 0x1(%rdi), %eax
addq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rsi
cmovbeq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/mpeg/psi/desc_21.h
// Function: desc21n_next_substruct
static inline uint8_t *desc21n_next_substruct(const uint8_t *p_desc_n,
                                              const uint8_t *p_desc_k)
{
    if (!p_desc_k)
        p_desc_k = p_desc_n + DESC21_ENTRY_HEADER_SIZE;
    else
        p_desc_k += DESC21_SUBSTRUCT_HEADER_SIZE +
            2 * desc21k_get_slot_count(p_desc_k);
    return desc21n_check_substruct(p_desc_n, p_desc_k);
}

// Assembly:
testq %rsi, %rsi
je 0x5f04
movzbl (%rsi), %ecx
shrl $0x2, %ecx
orq $0x1, %rcx
addq %rsi, %rcx
jmp 0x5f08
leaq 0x3(%rdi), %rcx
leaq 0x3(%rdi), %rdx
leaq 0x1(%rcx), %rax
movzbl (%rdi), %esi
addq %rdi, %rsi
incq %rsi
xorl %edi, %edi
cmpq %rsi, %rax
movq %rcx, %rax
cmovaq %rdi, %rax
cmpq %rcx, %rdx
cmovaq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/mpeg/psi/desc_22.h
// Function: desc22_next_entry
static inline uint8_t *desc22_next_entry(const uint8_t *p_desc,
                                         const uint8_t *p_desc_n)
{
    if (!p_desc_n)
        p_desc_n = p_desc + DESC22_HEADER_SIZE;
    else
        p_desc_n += DESC22_ENTRY_SIZE;
    return desc_check(p_desc, p_desc_n, DESC22_ENTRY_SIZE);
}

// Assembly:
leaq 0x4(%rsi), %rcx
leaq 0x5(%rdi), %rax
testq %rsi, %rsi
cmoveq %rax, %rcx
testq %rdi, %rdi
je 0x5f4a
leaq 0x2(%rdi), %rdx
cmpq %rcx, %rdx
jbe 0x5f4d
xorl %eax, %eax
retq
leaq 0x4(%rcx), %rsi
movzbl 0x1(%rdi), %eax
addq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rsi
cmovbeq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/mpeg/psi/desc_24.h
// Function: desc24_set_time_base_association
static inline void desc24_set_time_base_association(uint8_t *p_desc, uint8_t i_length, uint8_t *p_data)
{
    uint8_t i_indicator = desc24_get_content_time_base_indicator(p_desc);
    if (i_indicator >= 3 && i_indicator <= 7) {
        uint8_t ofs = __ofs2;
        p_desc[ofs] = i_length;
        memcpy(p_desc + ofs + 1, p_data, i_length);
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x606d
addb $-0x3, %al
cmpb $0x4, %al
ja 0x6112
movb 0x2(%rbx), %al
andb 0x3(%rbx), %al
cmpb $-0x1, %al
sete %bpl
shlb $0x2, %bpl
addb $0x5, %bpl
movq %rbx, %rdi
callq 0x6084
testb %al, %al
je 0x60fa
movq %rbx, %rdi
callq 0x6099
incb %al
jmp 0x60fc
xorl %eax, %eax
addb %bpl, %al
movzbl %al, %eax
movb $0x3, (%rbx,%rax)
movw $0x4241, 0x1(%rbx,%rax) # imm = 0x4241
movb $0x43, 0x3(%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/dvb/si/sit.h
// Function: sit_get_service
static inline uint8_t *sit_get_service(uint8_t *p_sit, uint8_t n)
{
    uint16_t i_section_size = psi_get_length(p_sit) + PSI_HEADER_SIZE
                               - PSI_CRC_SIZE;
    uint8_t *p_sit_n = p_sit + SIT_HEADER_SIZE + sit_get_desclength(p_sit);
    if (p_sit_n - p_sit > i_section_size) return NULL;

    while (n) {
        if (p_sit_n + SIT_SERVICE_SIZE - p_sit > i_section_size) return NULL;
        p_sit_n += SIT_SERVICE_SIZE + sitn_get_desclength(p_sit_n);
        n--;
    }
    if (p_sit_n - p_sit >= i_section_size) return NULL;
    return p_sit_n;
}

// Assembly:
movzbl 0x1(%rdi), %eax
andl $0xf, %eax
shll $0x8, %eax
movzbl 0x2(%rdi), %ecx
addl %eax, %ecx
decl %ecx
movzbl 0x8(%rdi), %eax
andl $0xf, %eax
shll $0x8, %eax
movzbl 0x9(%rdi), %edx
leaq (%rax,%rdx), %r8
addq $0xa, %r8
movzwl %cx, %ecx
cmpq %rcx, %r8
jle 0x63f4
xorl %eax, %eax
retq
orq %rdx, %rax
leaq (%rdi,%rax), %rdx
addq $0xa, %rdx
xorl %eax, %eax
subb $0x1, %sil
jb 0x6434
movq %rdx, %r8
subq %rdi, %r8
addq $0x4, %r8
cmpq %rcx, %r8
jg 0x63f3
movzbl 0x2(%rdx), %r8d
andl $0xf, %r8d
shll $0x8, %r8d
movzbl 0x3(%rdx), %r9d
orq %r8, %r9
addq %r9, %rdx
addq $0x4, %rdx
jmp 0x6401
movq %rdx, %rsi
subq %rdi, %rsi
xorl %eax, %eax
cmpq %rcx, %rsi
cmovlq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_insert_get_break_duration
static inline uint8_t *scte35_insert_get_break_duration(const uint8_t *p_scte35)
{
    if (!scte35_insert_has_program_splice(p_scte35))
        return scte35_insert_get_component(p_scte35,
                scte35_insert_get_component_count(p_scte35) + 1);

    if (scte35_insert_has_splice_immediate(p_scte35))
        return scte35_get_command(p_scte35) + SCTE35_INSERT_HEADER_SIZE +
               SCTE35_INSERT_HEADER2_SIZE;

    uint8_t *p_splice_time = scte35_insert_get_splice_time(p_scte35);
    return p_splice_time + scte35_splice_time_size(p_splice_time);
}

// Assembly:
movq %rdi, %rax
movb 0x13(%rdi), %cl
testb $0x40, %cl
jne 0x6490
movzbl 0x1(%rax), %edx
andl $0xf, %edx
shll $0x8, %edx
movzbl 0x2(%rax), %esi
addl %esi, %edx
decl %edx
movzwl %dx, %edx
cmpl $0x15, %edx
jae 0x64a9
xorl %eax, %eax
retq
addq $0x14, %rax
testb $0x10, %cl
jne 0x64a8
movb (%rax), %cl
shrb $0x7, %cl
movzbl %cl, %ecx
leaq (%rax,%rcx,4), %rax
incq %rax
retq
movb 0x14(%rax), %dil
incb %dil
leaq 0x15(%rax), %rsi
pushq $0x1
popq %r8
subb $0x1, %dil
jb 0x64ed
leaq 0x1(%rsi), %r9
movq %r9, %r10
subq %rax, %r10
cmpq %rdx, %r10
jg 0x648d
movq %r8, %r10
testb $0x10, %cl
je 0x64e8
movb (%r9), %r9b
shrb $0x7, %r9b
movzbl %r9b, %r9d
leaq 0x2(,%r9,4), %r10
addq %r10, %rsi
jmp 0x64b8
movq %rsi, %rcx
subq %rax, %rcx
xorl %eax, %eax
cmpq %rdx, %rcx
cmovlq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/tests/run-loader.c
// Function: main
int
main(int argc, char *argv[])
{
    int number;

    if (argc < 2) {
        printf("Usage: %s file1.yaml ...\n", argv[0]);
        return 0;
    }

    for (number = 1; number < argc; number ++)
    {
        FILE *file;
        yaml_parser_t parser;
        yaml_document_t document;
        int done = 0;
        int count = 0;
        int error = 0;

        printf("[%d] Loading '%s': ", number, argv[number]);
        fflush(stdout);

        file = fopen(argv[number], "rb");
        assert(file);

        assert(yaml_parser_initialize(&parser));

        yaml_parser_set_input_file(&parser, file);

        while (!done)
        {
            if (!yaml_parser_load(&parser, &document)) {
                error = 1;
                break;
            }

            done = (!yaml_document_get_root_node(&document));

            yaml_document_delete(&document);

            if (!done) count ++;
        }

        yaml_parser_delete(&parser);

        assert(!fclose(file));

        printf("%s (%d documents)\n", (error ? "FAILURE" : "SUCCESS"), count);
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %rbx
cmpl $0x2, %edi
jge 0x121a
movq (%rbx), %rsi
leaq 0xe05(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1070
xorl %eax, %eax
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %eax
movq %rax, 0x8(%rsp)
pushq $0x1
popq %r14
leaq 0x78(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq %rbx, (%rsp)
cmpq 0x8(%rsp), %r14
je 0x1206
movq (%rbx,%r14,8), %rdx
leaq 0xdd9(%rip), %rdi       # 0x201e
movl %r14d, %esi
xorl %eax, %eax
callq 0x1070
movq 0x2d8a(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10c0
movq (%rbx,%r14,8), %rdi
leaq 0xdc9(%rip), %rsi       # 0x2032
callq 0x10d0
testq %rax, %rax
je 0x1311
movq %rax, %r12
movq %r13, %rdi
callq 0x10b0
testl %eax, %eax
je 0x132a
movq %r13, %rdi
movq %r12, %rsi
callq 0x1030
xorl %r15d, %r15d
movb $0x1, %bl
testb $0x1, %bl
je 0x12cb
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1060
testl %eax, %eax
je 0x12cb
movq %rbp, %rdi
callq 0x1040
xorl %ebx, %ebx
testq %rax, %rax
setne %bl
movq %rbp, %rdi
callq 0x1090
addl %ebx, %r15d
jmp 0x129a
movq %r13, %rdi
callq 0x10a0
movq %r12, %rdi
callq 0x1050
testl %eax, %eax
jne 0x1343
testb $0x1, %bl
leaq 0xdbe(%rip), %rsi       # 0x20a7
leaq 0xdaf(%rip), %rax       # 0x209f
cmovneq %rax, %rsi
leaq 0xd91(%rip), %rdi       # 0x208c
movl %r15d, %edx
xorl %eax, %eax
callq 0x1070
incq %r14
movq (%rsp), %rbx
jmp 0x1233
leaq 0xd1d(%rip), %rdi       # 0x2035
leaq 0xd1b(%rip), %rsi       # 0x203a
leaq 0xd21(%rip), %rcx       # 0x2047
pushq $0x22
jmp 0x135a
leaq 0xd2d(%rip), %rdi       # 0x205e
leaq 0xd02(%rip), %rsi       # 0x203a
leaq 0xd08(%rip), %rcx       # 0x2047
pushq $0x24
jmp 0x135a
leaq 0xd34(%rip), %rdi       # 0x207e
leaq 0xce9(%rip), %rsi       # 0x203a
leaq 0xcef(%rip), %rcx       # 0x2047
pushq $0x38
popq %rdx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/keiranrowan[P]tiny-core/./src/cat.c
// Function: main
int main(int argc, char **argv) {
	if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
		printf("cat [FILE]...\n- to read stdin\n");
	} else if (strcmp(argv[1],"-") == 0) {
		char ch;
		while ((ch = getc(stdin)) != EOF) {
			putc(ch, stdout);
		}
	} else {
		int i;
		for (i = 1; i < argc; i++) {
			FILE *fp;
			char ch;
			fp = fopen(argv[i], "r");
			if (fp) {
				while ((ch = getc(fp)) != EOF) {
					putc(ch, stdout);
				}
				fclose(fp);
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %r14
movb (%r14), %r15b
cmpb $0x2d, %r15b
jne 0x11b7
cmpb $0x68, 0x1(%r14)
jne 0x11b7
cmpb $0x0, 0x2(%r14)
je 0x1234
leaq 0xe46(%rip), %rsi       # 0x2004
movq %r14, %rdi
callq 0x1050
testl %eax, %eax
je 0x1234
cmpb $0x2d, %r15b
jne 0x11d7
cmpb $0x0, 0x1(%r14)
je 0x1251
movslq %ebp, %r12
pushq $0x1
popq %r13
leaq 0xe26(%rip), %r14       # 0x200b
movq 0x2dec(%rip), %rbp      # 0x3fd8
cmpq %r12, %r13
jge 0x1240
movq (%rbx,%r13,8), %rdi
movq %r14, %rsi
callq 0x1070
testq %rax, %rax
je 0x122f
movq %rax, %r15
movq %r15, %rdi
callq 0x1080
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x1227
sarl $0x18, %eax
movq (%rbp), %rsi
movl %eax, %edi
callq 0x1060
jmp 0x1205
movq %r15, %rdi
callq 0x1040
incq %r13
jmp 0x11ec
leaq 0xdd2(%rip), %rdi       # 0x200d
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d88(%rip), %rbx      # 0x3fe0
movq 0x2d79(%rip), %r14      # 0x3fd8
movq (%rbx), %rdi
callq 0x1080
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x1240
sarl $0x18, %eax
movq (%r14), %rsi
movl %eax, %edi
callq 0x1060
jmp 0x125f
// File: /workspace/github_c_makefile_star2_O2/tylerneylon[P]APIsWithLua/ch1/loadmodule.c
// Function: main
int main() {
  lua_State *L = luaL_newstate();
  luaL_openlibs(L);
  luaL_dofile(L, "mymodule.lua");
  lua_setglobal(L, "mymodule");
  lua_settop(L, 0);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x12b36
movq %rax, %rbx
movq %rax, %rdi
callq 0x12d5c
leaq 0x199fb(%rip), %rsi     # 0x1e004
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12307
testl %eax, %eax
jne 0x462c
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5864
leaq 0x199de(%rip), %rsi     # 0x1e011
movq %rbx, %rdi
callq 0x5395
movq %rbx, %rdi
xorl %esi, %esi
callq 0x477d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/waveinfo/waveinfo.c
// Function: main
int
main(int argc,char **argv)
    {
    int argIndex = 1;

    char *in;
    WAVE *w;

    argIndex = processOptions(argc,argv);

    if (argc-argIndex == 1)
        {
        in = argv[argIndex];
        }
    else
        {
        printf("usage: waveheader <wave file>\n");
        exit(-1);
        }

    w = readWave(in);

    displayWave(w);

    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movslq %edi, %r13
cmpl $0x2, %r13d
pushq $0x1
popq %rax
cmovgel %edi, %eax
movl %eax, -0x2c(%rbp)
pushq $0x1
popq %r12
leaq 0x1d98(%rip), %r15      # 0x3023
cmpq %r13, %r12
jge 0x12ae
movq (%rbx,%r12,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x12b3
cmpb $0x76, 0x1(%rsi)
je 0x12e3
movq %r15, %rdi
xorl %eax, %eax
callq 0x131c
incq %r12
jmp 0x128b
movl -0x2c(%rbp), %eax
jmp 0x12b6
movl %r12d, %eax
subl %eax, %r14d
cmpl $0x1, %r14d
jne 0x1306
cltq
movq (%rbx,%rax,8), %rdi
callq 0x1b07
movq %rax, %rdi
callq 0x1795
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3dd6(%rip), %rsi      # 0x50c0
movq 0x3dd7(%rip), %rdx      # 0x50c8
leaq 0x1d1c(%rip), %rdi      # 0x3014
xorl %eax, %eax
callq 0x10a0
xorl %edi, %edi
callq 0x1140
leaq 0x1d30(%rip), %rdi      # 0x303d
callq 0x1060
pushq $-0x1
popq %rdi
callq 0x1140
nop
// File: /workspace/github_c_makefile_star2_O2/cyb70289[P]tt/include/tt/common/heap.h
// Function: tt_heap_insert
static inline int tt_heap_insert(struct tt_heap *heap, const void *v)
{
	if (heap->__heaplen == heap->cap)
		return TT_EOVERFLOW;
	heap->num._set(&heap->num, heap_ptr(heap, heap->__heaplen), v);
	heap->__heaplen++;
	heap->_adjust(heap, heap->__heaplen - 1);
	return 0;
}

// Assembly:
movq %rsi, %rdx
movl 0x30(%rdi), %esi
cmpl 0x28(%rdi), %esi
jne 0x14ba
retq
pushq %rbx
movq %rdi, %rbx
imull (%rdi), %esi
addq 0x20(%rdi), %rsi
callq *0x18(%rdi)
movl 0x30(%rbx), %esi
leal 0x1(%rsi), %eax
movl %eax, 0x30(%rbx)
movq 0x40(%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *%rax
nop
// File: /workspace/github_c_makefile_star2_O2/aokad[P]sequeeze/seqtk.c
// Function: stk_reg_destroy
void stk_reg_destroy(reghash_t *h)
{
	khint_t k;
	if (h == 0) return;
	for (k = 0; k < kh_end(h); ++k) {
		if (kh_exist(h, k)) {
			free(kh_val(h, k).a);
			free((char*)kh_key(h, k));
		}
	}
	kh_destroy(reg, h);
}

// Assembly:
testq %rdi, %rdi
je 0x2a1f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x8
popq %r15
xorl %r12d, %r12d
movl (%rbx), %eax
cmpq %rax, %r12
jae 0x2a0f
movq 0x10(%rbx), %rax
movq %r12, %rcx
shrq $0x4, %rcx
movl (%rax,%rcx,4), %eax
movl %r14d, %ecx
andb $0x1e, %cl
shrl %cl, %eax
testb $0x3, %al
jne 0x2a02
movq 0x20(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x2050
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x2050
incq %r12
addl $0x2, %r14d
addq $0x10, %r15
jmp 0x29c7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2a20
retq
// File: /workspace/github_c_makefile_star2_O2/aokad[P]sequeeze/seqtk.c
// Function: kr_rand
krint64_t kr_rand(krand_t *kr)
{
	krint64_t x;
	static const krint64_t mag01[2] = { 0, 0xB5026F5AA96619E9ULL };
    if (kr->mti >= KR_NN) {
		int i;
		if (kr->mti == KR_NN + 1) kr_srand0(5489ULL, kr);
        for (i = 0; i < KR_NN - KR_MM; ++i) {
            x = (kr->mt[i] & KR_UM) | (kr->mt[i+1] & KR_LM);
            kr->mt[i] = kr->mt[i + KR_MM] ^ (x>>1) ^ mag01[(int)(x&1)];
        }
        for (; i < KR_NN - 1; ++i) {
            x = (kr->mt[i] & KR_UM) | (kr->mt[i+1] & KR_LM);
            kr->mt[i] = kr->mt[i + (KR_MM - KR_NN)] ^ (x>>1) ^ mag01[(int)(x&1)];
        }
        x = (kr->mt[KR_NN - 1] & KR_UM) | (kr->mt[0] & KR_LM);
        kr->mt[KR_NN - 1] = kr->mt[KR_MM - 1] ^ (x>>1) ^ mag01[(int)(x&1)];
        kr->mti = 0;
    }
    x = kr->mt[kr->mti++];
    x ^= (x >> 29) & 0x5555555555555555ULL;
    x ^= (x << 17) & 0x71D67FFFEDA60000ULL;
    x ^= (x << 37) & 0xFFF7EEE000000000ULL;
    x ^= (x >> 43);
    return x;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rax
cmpq $0x137, %rax            # imm = 0x137
jle 0x2b43
cmpl $0x139, %eax            # imm = 0x139
jne 0x2ae6
movl $0x1571, %edi           # imm = 0x1571
movq %rbx, %rsi
callq 0x2a78
movq $-0x4e0, %rcx           # imm = 0xFB20
movq $-0x80000000, %rdx      # imm = 0x80000000
leaq 0x6555(%rip), %rax      # 0x9050
testq %rcx, %rcx
je 0x2b4f
movq 0x4e8(%rbx,%rcx), %rsi
andq %rdx, %rsi
movq 0x4f0(%rbx,%rcx), %rdi
movl %edi, %r8d
andl $0x7ffffffe, %r8d       # imm = 0x7FFFFFFE
orq %rsi, %r8
andl $0x1, %edi
movq (%rax,%rdi,8), %rsi
xorq 0x9c8(%rbx,%rcx), %rsi
shrq %r8
xorq %r8, %rsi
movq %rsi, 0x4e8(%rbx,%rcx)
addq $0x8, %rcx
jmp 0x2afb
movq 0x8(%rbx,%rax,8), %rcx
incl %eax
jmp 0x2bdd
xorl %ecx, %ecx
movq $-0x80000000, %rdx      # imm = 0x80000000
cmpq $0x9b, %rcx
je 0x2ba0
movq 0x4e8(%rbx,%rcx,8), %rsi
andq %rdx, %rsi
movq 0x4f0(%rbx,%rcx,8), %rdi
movl %edi, %r8d
andl $0x7ffffffe, %r8d       # imm = 0x7FFFFFFE
orq %rsi, %r8
andl $0x1, %edi
movq (%rax,%rdi,8), %rsi
xorq 0x8(%rbx,%rcx,8), %rsi
shrq %r8
xorq %r8, %rsi
movq %rsi, 0x4e8(%rbx,%rcx,8)
incq %rcx
jmp 0x2b58
movq $-0x80000000, %rdx      # imm = 0x80000000
andq 0x9c0(%rbx), %rdx
movq 0x8(%rbx), %rcx
movl %ecx, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
orq %rdx, %rsi
movl %ecx, %edx
andl $0x1, %edx
movq (%rax,%rdx,8), %rax
xorq 0x4e0(%rbx), %rax
shrq %rsi
xorq %rsi, %rax
movq %rax, 0x9c0(%rbx)
pushq $0x1
popq %rax
movl %eax, (%rbx)
movq %rcx, %rax
shrq $0x1d, %rax
movabsq $0x555555555, %rdx      # imm = 0x555555555
andq %rax, %rdx
xorq %rcx, %rdx
movq %rdx, %rax
shlq $0x11, %rax
movabsq $0x71d67fffeda60000, %rcx # imm = 0x71D67FFFEDA60000
andq %rax, %rcx
xorq %rdx, %rcx
movl %ecx, %edx
andl $0x7ffbf77, %edx        # imm = 0x7FFBF77
shlq $0x25, %rdx
xorq %rcx, %rdx
movq %rdx, %rax
shrq $0x2b, %rax
xorq %rdx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/aokad[P]sequeeze/seqtk.c
// Function: stk_listhet
int stk_listhet(int argc, char *argv[])
{
	gzFile fp;
	kseq_t *seq;
	int i, l;
	if (argc == 1) {
		fprintf(stderr, "Usage: seqtk listhet <in.fa>\n");
		return 1;
	}
	fp = (strcmp(argv[1], "-") == 0)? gzdopen(fileno(stdin), "r") : gzopen(argv[1], "r");
	if (fp == 0) {
		fprintf(stderr, "[E::%s] failed to open the input file/stream.\n", __func__);
		return 1;
	}
	seq = kseq_init(fp);
	while ((l = kseq_read(seq)) >= 0) {
		for (i = 0; i < l; ++i) {
			int b = seq->seq.s[i];
			if (bitcnt_table[seq_nt16_table[b]] == 2)
				printf("%s\t%d\t%c\n", seq->name.s, i+1, b);
		}
	}
	kseq_destroy(seq);
	gzclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x1, %edi
je 0x4e3c
movq 0x8(%rsi), %rdi
cmpb $0x2d, (%rdi)
jne 0x4d79
cmpb $0x0, 0x1(%rdi)
je 0x4e1a
leaq 0x4428(%rip), %rsi      # 0x91a8
callq 0x2220
testq %rax, %rax
je 0x4e5a
movq %rax, (%rsp)
movq %rax, %rdi
callq 0x3102
movq %rax, %r14
leaq 0x93cc(%rip), %r13      # 0xe170
leaq 0x95f5(%rip), %rbp      # 0xe3a0
leaq 0x4c56(%rip), %r15      # 0x9a08
movq %r14, %rdi
callq 0x312e
testl %eax, %eax
js 0x4df8
movl %eax, %ebx
xorl %r12d, %r12d
cmpq %rbx, %r12
je 0x4db2
movq 0x40(%r14), %rax
movsbq (%rax,%r12), %rcx
movzbl (%rcx,%r13), %eax
cmpl $0x2, (%rbp,%rax,4)
jne 0x4df3
movq 0x10(%r14), %rsi
incq %r12
movq %r15, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x20f0
jmp 0x4dc3
incq %r12
jmp 0x4dc3
movq %r14, %rdi
callq 0x3329
movq (%rsp), %rdi
callq 0x2040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x91a7(%rip), %rax      # 0xdfc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x4378(%rip), %rsi      # 0x91a8
movl %eax, %edi
callq 0x20b0
jmp 0x4d85
movq 0x91b5(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x4b91(%rip), %rdi      # 0x99de
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x2260
jmp 0x4e79
movq 0x9197(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x4536(%rip), %rsi      # 0x93a1
leaq 0x4b8a(%rip), %rdx      # 0x99fc
xorl %eax, %eax
callq 0x2190
pushq $0x1
popq %rax
jmp 0x4e0b
// File: /workspace/github_c_makefile_star2_O2/aokad[P]sequeeze/seqtk.c
// Function: print_seq
static void print_seq(FILE *fpout, const kseq_t *ks, int begin, int end)
{
	int i;
	if (begin >= end) return; // FIXME: why may this happen? Understand it!
	fprintf(fpout, "%c%s:%d-%d", ks->qual.l? '@' : '>', ks->name.s, begin+1, end);
	for (i = begin; i < end && i < ks->seq.l; ++i) {
		if ((i - begin)%60 == 0) fputc('\n', fpout);
		fputc(ks->seq.s[i], fpout);
	}
	fputc('\n', fpout);
	if (ks->qual.l == 0) return;
	fputs("+\n", fpout);
	for (i = begin; i < end && i < ks->qual.l; ++i) {
		if ((i - begin)%60 == 0) fputc('\n', fpout);
		fputc(ks->qual.s[i], fpout);
	}
	fputc('\n', fpout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl %ecx, %edx
jge 0x525c
movl %ecx, %r13d
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x0, 0x48(%rsi)
setne %al
leal 0x3e(,%rax,2), %edx
movq 0x10(%rsi), %rcx
leal 0x1(%r12), %r8d
leaq 0x53c4(%rip), %rsi      # 0xa570
xorl %ebp, %ebp
movl %r13d, %r9d
xorl %eax, %eax
callq 0x2190
movslq %r12d, %r15
movslq %r13d, %r13
movq %r15, %r12
cmpq %r13, %r12
jge 0x51fb
cmpq %r12, 0x30(%r14)
jbe 0x51fb
movl %ebp, %eax
cltd
pushq $0x3c
popq %rcx
idivl %ecx
testl %edx, %edx
jne 0x51e3
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x2140
movq 0x40(%r14), %rax
movsbl (%rax,%r12), %edi
movq %rbx, %rsi
callq 0x2140
incq %r12
incl %ebp
jmp 0x51c1
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x2140
cmpq $0x0, 0x48(%r14)
je 0x525c
leaq 0x5367(%rip), %rdi      # 0xa57b
movq %rbx, %rsi
callq 0x2110
xorl %ebp, %ebp
pushq $0xa
popq %r12
cmpq %r13, %r15
jge 0x526b
cmpq %r15, 0x48(%r14)
jbe 0x526b
movl %ebp, %eax
cltd
pushq $0x3c
popq %rcx
idivl %ecx
testl %edx, %edx
jne 0x5244
movl %r12d, %edi
movq %rbx, %rsi
callq 0x2140
movq 0x58(%r14), %rax
movsbl (%rax,%r15), %edi
movq %rbx, %rsi
callq 0x2140
incq %r15
incl %ebp
jmp 0x5222
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2140
// File: /workspace/github_c_makefile_star2_O2/aokad[P]sequeeze/seqtk.c
// Function: stk_hrun
int stk_hrun(int argc, char *argv[])
{
	gzFile fp;
	kseq_t *ks;
	int min_len = 7, l = 0, c = 0, beg = 0, i;
	if (argc == optind) {
		fprintf(stderr, "Usage: seqtk hrun <in.fa> [minLen=%d]\n", min_len);
		return 1;
	}
	if (argc == optind + 2) min_len = atoi(argv[optind+1]);
	fp = (strcmp(argv[optind], "-") == 0)? gzdopen(fileno(stdin), "r") : gzopen(argv[optind], "r");
	if (fp == 0) {
		fprintf(stderr, "[E::%s] failed to open the input file/stream.\n", __func__);
		return 1;
	}
	ks = kseq_init(fp);
	while (kseq_read(ks) >= 0) {
		c = ks->seq.s[0]; l = 1; beg = 0;
		for (i = 1; i < ks->seq.l; ++i) {
			if (ks->seq.s[i] != c) {
				if (l >= min_len) printf("%s\t%d\t%d\t%c\n", ks->name.s, beg, beg + l, c);
				c = ks->seq.s[i]; l = 1; beg = i;
			} else ++l;
		}
	}
	if (l >= min_len) printf("%s\t%d\t%d\t%c\n", ks->name.s, beg, beg + l, c);
	kseq_destroy(ks);
	gzclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x8d37(%rip), %rax      # 0xdfd0
movslq (%rax), %rbx
cmpl %edi, %ebx
je 0x53e7
movq %rsi, %r14
leal 0x2(%rbx), %eax
cmpl %edi, %eax
jne 0x52ba
movq 0x8(%r14,%rbx,8), %rdi
callq 0x2250
jmp 0x52bd
pushq $0x7
popq %rax
movl %eax, 0x4(%rsp)
movq (%r14,%rbx,8), %rdi
cmpb $0x2d, (%rdi)
jne 0x52d4
cmpb $0x0, 0x1(%rdi)
je 0x53c5
leaq 0x3ecd(%rip), %rsi      # 0x91a8
callq 0x2220
testq %rax, %rax
je 0x5404
movq %rax, 0x10(%rsp)
movq %rax, %rdi
callq 0x3102
movq %rax, %rbx
xorl %r12d, %r12d
xorl %ebp, %ebp
xorl %r14d, %r14d
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x312e
testl %eax, %eax
js 0x537d
movq 0x30(%rbx), %r13
movq 0x40(%rbx), %r15
movsbl (%r15), %ebp
xorl %r14d, %r14d
pushq $0x1
popq %rbx
pushq $0x1
popq %r12
cmpq %rbx, %r13
jbe 0x5376
movsbl (%r15,%rbx), %eax
cmpl %eax, %ebp
jne 0x533b
incl %r12d
jmp 0x5371
cmpl 0x4(%rsp), %r12d
jl 0x5365
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
addl %r14d, %r12d
leaq 0x47ba(%rip), %rdi      # 0x9b0f
movl %r14d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x20f0
movsbl (%r15,%rbx), %ebp
pushq $0x1
popq %r12
movl %ebx, %r14d
incq %rbx
jmp 0x5328
movq 0x8(%rsp), %rbx
jmp 0x5306
cmpl 0x4(%rsp), %r12d
jl 0x53a2
movq 0x10(%rbx), %rsi
addl %r14d, %r12d
leaq 0x477d(%rip), %rdi      # 0x9b0f
movl %r14d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x20f0
movq %rbx, %rdi
callq 0x3329
movq 0x10(%rsp), %rdi
callq 0x2040
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8bfc(%rip), %rax      # 0xdfc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x3dcd(%rip), %rsi      # 0x91a8
movl %eax, %edi
callq 0x20b0
jmp 0x52e0
movq 0x8c0a(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x46e7(%rip), %rsi      # 0x9adf
pushq $0x7
popq %rdx
xorl %eax, %eax
callq 0x2190
jmp 0x5423
movq 0x8bed(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x3f8c(%rip), %rsi      # 0x93a1
leaq 0x46ea(%rip), %rdx      # 0x9b06
xorl %eax, %eax
callq 0x2190
pushq $0x1
popq %rax
jmp 0x53b6
// File: /workspace/github_c_makefile_star2_O2/aokad[P]sequeeze/seqtk.c
// Function: cpy_kseq
static void cpy_kseq(kseq_t *dst, const kseq_t *src)
{
	cpy_kstr(&dst->name, &src->name);
	cpy_kstr(&dst->seq,  &src->seq);
	cpy_kstr(&dst->qual, &src->qual);
	cpy_kstr(&dst->comment, &src->comment);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8be1
leaq 0x30(%r14), %rdi
leaq 0x30(%rbx), %rsi
callq 0x8be1
leaq 0x48(%r14), %rdi
leaq 0x48(%rbx), %rsi
callq 0x8be1
addq $0x18, %r14
addq $0x18, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8be1
// File: /workspace/github_c_makefile_star2_O2/aokad[P]sequeeze/seqtk.c
// Function: stk_mergepe
int stk_mergepe(int argc, char *argv[])
{
	gzFile fp1, fp2;
	kseq_t *seq[2];

	if (argc < 3) {
		fprintf(stderr, "Usage: seqtk mergepe <in1.fq> <in2.fq>\n");
		return 1;
	}
	fp1 = strcmp(argv[1], "-")? gzopen(argv[1], "r") : gzdopen(fileno(stdin), "r");
	fp2 = strcmp(argv[2], "-")? gzopen(argv[2], "r") : gzdopen(fileno(stdin), "r");
	if (fp1 == 0 || fp2 == 0) {
		fprintf(stderr, "[E::%s] failed to open the input file/stream.\n", __func__);
		return 1;
	}
	seq[0] = kseq_init(fp1);
	seq[1] = kseq_init(fp2);
	while (kseq_read(seq[0]) >= 0) {
		if (kseq_read(seq[1]) < 0) {
			fprintf(stderr, "[W::%s] the 2nd file has fewer records.\n", __func__);
			break;
		}
		stk_printseq(seq[0], 0);
		stk_printseq(seq[1], 0);
	}
	if (kseq_read(seq[1]) >= 0)
		fprintf(stderr, "[W::%s] the 1st file has fewer records.\n", __func__);
	kseq_destroy(seq[0]); gzclose(fp1);
	kseq_destroy(seq[1]); gzclose(fp2);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jle 0x6d42
movq %rsi, %r14
movq 0x8(%rsi), %rdi
cmpb $0x2d, (%rdi)
jne 0x6c6f
cmpb $0x0, 0x1(%rdi)
je 0x6cfe
leaq 0x2532(%rip), %rsi      # 0x91a8
callq 0x2220
movq %rax, %rbx
movq 0x10(%r14), %rdi
cmpb $0x2d, (%rdi)
jne 0x6c91
cmpb $0x0, 0x1(%rdi)
je 0x6d20
leaq 0x2510(%rip), %rsi      # 0x91a8
callq 0x2220
movq %rax, %r14
testq %rbx, %rbx
je 0x6d60
testq %r14, %r14
je 0x6d60
movq %rbx, %rdi
callq 0x3102
movq %rax, %r12
movq %r14, %rdi
callq 0x3102
movq %rax, %r15
movq %r12, %rdi
callq 0x312e
testl %eax, %eax
js 0x6da3
movq %r15, %rdi
callq 0x312e
testl %eax, %eax
js 0x6d84
movq %r12, %rdi
xorl %esi, %esi
callq 0x5e07
movq %r15, %rdi
xorl %esi, %esi
callq 0x5e07
jmp 0x6cc8
movq 0x72c3(%rip), %rax      # 0xdfc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x2494(%rip), %rsi      # 0x91a8
movl %eax, %edi
callq 0x20b0
jmp 0x6c7b
movq 0x72a1(%rip), %rax      # 0xdfc8
movq (%rax), %rdi
callq 0x21b0
leaq 0x2472(%rip), %rsi      # 0x91a8
movl %eax, %edi
callq 0x20b0
jmp 0x6c9d
movq 0x72af(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x3518(%rip), %rdi      # 0xa26b
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
callq 0x2260
jmp 0x6d7f
movq 0x7291(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x2630(%rip), %rsi      # 0x93a1
leaq 0x351b(%rip), %rdx      # 0xa293
xorl %eax, %eax
callq 0x2190
pushq $0x1
popq %rax
jmp 0x6dd1
movq 0x726d(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x350a(%rip), %rsi      # 0xa29f
leaq 0x34f7(%rip), %rdx      # 0xa293
xorl %eax, %eax
callq 0x2190
movq %r15, %rdi
callq 0x312e
testl %eax, %eax
jns 0x6ddd
movq %r12, %rdi
callq 0x3329
movq %rbx, %rdi
callq 0x2040
movq %r15, %rdi
callq 0x3329
movq %r14, %rdi
callq 0x2040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x7214(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x34da(%rip), %rsi      # 0xa2c8
leaq 0x349e(%rip), %rdx      # 0xa293
xorl %eax, %eax
callq 0x2190
jmp 0x6daf
// File: /workspace/github_c_makefile_star2_O2/aokad[P]sequeeze/seqtk.c
// Function: stk_printseq_renamed
static inline void stk_printseq_renamed(const kseq_t *s, int line_len, const char *prefix, int64_t n)
{
	putchar(s->qual.l? '@' : '>');
	if (n >= 0) {
		if (prefix) fputs(prefix, stdout);
		printf("%lld", (long long)n);
	} else fputs(s->name.s, stdout);
	if (s->comment.l) {
	//	putchar(' '); fputs(s->comment.s, stdout);
	}
	stk_printstr(&s->seq, line_len);
	if (s->qual.l) {
		putchar('+');
		stk_printstr(&s->qual, line_len);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
xorl %eax, %eax
cmpq $0x0, 0x48(%rdi)
setne %al
leal 0x3e(,%rax,2), %edi
callq 0x2060
testq %r15, %r15
js 0x723c
testq %r12, %r12
je 0x7229
movq 0x6da2(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
movq %r12, %rdi
callq 0x2110
leaq 0x3353(%rip), %rdi      # 0xa583
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
jmp 0x724f
movq 0x10(%r14), %rdi
movq 0x6d79(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x2110
leaq 0x30(%r14), %rdi
movl %ebx, %esi
callq 0x8c68
cmpq $0x0, 0x48(%r14)
je 0x7282
addq $0x48, %r14
pushq $0x2b
popq %rdi
callq 0x2060
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8c68
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/aokad[P]sequeeze/seqtk.c
// Function: fqc_aux
static void fqc_aux(posstat_t *p, int pos, int64_t allq[94], double perr[94], int qthres)
{
	int k;
	int64_t sum = 0, qsum = 0, sum_low = 0;
	double psum = 0;
	if (pos <= 0) printf("ALL");
	else printf("%d", pos);
	for (k = 0; k <= 4; ++k) sum += p->b[k];
	printf("\t%lld", (long long)sum);
	for (k = 0; k <= 4; ++k)
		printf("\t%.1f", 100. * p->b[k] / sum);
	for (k = 0; k <= 93; ++k) {
		qsum += p->q[k] * k, psum += p->q[k] * perr[k];
		if (k < qthres) sum_low += p->q[k];
	}
	printf("\t%.1f\t%.1f", (double)qsum/sum, -4.343*log((psum+1e-6)/(sum+1e-6)));
	if (qthres <= 0) {
		for (k = 0; k <= 93; ++k)
			if (allq[k] > 0) printf("\t%.2f", 100. * p->q[k] / sum);
	} else printf("\t%.1f\t%.1f", 100. * sum_low / sum, 100. * (sum - sum_low) / sum);
	putchar('\n');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r14
testl %esi, %esi
jle 0x79e7
leaq 0x1a91(%rip), %rdi      # 0x946f
xorl %eax, %eax
callq 0x20f0
jmp 0x79f5
leaq 0x2b90(%rip), %rdi      # 0xa57e
xorl %eax, %eax
callq 0x20f0
xorl %eax, %eax
xorl %r15d, %r15d
cmpq $0x5, %rax
je 0x7a0d
addq 0x2f0(%r14,%rax,8), %r15
incq %rax
jmp 0x79fa
movl %ebp, 0xc(%rsp)
leaq 0x2b6a(%rip), %rdi      # 0xa582
xorl %ebp, %ebp
movq %r15, %rsi
xorl %eax, %eax
callq 0x20f0
cvtsi2sd %r15, %xmm0
movsd %xmm0, (%rsp)
leaq 0x2b58(%rip), %r13      # 0xa58d
cmpq $0x5, %rbp
je 0x7a61
cvtsi2sdq 0x2f0(%r14,%rbp,8), %xmm0
mulsd 0x166b(%rip), %xmm0     # 0x90b8
divsd (%rsp), %xmm0
movq %r13, %rdi
movb $0x1, %al
callq 0x20f0
incq %rbp
jmp 0x7a35
movl 0xc(%rsp), %ebp
movslq %ebp, %rax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
xorl %r13d, %r13d
movsd (%rsp), %xmm2
cmpq $0x5e, %rsi
je 0x7aac
movq (%r14,%rsi,8), %rdi
movq %rdi, %r8
imulq %rsi, %r8
addq %r8, %rdx
cvtsi2sd %rdi, %xmm1
mulsd (%r12,%rsi,8), %xmm1
addsd %xmm1, %xmm0
cmpq %rax, %rsi
cmovgeq %rcx, %rdi
addq %rdi, %r13
incq %rsi
jmp 0x7a7a
cvtsi2sd %rdx, %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x15fd(%rip), %xmm1     # 0x90c0
addsd %xmm1, %xmm0
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x2130
movapd %xmm0, %xmm1
mulsd 0x15e8(%rip), %xmm1     # 0x90c8
leaq 0x2aa1(%rip), %rdi      # 0xa588
movsd 0x10(%rsp), %xmm0
movb $0x2, %al
callq 0x20f0
testl %ebp, %ebp
jle 0x7b46
cvtsi2sd %r13, %xmm0
movsd 0x15b3(%rip), %xmm2     # 0x90b8
mulsd %xmm2, %xmm0
movsd (%rsp), %xmm3
divsd %xmm3, %xmm0
subq %r13, %r15
cvtsi2sd %r15, %xmm1
mulsd %xmm2, %xmm1
divsd %xmm3, %xmm1
leaq 0x2a5f(%rip), %rdi      # 0xa588
movb $0x2, %al
callq 0x20f0
pushq $0xa
popq %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2060
xorl %r12d, %r12d
leaq 0x2a43(%rip), %r15      # 0xa593
cmpq $0x5e, %r12
je 0x7b30
cmpq $0x0, (%rbx,%r12,8)
jle 0x7b7a
cvtsi2sdq (%r14,%r12,8), %xmm0
mulsd 0x154d(%rip), %xmm0     # 0x90b8
divsd (%rsp), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x20f0
incq %r12
jmp 0x7b50
// File: /workspace/github_c_makefile_star2_O2/aokad[P]sequeeze/seqtk.c
// Function: cpy_kstr
static void cpy_kstr(kstring_t *dst, const kstring_t *src)
{
	if (src->l == 0) return;
	if (src->l + 1 > dst->m) {
		dst->m = src->l + 1;
		kroundup32(dst->m);
		dst->s = realloc(dst->s, dst->m);
	}
	dst->l = src->l;
	memcpy(dst->s, src->s, src->l + 1);
}

// Assembly:
movq (%rsi), %rax
testq %rax, %rax
je 0x8c4a
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rax), %rcx
cmpq 0x8(%rdi), %rcx
jbe 0x8c4b
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rsi
shrq $0x10, %rsi
orq %rax, %rsi
incq %rsi
movq %rsi, 0x8(%r14)
movq 0x10(%r14), %rdi
callq 0x2200
movq %rax, %rdi
movq %rax, 0x10(%r14)
movq (%rbx), %rax
jmp 0x8c4f
retq
movq 0x10(%r14), %rdi
movq %rax, (%r14)
movq (%rbx), %rdx
movq 0x10(%rbx), %rsi
incq %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
// File: /workspace/github_c_makefile_star2_O2/aokad[P]sequeeze/seqtk.c
// Function: stk_printstr
static void stk_printstr(const kstring_t *s, unsigned line_len)
{
	if (line_len != UINT_MAX && line_len != 0) {
		int i, rest = s->l;
		for (i = 0; i < s->l; i += line_len, rest -= line_len) {
			putchar('\n');
			if (rest > line_len) fwrite(s->s + i, 1, line_len, stdout);
			else fwrite(s->s + i, 1, rest, stdout);
		}
		putchar('\n');
	} else {
		putchar('\n');
		puts(s->s);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leal -0x1(%r14), %eax
cmpl $-0x3, %eax
ja 0x8cd8
movq (%rbx), %rbp
movl %r14d, %r12d
xorl %r13d, %r13d
movl %ebp, %r15d
movslq %r13d, %r13
pushq $0xa
popq %rdi
callq 0x2060
cmpq %r13, %rbp
jbe 0x8cc9
movq 0x10(%rbx), %rdi
addq %r13, %rdi
movslq %r15d, %rdx
subl %r14d, %r15d
cmovaq %r12, %rdx
movq 0x530a(%rip), %rax      # 0xdfc0
movq (%rax), %rcx
pushq $0x1
popq %rsi
callq 0x2260
addl %r14d, %r13d
movq (%rbx), %rbp
jmp 0x8c8e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0xa
popq %rdi
callq 0x2060
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2080
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/5-Signal/pause.c
// Function: main
int main(void)
{
	signal(SIGINT, sig_handler);
	pause();
	printf("Ctrl+C received. Bye!\n");
	return 0;
}

// Assembly:
pushq %rax
leaq -0x1a(%rip), %rsi       # 0x115c
pushq $0x2
popq %rdi
callq 0x1040
callq 0x1050
leaq 0xe8a(%rip), %rdi       # 0x2014
callq 0x1030
xorl %eax, %eax
popq %rcx
retq