LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/qlts.cpp
// Function: QltSave::~QltSave()
QltSave::~QltSave() {
    rcoder.done();
    if (not conf.quiet) {
        if (m_last.extra_hi_qlt) {
            conf.set_info("qlt.extra.hi", m_last.extra_hi_qlt);
        }
    }

    delete [] ranger;
    delete    filer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x310(%rdi), %rbx
movq %rbx, %rdi
callq 0x2962
leaq 0xc057(%rip), %rax      # 0x11350
cmpb $0x0, 0xe(%rax)
jne 0x531e
movl 0x348(%r14), %edx
testq %rdx, %rdx
je 0x531e
leaq 0xc03e(%rip), %rdi      # 0x11350
leaq 0x4ba7(%rip), %rsi      # 0x9ec0
callq 0x309e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x532b
callq 0x2260
movq 0x340(%r14), %r14
testq %r14, %r14
je 0x533f
movq %r14, %rdi
callq 0x411a
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28d4
movq %rax, %rdi
callq 0x2957
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/qlts.cpp
// Function: QltSave::save_1(unsigned char const*, unsigned long)
void QltSave::save_1(const UCHAR* buf, size_t size) {
    UINT32 last = 0;
    for (const UCHAR* p = buf ; p < buf + size; p++) {
        UCHAR b = UCHAR(*p-'!');

        PREFETCH(ranger + last);
        likely_if(b < LAST_QLT)
            ranger[last].put(&rcoder, b);
        else {
            ranger[last].put(&rcoder, LAST_QLT);
            exranger.put(&rcoder, b);
            m_last.extra_hi_qlt ++ ;
        }
        last = calc_last_1(last, b);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq %rsi, %rbx
leaq 0x310(%rdi), %r12
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
cmpq %rbx, %r14
jae 0x5408
movb (%r14), %al
addb $-0x21, %al
movq (%r15), %rcx
movl %r13d, %edx
imulq $0xc7, %rdx, %rdx
leaq (%rcx,%rdx), %rdi
prefetcht0 (%rcx,%rdx)
movzbl %al, %ebp
movq %r12, %rsi
cmpb $0x3e, %al
ja 0x53e9
movl %ebp, %edx
callq 0x59b2
andl $0x3f, %r13d
shll $0x6, %r13d
orl %ebp, %r13d
incq %r14
jmp 0x53a9
pushq $0x3f
popq %rdx
callq 0x59b2
movq (%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x28e4
incl 0x348(%r15)
jmp 0x53d9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/qlts.cpp
// Function: QltSave::save_2(unsigned char const*, unsigned long)
void QltSave::save_2(const UCHAR* buf, size_t size) {
    UINT32 last = 0;
    for (const UCHAR* p = buf ; p < buf + size; p++) {
        UCHAR b = UCHAR(*p-'!');

        PREFETCH(ranger + last);
        likely_if(b < LAST_QLT)
            ranger[last].put(&rcoder, b);
        else {
            ranger[last].put(&rcoder, LAST_QLT);
            exranger.put(&rcoder, b);
            m_last.extra_hi_qlt ++ ;
        }
        last = calc_last_2(last, b);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq %rsi, %rbx
leaq 0x310(%rdi), %r12
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
cmpq %rbx, %r14
jae 0x54a0
movb (%r14), %al
addb $-0x21, %al
movq (%r15), %rcx
movl %r13d, %edx
imulq $0xc7, %rdx, %rdx
leaq (%rcx,%rdx), %rdi
prefetcht0 (%rcx,%rdx)
movzbl %al, %ebp
movq %r12, %rsi
cmpb $0x3e, %al
ja 0x5481
movl %ebp, %edx
callq 0x59b2
shll $0x6, %r13d
movzwl %r13w, %r13d
orl %ebp, %r13d
incq %r14
jmp 0x5441
pushq $0x3f
popq %rdx
callq 0x59b2
movq (%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x28e4
incl 0x348(%r15)
jmp 0x5471
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/qlts.cpp
// Function: QltSave::save_3(unsigned char const*, unsigned long)
void QltSave::save_3(const UCHAR* buf, size_t size) {
    UINT32 last = 0;
    UINT32 delta = 5;
    UCHAR q1 = 0, q2 = 0;
    UINT32 di = 0;

    for (const UCHAR* p = buf ; p < buf + size; p++) {
        UCHAR b = UCHAR(*p-'!');

        PREFETCH(ranger + last);
        likely_if(b < LAST_QLT)
            ranger[last].put(&rcoder, b);
        else {
            // croak("This qlt rate makes no sence: '%c' (record %d, pos %d)", *p, g_record_count, p-buf);
            ranger[last].put(&rcoder, LAST_QLT);
            exranger.put(&rcoder, b);
            m_last.extra_hi_qlt ++ ;
        }

        if (++ di & 1) {
            last = calc_last_delta(delta, b, q1, q2);
            q2 = b;
        }
        else {
            last = calc_last_delta(delta, b, q2, q1);
            q1 = b;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
leaq 0x4(%rsp), %rax
movl $0x5, (%rax)
movq %rsi, 0x20(%rsp)
addq %rsi, %rbx
leaq 0x310(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x8(%rdi), %rax
movq %rax, 0x18(%rsp)
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %r14d, %r14d
xorl %eax, %eax
movq 0x20(%rsp), %rcx
addq %r12, %rcx
cmpq %rbx, %rcx
jae 0x559d
movb (%rcx), %r15b
addb $-0x21, %r15b
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movl %eax, %eax
imulq $0xc7, %rax, %rax
leaq (%rcx,%rax), %rdi
prefetcht0 (%rcx,%rax)
movzbl %r15b, %ebp
cmpb $0x3e, %r15b
ja 0x5572
movq 0x8(%rsp), %rsi
movl %ebp, %edx
callq 0x59b2
movzbl %r13b, %ecx
movzbl %r14b, %eax
leaq 0x4(%rsp), %rdi
movl %ebp, %esi
testb $0x1, %r12b
jne 0x5563
movl %ecx, %edx
movl %eax, %ecx
callq 0x5a48
movl %r15d, %r14d
jmp 0x556d
movl %eax, %edx
callq 0x5a48
movl %r15d, %r13d
incq %r12
jmp 0x54f9
movq 0x8(%rsp), %rsi
pushq $0x3f
popq %rdx
callq 0x59b2
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %ebp, %edx
callq 0x28e4
movq 0x10(%rsp), %rax
incl 0x348(%rax)
jmp 0x5540
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/qlts.cpp
// Function: QltLoad::QltLoad()
QltLoad::QltLoad() {
    filer = new FilerLoad("qlt", &m_valid);
    ranger = new Log64Ranger[ranger_cnt()];

    rcoder.init(filer);
    // range_init();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rdi
movl $0x307, %edx            # imm = 0x307
xorl %esi, %esi
callq 0x2130
pxor %xmm0, %xmm0
movdqu %xmm0, 0x328(%rbx)
movl $0x4040, %edi           # imm = 0x4040
callq 0x21e0
movq %rax, %r14
leaq 0x338(%rbx), %rdx
leaq 0x4a9f(%rip), %rsi      # 0xa08c
movq %rax, %rdi
callq 0x435a
movq %r14, 0x340(%rbx)
leaq 0xbd4d(%rip), %rax      # 0x11350
movl 0x4(%rax), %ebp
cmpl $0x1, %ebp
movl $0xc7000, %eax          # imm = 0xC7000
movl $0xc70000, %edi         # imm = 0xC70000
cmoveq %rax, %rdi
callq 0x2040
cmpl $0x1, %ebp
movl $0x1000, %edx           # imm = 0x1000
movl $0x10000, %ecx          # imm = 0x10000
cmoveq %rdx, %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movq %rax, %rdx
subq $-0x80, %rdx
xorl %esi, %esi
movdqa 0x4854(%rip), %xmm1     # 0x9ea0
movdqa 0x485c(%rip), %xmm2     # 0x9eb0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rsi, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0x569c
andq $0x0, (%rdx)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x56b3
andq $0x0, 0xc7(%rdx)
addq $0x2, %rsi
addq $0x18e, %rdx            # imm = 0x18E
cmpq %rsi, %rcx
jne 0x565c
movq %rax, (%rbx)
leaq 0x310(%rbx), %rdi
movq %r14, %rsi
callq 0x2996
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21f0
jmp 0x56f5
movq %rax, %r15
addq $0x310, %rbx            # imm = 0x310
movq %rbx, %rdi
callq 0x28d4
movq %r15, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/qlts.cpp
// Function: QltLoad::load_1(unsigned char*, unsigned long)
UINT32 QltLoad::load_1(UCHAR* buf, const size_t size) {

    UINT32 last = 0 ;

    for (UCHAR* p = buf; p < buf + size ; p++) {
        UCHAR b = ranger[last].get(&rcoder);

        rarely_if(b == LAST_QLT)
            b = exranger.get(&rcoder);

        *p = UCHAR('!' + b);

        last = calc_last_1(last, b);
    }
    buf[size] = '\n';
    return m_valid ? size : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq (%rsi,%rdx), %rbp
leaq 0x310(%rdi), %r12
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
cmpq %rbp, %r15
jae 0x57fa
movl %r13d, %eax
imulq $0xc7, %rax, %rdi
addq (%r14), %rdi
movq %r12, %rsi
callq 0x5a90
movzbl %al, %ecx
cmpw $0x3f, %cx
je 0x57e9
addb $0x21, %al
movb %al, (%r15)
movzwl %cx, %eax
andl $0x3f, %r13d
shll $0x6, %r13d
orl %eax, %r13d
incq %r15
jmp 0x57ae
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x29da
movzbl %al, %ecx
jmp 0x57d1
movb $0xa, (%rbp)
xorl %eax, %eax
cmpb $0x0, 0x338(%r14)
cmovnel %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/qlts.cpp
// Function: QltLoad::load_2(unsigned char*, unsigned long)
UINT32 QltLoad::load_2(UCHAR* buf, const size_t size) {

    UINT32 last = 0 ;
    for (UCHAR* p = buf; p < buf + size ; p++) {
        PREFETCH(ranger + last);
        UCHAR b = ranger[last].get(&rcoder);

        rarely_if(b == LAST_QLT)
            b = exranger.get(&rcoder);

        *p = UCHAR('!' + b);

        last = calc_last_2(last, b);
    }
    buf[size] = '\n';
    return m_valid ? size : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq (%rsi,%rdx), %rbp
leaq 0x310(%rdi), %r12
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
cmpq %rbp, %r15
jae 0x5898
movq (%r14), %rax
movl %r13d, %ecx
imulq $0xc7, %rcx, %rcx
leaq (%rax,%rcx), %rdi
prefetcht0 (%rax,%rcx)
movq %r12, %rsi
callq 0x5a90
movzbl %al, %ecx
cmpw $0x3f, %cx
je 0x5887
addb $0x21, %al
movb %al, (%r15)
movzwl %cx, %eax
shll $0x6, %r13d
movzwl %r13w, %r13d
orl %eax, %r13d
incq %r15
jmp 0x5844
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x29da
movzbl %al, %ecx
jmp 0x586f
movb $0xa, (%rbp)
xorl %eax, %eax
cmpb $0x0, 0x338(%r14)
cmovnel %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/qlts.cpp
// Function: QltLoad::load_3(unsigned char*, unsigned long)
UINT32 QltLoad::load_3(UCHAR* buf, const size_t size) {

    UINT32 last = 0 ;
    UINT32 delta = 5;
    UCHAR  q1 = 0, q2 = 0;
    UINT32 di = 0;

    for (UCHAR* p = buf; p < buf + size ; p++) {
        PREFETCH(ranger + last);
        UCHAR b = ranger[last].get(&rcoder);

        rarely_if(b == LAST_QLT)
            // croak("extra high qlt. Record %d, pos %d", g_record_count, p-buf);
            b = exranger.get(&rcoder);
        // likely_if(b < LAST_QLT)
        //     *p = UCHAR('!' + b);
        // else {
        //     b = exranger.get(&rcoder);
        //     *p = UCHAR('!' + b);
        // }
        *p = UCHAR('!' + b);

        if (++di & 1) {
            last = calc_last_delta(delta, b, q1, q2);
            q2 = b;
        }
        else {
            last = calc_last_delta(delta, b, q2, q1);
            q1 = b;
        }
    }
    buf[size] = '\n';
    // buf[size+1] = 0;
    // printf("%llu: %s", g_record_count, buf);
    return m_valid ? size : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0xc(%rsp), %rax
movl $0x5, (%rax)
movq %rdx, 0x28(%rsp)
movq %rsi, 0x30(%rsp)
leaq (%rsi,%rdx), %rbx
leaq 0x310(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
leaq 0x8(%rdi), %rax
movq %rax, 0x20(%rsp)
xorl %r12d, %r12d
xorl %eax, %eax
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x30(%rsp), %rcx
leaq (%rcx,%r12), %r14
cmpq %rbx, %r14
jae 0x598d
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movl %eax, %eax
imulq $0xc7, %rax, %rax
leaq (%rcx,%rax), %rdi
prefetcht0 (%rcx,%rax)
movq 0x10(%rsp), %rsi
callq 0x5a90
movl %eax, %ebp
cmpb $0x3f, %bpl
je 0x597a
leal 0x21(%rbp), %eax
movb %al, (%r14)
movzbl %bpl, %esi
movzbl %r13b, %ecx
movzbl %r15b, %eax
leaq 0xc(%rsp), %rdi
testb $0x1, %r12b
jne 0x5965
movl %ecx, %edx
movl %eax, %ecx
callq 0x5a48
jmp 0x5972
movl %eax, %edx
callq 0x5a48
movl %ebp, %r13d
movl %r15d, %ebp
incq %r12
movl %ebp, %r15d
jmp 0x5904
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x29da
movl %eax, %ebp
jmp 0x593d
movb $0xa, (%rbx)
xorl %eax, %eax
movq 0x18(%rsp), %rcx
cmpb $0x0, 0x338(%rcx)
cmovnel 0x28(%rsp), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/./qlts.hpp
// Function: QltBase::calc_last_delta(unsigned int&, unsigned char, unsigned char, unsigned char)
inline static UINT32 calc_last_delta(UINT32 &delta, UCHAR q, UCHAR q1, UCHAR q2) {

        // This brilliant code could only be of James Bonfield
        if (q1>q)
            delta += (q1-q);

        return
            ( q
              | ((q1 < q2        ? q2         : q1) <<  6)
              | ((q1 == q2                        ) << 12)
              | ((7 > (delta>>3) ? (delta>>3) : 7 ) << 13)
              ) & RANGER_MASK_2 ;
    }

// Assembly:
movl (%rdi), %r8d
movzbl %dl, %eax
cmpb %sil, %dl
jbe 0x5a5d
movl %eax, %edx
subl %esi, %edx
addl %edx, %r8d
movl %r8d, (%rdi)
movl %r8d, %edx
andl $0x38, %edx
shll $0xa, %edx
cmpl $0x38, %r8d
movl $0xe000, %edi           # imm = 0xE000
cmovbl %edx, %edi
xorl %edx, %edx
cmpb %cl, %al
movzbl %cl, %ecx
cmoval %eax, %ecx
sete %dl
shll $0xc, %edx
movzbl %cl, %eax
shll $0x6, %eax
orl %edx, %eax
orl %esi, %eax
orl %edi, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/./log64_ranger.hpp
// Function: Log64Ranger::update_freq(int)
inline UCHAR update_freq(int i) {

        rarely_if(freq[i] > (MAX_FREQ - STEP)) {
            rarely_if( i == 0 and
                       freq[i] + 20U > total)
                return syms[i];

            normalize();
        }

        freq[i] += STEP;
        total   += STEP;

        return LIKELY (i == 0 or
                       (++ count & 0xf) or
                       freq[i] <= freq[i-1] ) ?
            syms[i] :
            down_level(i);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r14
movzwl (%rdi,%r14,2), %eax
cmpl $0xffbb, %eax           # imm = 0xFFBB
jae 0x5b7b
addl $0x6, %eax
movw %ax, (%rbx,%r14,2)
addl $0x6, 0x82(%rbx)
testl %ebp, %ebp
je 0x5b6e
movb 0x86(%rbx), %cl
incb %cl
movb %cl, 0x86(%rbx)
testb $0xf, %cl
jne 0x5b6e
cmpw -0x2(%rbx,%r14,2), %ax
ja 0x5b99
movb 0x87(%rbx,%r14), %al
popq %rbx
popq %r14
popq %rbp
retq
testl %ebp, %ebp
jne 0x5b8a
addl $0x14, %eax
cmpl 0x82(%rbx), %eax
ja 0x5b6e
movq %rbx, %rdi
callq 0x5ba8
movzwl (%rbx,%r14,2), %eax
jmp 0x5b40
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x5bd8
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/recs.cpp
// Function: RecSave::RecSave()
RecSave::RecSave() {

    m_valid = true;

    BZERO(m_last);
    BZERO(stats);
    // range_init();

    filer = new FilerSave("rec");
    assert(filer);
    rcoder.init(filer);

    x_file = new XFileSave("rec.x");

    smap[0].len = smap[1].len = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xc7ce0, %edx          # imm = 0xC7CE0
xorl %esi, %esi
callq 0x2130
xorps %xmm0, %xmm0
movups %xmm0, 0xc7cf8(%rbx)
movb $0x1, 0xc7d2c(%rbx)
movups %xmm0, 0xc7d08(%rbx)
movups %xmm0, 0xc7d18(%rbx)
andl $0x0, 0xc7d28(%rbx)
movl $0x4040, %edi           # imm = 0x4040
callq 0x21e0
movq %rax, %r15
leaq 0x443b(%rip), %rsi      # 0xa095
movq %rax, %rdi
callq 0x3ff8
movq %r15, 0xc8668(%rbx)
movq %r15, 0xc7d00(%rbx)
andq $0x0, 0xc7cf8(%rbx)
andq $0x0, 0xc7ce0(%rbx)
orl $-0x1, 0xc7cf0(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21e0
movq %rax, %r15
leaq 0x42d2(%rip), %rsi      # 0x9f6d
movq %rax, %rdi
callq 0x8534
movq %r15, 0xc8670(%rbx)
xorl %eax, %eax
movb %al, 0xc81c5(%rbx)
movb %al, 0xc7f79(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x2db0, %esi           # imm = 0x2DB0
jmp 0x5cd0
movq %rax, %r14
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21f0
jmp 0x5cdd
movq %rax, %r14
movq %rbx, %rdi
callq 0x6bd8
movq %r14, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/recs.cpp
// Function: RecSave::~RecSave()
RecSave::~RecSave() {
    rcoder.done();
    if (not conf.quiet) {
    }

    DELETE(filer);
    DELETE(x_file);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0xc7ce0, %rdi          # imm = 0xC7CE0
callq 0x2962
movq 0xc8668(%rbx), %r14
testq %r14, %r14
je 0x5d22
movq %r14, %rdi
callq 0x411a
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21f0
andq $0x0, 0xc8668(%rbx)
movq 0xc8670(%rbx), %r14
testq %r14, %r14
je 0x5d4b
movq %r14, %rdi
callq 0x8556
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21f0
andq $0x0, 0xc8670(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6bd8
movq %rax, %rdi
callq 0x2957
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/recs.cpp
// Function: sncpy(unsigned char*, unsigned char const*, int)
UCHAR* sncpy(UCHAR* target, const UCHAR* source, int n) {
    int  i;
    for (i = 0 ; i < n and source[i]; i++)
        target[i] = source[i];
    target[i] = 0;
    return target + i;
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
cmpq %rax, %rdx
je 0x5d88
movb (%rsi,%rax), %cl
testb %cl, %cl
je 0x5d85
movb %cl, (%rdi,%rax)
incq %rax
jmp 0x5d71
movq %rax, %rdx
leaq (%rdi,%rdx), %rax
movb $0x0, (%rdi,%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/recs.cpp
// Function: RecSave::save_first_line(unsigned char const*, unsigned char const*)
void RecSave::save_first_line(const UCHAR* buf, const UCHAR* end) {
    UCHAR first[MAX_LLINE];
    sncpy(first, buf, end-buf);
    conf.set_info("rec.first", (const char*)first);
    // conf.save_info();

    m_last.initilized = true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
subl %esi, %edx
movq %rsp, %r14
movq %r14, %rdi
callq 0x5d6a
leaq 0xb59d(%rip), %rdi      # 0x11350
leaq 0x41b9(%rip), %rsi      # 0x9f73
movq %r14, %rdx
callq 0x3000
movb $0x1, 0xc7d08(%rbx)
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/recs.cpp
// Function: RecLoad::RecLoad()
RecLoad::RecLoad() {
    m_valid = true;
    // range_init();

    filer = new FilerLoad("rec", &m_valid);
    assert(filer);
    rcoder.init(filer);

    BZERO(m_last);

    x_file = new XFileLoad("rec.x");
    m_last.index = x_file->get();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xc7ce0, %edx          # imm = 0xC7CE0
xorl %esi, %esi
callq 0x2130
xorps %xmm0, %xmm0
movups %xmm0, 0xc7cf8(%rbx)
movb $0x1, 0xc7d2c(%rbx)
movl $0x4040, %edi           # imm = 0x4040
callq 0x21e0
movq %rax, %r15
leaq 0xc7d2c(%rbx), %rdx
leaq 0x41cb(%rip), %rsi      # 0xa095
movq %rax, %rdi
callq 0x435a
movq %r15, 0xc8668(%rbx)
leaq 0xc7ce0(%rbx), %rdi
movq %r15, %rsi
callq 0x2996
xorps %xmm0, %xmm0
movups %xmm0, 0xc7d08(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21e0
movq %rax, %r15
leaq 0x4067(%rip), %rsi      # 0x9f6d
movq %rax, %rdi
callq 0x85f6
movq %r15, 0xc8670(%rbx)
movq %r15, %rdi
callq 0x87ba
movq %rax, 0xc7d10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x2db0, %esi           # imm = 0x2DB0
jmp 0x5f3c
movq %rax, %r14
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21f0
jmp 0x5f49
movq %rax, %r14
movq %rbx, %rdi
callq 0x6bd8
movq %r14, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/recs.cpp
// Function: RecLoad::load_first_line(unsigned char*)
size_t RecLoad::load_first_line(UCHAR* buf) {

    m_last.initilized = true;

    const char *first = conf.get_info("rec.first");
    strcpy((char*)buf, first);
    return strlen(first);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb $0x1, 0xc7d08(%rdi)
leaq 0xb38d(%rip), %rdi      # 0x11350
leaq 0x3fa9(%rip), %rsi      # 0x9f73
callq 0x2cb8
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21c0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/recs.cpp
// Function: RecLoad::get_str(unsigned char, unsigned char*)
UCHAR* RecLoad::get_str(UCHAR i, UCHAR* p) {
    UINT32 len = ranger[i].num.get_u(&rcoder);
    for (UINT32 j = 0; j < len; j++)
        p[j] = ranger[i].str.get(&rcoder);
    return p + len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r12
movl %esi, %eax
imulq $0x3070, %rax, %r13     # imm = 0x3070
addq %r13, %rdi
addq $0x60e, %rdi            # imm = 0x60E
leaq 0xc7ce0(%r12), %r14
movq %r14, %rsi
callq 0x6d04
movq %rax, %r15
addq %r13, %r12
addq $0x307, %r12            # imm = 0x307
movl %r15d, %r13d
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x608a
movq %r12, %rdi
movq %r14, %rsi
callq 0x29da
movb %al, (%rbx,%rbp)
incq %rbp
jmp 0x6072
movl %r15d, %eax
addq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/recs.cpp
// Function: RecBase::map_space(unsigned char const*, bool)
void RecBase::map_space(const UCHAR* p, bool flip) {
    smap[flip].len = 0;
    smap[flip].off[0] = 0;
    for (int i = 0; ; i++) {
        if (not isword(p[i])) {
            smap[flip].wln [smap[flip].len  ] = i - smap[flip].off[smap[flip].len];
            smap[flip].str[smap[flip].len++] = p[i];
            smap[flip].off[smap[flip].len  ] = i + 1;

            rarely_if (p[i] == 0 or p[i] == '\n')
                break;

            rarely_if(smap[flip].len > 64)
                croak("ERROR: irregulal record (over 64 non alpha non digit). Is it a valid fastq file?");
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %eax
imulq $0x24c, %rax, %rax      # imm = 0x24C
leaq (%rdi,%rax), %r14
addq $0xc7d30, %r14          # imm = 0xC7D30
movb $0x0, 0x249(%r14)
andl $0x0, (%r14)
movq %rsi, %rbx
xorl %r12d, %r12d
xorl %r15d, %r15d
movzbl (%rbx,%r15), %edi
leal -0x30(%rdi), %eax
cmpl $0xa, %eax
jb 0x6137
callq 0x22e0
testl %eax, %eax
jne 0x6137
movzbl %r12b, %eax
movl %r15d, %ecx
subl (%r14,%rax,4), %ecx
movl %ecx, 0x104(%r14,%rax,4)
movb (%rbx,%r15), %cl
movl %eax, %edx
incb %dl
movb %dl, 0x249(%r14)
movb %cl, 0x208(%r14,%rax)
movzbl 0x249(%r14), %r12d
leal 0x1(%r15), %eax
movl %eax, (%r14,%r12,4)
movzbl (%rbx,%r15), %eax
cmpl $0xa, %eax
je 0x613c
testl %eax, %eax
je 0x613c
cmpb $0x41, %r12b
jae 0x6148
incq %r15
jmp 0x60d3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3e2e(%rip), %rdi      # 0x9f7d
xorl %eax, %eax
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/./power_ranger.hpp
// Function: PowerRangerU::put_u(RCoder*, unsigned long long)
bool put_u(RCoder *rc, UINT64 num) {

    likely_if(num <= 0x7f) {
        p[0].put(rc, 0xff & num);
        return false;
    }
    likely_if (num < 0x7ffe) {
        p[0].put(rc, 0xff & (0x80 | (num>>8)));
        p[1].put(rc, 0xff & num);
        return false;
    }
    p[0].put(rc, 0xff);
    if (num < 1ULL<<32) {
        p[1].put(rc, 0xfe);
        for (int shift=0, i=2; shift < 32; shift+=8, i++)
            p[i].put(rc, 0xff & (num>>shift));
        return true;
    }
    {
        p[1].put(rc, 0xff);
        for (int shift=0, i=6; shift < 64; shift+=8, i++)
            p[i].put(rc, 0xff & (num>>shift));
        return true;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpq $0x80, %rdx
jae 0x6c33
movzbl %r14b, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x28e4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpq $0x7ffd, %r14           # imm = 0x7FFD
ja 0x6c5b
movl %r14d, %eax
shrl $0x8, %eax
orb $-0x80, %al
movzbl %al, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x28e4
addq $0x307, %r15            # imm = 0x307
jmp 0x6c16
movq %r15, %rdi
movq %rbx, %rsi
movl $0xff, %edx
callq 0x28e4
movq %r14, %rax
shrq $0x20, %rax
leaq 0x307(%r15), %rdi
movq %rbx, %rsi
testq %rax, %rax
jne 0x6cbf
movl $0xfe, %edx
callq 0x28e4
addq $0x60e, %r15            # imm = 0x60E
xorl %r12d, %r12d
cmpq $0x20, %r12
je 0x6cfd
movq %r14, %rax
movl %r12d, %ecx
shrq %cl, %rax
movzbl %al, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x28e4
addq $0x8, %r12
addq $0x307, %r15            # imm = 0x307
jmp 0x6c95
movl $0xff, %edx
callq 0x28e4
addq $0x122a, %r15           # imm = 0x122A
xorl %r12d, %r12d
cmpq $0x40, %r12
je 0x6cfd
movq %r14, %rax
movl %r12d, %ecx
shrq %cl, %rax
movzbl %al, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x28e4
addq $0x8, %r12
addq $0x307, %r15            # imm = 0x307
jmp 0x6cd3
movb $0x1, %al
jmp 0x6c27
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/./power_ranger.hpp
// Function: PowerRangerU::get_u(RCoder*)
UINT64 get_u(RCoder *rc) {

    UINT64 num = p[0].get(rc);
    rarely_if(num > 0x7f) {

        num <<= 8;
        num  |= p[1].get(rc);
        likely_if(num < 0xfffe)
            num &= 0x7fff;

        else likely_if (num == 0xfffe) {
            num = 0;
            for (int shift=0, i = 2; shift < 32; shift+=8, i++) {
                UINT64 c = p[i].get(rc);
                num  |= (c<<shift);
            }
        }
        else {
            num = 0;
            for (int shift=0, i=6; shift < 64; shift+=8, i++) {
                UINT64 c = p[i].get(rc);
                num  |= (c<<shift);
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x29da
movzwl %ax, %r15d
cmpw $0x80, %r15w
jae 0x6d32
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
shll $0x8, %r15d
leaq 0x307(%r14), %rdi
movq %rbx, %rsi
callq 0x29da
movzwl %ax, %eax
orq %r15, %rax
cmpq $0xfffd, %rax           # imm = 0xFFFD
ja 0x6d5d
andl $0x7fff, %eax           # imm = 0x7FFF
movq %rax, %r15
jmp 0x6d23
cmpl $0xfffe, %eax           # imm = 0xFFFE
jne 0x6d9b
addq $0x60e, %r14            # imm = 0x60E
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq $0x20, %r12
je 0x6d23
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29da
movzwl %ax, %eax
movl %r12d, %ecx
shlq %cl, %rax
orq %rax, %r15
addq $0x8, %r12
addq $0x307, %r14            # imm = 0x307
jmp 0x6d71
addq $0x122a, %r14           # imm = 0x122A
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq $0x40, %r12
je 0x6d23
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29da
movzwl %ax, %eax
movl %r12d, %ecx
shlq %cl, %rax
orq %rax, %r15
addq $0x8, %r12
addq $0x307, %r14            # imm = 0x307
jmp 0x6da8
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/usrs.cpp
// Function: UsrSave::UsrSave()
UsrSave::UsrSave() {
    BZERO(m_last);
    BZERO(mp);

    m_valid  = true ;
    m_cur = 0 ;
    m_end = 0 ;
    m_page_count = 0;
    m_llen = 0;
    m_qlen = 0;
    m_solid = false;
    x_llen = new XFileSave("usr.x");
    x_qlen = new XFileSave("usr.x.q");
    x_sgen = new XFileSave("usr.pfg");
    x_sqlt = new XFileSave("usr.pfq");

    x_lgen = new XFileSave("usr.lgen");
    x_lqlt = new XFileSave("usr.lqlt");
    x_lrec = new XFileSave("usr.lrec");

    m_in   = conf.file_usr();
    load_page();
    if (m_valid)
        determine_record();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x1240a0(%rdi)
movups %xmm0, 0x1240b0(%rdi)
movups %xmm0, 0x1240c0(%rdi)
movb $0x1, 0x30(%rdi)
movups %xmm0, 0x124040(%rdi)
andq $0x0, 0x12405c(%rdi)
movb $0x0, 0x124064(%rdi)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21e0
movq %rax, %r14
leaq 0x3230(%rip), %rsi      # 0xa060
movq %rax, %rdi
callq 0x8534
movq %r14, 0x124068(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21e0
movq %rax, %r14
leaq 0x3213(%rip), %rsi      # 0xa066
movq %rax, %rdi
callq 0x8534
movq %r14, 0x124070(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21e0
movq %rax, %r14
leaq 0x31f8(%rip), %rsi      # 0xa06e
movq %rax, %rdi
callq 0x8534
movq %r14, 0x124078(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21e0
movq %rax, %r14
leaq 0x31dd(%rip), %rsi      # 0xa076
movq %rax, %rdi
callq 0x8534
movq %r14, 0x124080(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21e0
movq %rax, %r14
leaq 0x31c2(%rip), %rsi      # 0xa07e
movq %rax, %rdi
callq 0x8534
movq %r14, 0x124088(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21e0
movq %rax, %r14
leaq 0x31a8(%rip), %rsi      # 0xa087
movq %rax, %rdi
callq 0x8534
movq %r14, 0x124090(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21e0
movq %rax, %r14
leaq 0x318e(%rip), %rsi      # 0xa090
movq %rax, %rdi
callq 0x8534
movq %r14, 0x124098(%rbx)
leaq 0xa438(%rip), %rax      # 0x11350
movq 0x10(%rax), %rax
movq %rax, 0x124050(%rbx)
movq %rbx, %rdi
callq 0x6f6c
cmpb $0x1, 0x30(%rbx)
jne 0x6f40
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7066
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x6f54
jmp 0x6f54
jmp 0x6f54
jmp 0x6f54
jmp 0x6f54
jmp 0x6f54
movq %rax, %rbx
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/usrs.cpp
// Function: UsrSave::load_page()
void UsrSave::load_page() {

    size_t size  = m_end - m_cur ;
    assert(size <= PLL_STRT);
    size_t start = PLL_STRT - size;
    for (size_t i = 0 ; i < size; i++)
        m_buff[start+i] = m_buff[m_cur+i];

    likely_if (mp.rec != NULL) {
        UCHAR* pl = mp_last;
        for (UCHAR* p = mp.rec; p < mp.rec_end; p++ , pl++)
            *pl = *p;
        mp.rec = mp_last;
        mp.rec_end = pl;
        *pl++ = '\n';           // Just in case
        *pl   = 0;              // clean debug
    }

    size_t cnt = fread(&m_buff[PLL_STRT], 1, PLL_SIZE, m_in);
    m_cur  = start;
    m_end = PLL_STRT + cnt  ;

    if (m_cur == m_end)
        m_valid = false;
    else
        m_page_count++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq 0x12404c(%rdi), %rdx
movslq 0x124048(%rdi), %rax
movq %rdx, %rcx
subq %rax, %rcx
cmpl $0x24001, %ecx          # imm = 0x24001
jae 0x7048
movq %rdi, %rbx
movl $0x24000, %r14d         # imm = 0x24000
subq %rcx, %r14
leaq 0x31(%rdi), %rcx
subq %rdx, %rax
testq %rax, %rax
je 0x6fc1
movslq 0x124048(%rbx), %rdx
movb (%rcx,%rdx), %dl
movb %dl, 0x24031(%rbx,%rax)
incq %rax
incq %rcx
jmp 0x6fa3
movq 0x1240a0(%rbx), %rax
testq %rax, %rax
je 0x7001
leaq 0x1240d0(%rbx), %rdx
movq %rdx, %rcx
cmpq 0x1240a8(%rbx), %rax
jae 0x6fee
movb (%rax), %sil
movb %sil, (%rcx)
incq %rax
incq %rcx
jmp 0x6fd7
movq %rdx, 0x1240a0(%rbx)
movq %rcx, 0x1240a8(%rbx)
movw $0xa, (%rcx)
leaq 0x24031(%rbx), %rdi
movq 0x124050(%rbx), %rcx
pushq $0x1
popq %rsi
movl $0x100000, %edx         # imm = 0x100000
callq 0x22c0
movl %r14d, 0x124048(%rbx)
addl $0x24000, %eax          # imm = 0x24000
movl %eax, 0x12404c(%rbx)
cmpl %r14d, %eax
jne 0x7039
movb $0x0, 0x30(%rbx)
jmp 0x7040
incq 0x124040(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x308f(%rip), %rdi      # 0xa0de
leaq 0x3099(%rip), %rsi      # 0xa0ef
leaq 0x309b(%rip), %rcx      # 0xa0f8
pushq $0x63
popq %rdx
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/usrs.cpp
// Function: UsrSave::update(UsrBase::exception_t, unsigned short)
void UsrSave::update(exception_t type, UINT16 dat) {
    switch (type) {
    case ET_LLEN:
        x_llen -> put ( g_record_count - m_last.i_llen );
        x_llen -> put ( dat );
        m_last.i_llen = g_record_count;
        m_llen = dat;
        break;

    case ET_QLEN:
        x_qlen -> put( g_record_count - m_last.i_qlen );
        x_qlen -> put( dat );
        m_last.i_qlen = g_record_count;
        // m_qlen = dat;
        break;

    case ET_SOLPF_GEN:
        x_sgen->put( g_record_count - m_last.i_sgen);
        x_sgen->put_chr( dat );
        m_last.i_sgen = g_record_count;
        m_last.solid_pf_gen = dat;
        break;

    case ET_SOLPF_QLT:
        x_sqlt->put( g_record_count - m_last.i_sqlt);
        x_sqlt->put_chr( dat );
        m_last.i_sqlt = g_record_count;
        m_last.solid_pf_qlt = dat;
        break;

    default : assert(0);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, %esi
ja 0x760e
movl %edx, %ebp
movq %rdi, %rbx
movl %esi, %eax
leaq 0x2b1a(%rip), %rcx      # 0xa038
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x124068(%rbx), %rdi
leaq 0x7c9b(%rip), %r15      # 0xf1d0
movq (%r15), %rsi
subq (%rbx), %rsi
callq 0x85be
movq 0x124068(%rbx), %rdi
movzwl %bp, %r14d
movq %r14, %rsi
callq 0x85be
movq (%r15), %rax
movq %rax, (%rbx)
movl %r14d, 0x12405c(%rbx)
jmp 0x7603
movq 0x124078(%rbx), %rdi
leaq 0x7c5d(%rip), %r14      # 0xf1d0
movq (%r14), %rsi
subq 0x10(%rbx), %rsi
callq 0x85be
movq 0x124078(%rbx), %rdi
movzbl %bpl, %esi
callq 0x86ce
movq (%r14), %rax
movq %rax, 0x10(%rbx)
movb %bpl, 0x28(%rbx)
jmp 0x7603
movq 0x124080(%rbx), %rdi
leaq 0x7c26(%rip), %r14      # 0xf1d0
movq (%r14), %rsi
subq 0x18(%rbx), %rsi
callq 0x85be
movq 0x124080(%rbx), %rdi
movzbl %bpl, %esi
callq 0x86ce
movq (%r14), %rax
movq %rax, 0x18(%rbx)
movb %bpl, 0x29(%rbx)
jmp 0x7603
movq 0x124070(%rbx), %rdi
leaq 0x7bef(%rip), %r14      # 0xf1d0
movq (%r14), %rsi
subq 0x8(%rbx), %rsi
callq 0x85be
movq 0x124070(%rbx), %rdi
movzwl %bp, %esi
callq 0x85be
movq (%r14), %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2653(%rip), %rdi      # 0x9c68
leaq 0x2ad3(%rip), %rsi      # 0xa0ef
leaq 0x2aef(%rip), %rcx      # 0xa112
movl $0x9a, %edx
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/usrs.cpp
// Function: UsrSave::get_oversized_record(int, bool)
bool UsrSave::get_oversized_record(int cur, bool from_get) {
    // collect this record
    x_lrec->put( g_record_count - m_last.i_long);
    m_last.i_long = g_record_count ;

    m_cur = cur ;               // zap back
    UCHAR c = load_char();
    if ('@' != c)
        croak("record %llu: bad (long) record", g_record_count);

#define CHK_VALID if (!m_valid) croak("record %llu: seems truncated", g_record_count)
#define PUT_LINE(X) do { c = load_char(); X->put_chr(c); } while (c != '\n' and m_valid)

    PUT_LINE(x_lrec);
    CHK_VALID;

    PUT_LINE(x_lgen);
    CHK_VALID;

    PUT_LINE(x_lrec);           // 2nd rec
    CHK_VALID;

    PUT_LINE(x_lqlt);
    CHK_VALID;

#undef PUT_LINE
#undef CHK_VALID
    if (from_get) {
        g_record_count ++ ;
        return get_record();
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x124098(%rdi), %rdi
leaq 0x7b6b(%rip), %r15      # 0xf1d0
movq (%r15), %rsi
subq 0x20(%rbx), %rsi
callq 0x85be
movq (%r15), %rax
movq %rax, 0x20(%rbx)
movl %r14d, 0x124048(%rbx)
movq %rbx, %rdi
callq 0x8366
cmpb $0x40, %al
jne 0x776f
movq %rbx, %rdi
callq 0x8366
movq 0x124098(%rbx), %rdi
movzbl %al, %r14d
movl %r14d, %esi
callq 0x86ce
movb 0x30(%rbx), %al
cmpb $0xa, %r14b
je 0x76c8
testb $0x1, %al
jne 0x768f
movq (%r15), %rsi
leaq 0x2ba1(%rip), %rdi      # 0xa262
xorl %eax, %eax
callq 0x2350
testb $0x1, %al
je 0x76b7
movq %rbx, %rdi
callq 0x8366
movq 0x124088(%rbx), %rdi
movzbl %al, %r14d
movl %r14d, %esi
callq 0x86ce
movb 0x30(%rbx), %al
cmpb $0xa, %r14b
jne 0x76c8
testb $0x1, %al
je 0x76b7
movq %rbx, %rdi
callq 0x8366
movq 0x124098(%rbx), %rdi
movzbl %al, %r14d
movl %r14d, %esi
callq 0x86ce
movb 0x30(%rbx), %al
cmpb $0xa, %r14b
jne 0x76f0
testb $0x1, %al
je 0x76b7
movq %rbx, %rdi
callq 0x8366
movq 0x124090(%rbx), %rdi
movzbl %al, %r14d
movl %r14d, %esi
callq 0x86ce
movb 0x30(%rbx), %al
cmpb $0xa, %r14b
jne 0x7718
testb $0x1, %al
je 0x76b7
testb %bpl, %bpl
je 0x7762
incq (%r15)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x777e
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rsi
leaq 0x2aca(%rip), %rdi      # 0xa243
jmp 0x76c1
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/usrs.cpp
// Function: UsrSave::encode()
int UsrSave::encode() {

    UINT32  sanity = conf.profiling ? 100000 : 3000000000;

    RecSave rec;
    GenSave gen;
    QltSave qlt;

    while( ++ g_record_count < sanity  and get_record() ) {
        gen.save(mp.gen, mp.qlt, m_llen, m_qlen);
        rec.save(mp.rec, mp.rec_end, mp.prev_rec, mp.prev_rec_end);
        qlt.save(mp.qlt, m_qlen);
    }
    conf.set_info("num_records", g_record_count-1);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8a28, %rsp          # imm = 0xC8A28
movq %rdi, %rbx
leaq 0x98ef(%rip), %rax      # 0x11350
movb 0xd(%rax), %bpl
leaq 0x3b0(%rsp), %rdi
callq 0x5c0c
movq %rsp, %rdi
callq 0x482e
leaq 0x60(%rsp), %rdi
callq 0x516e
testb %bpl, %bpl
movl $0x186a0, %eax          # imm = 0x186A0
movl $0xb2d05e00, %r13d      # imm = 0xB2D05E00
cmovneq %rax, %r13
leaq 0x7733(%rip), %rbp      # 0xf1d0
movq %rsp, %r14
leaq 0x3b0(%rsp), %r15
leaq 0x60(%rsp), %r12
movq (%rbp), %rdx
leaq 0x1(%rdx), %rax
movq %rax, (%rbp)
cmpq %r13, %rax
jae 0x7b31
movq %rbx, %rdi
callq 0x777e
testb %al, %al
je 0x7b2a
movq 0x1240c0(%rbx), %rsi
movq 0x1240c8(%rbx), %rdx
movslq 0x12405c(%rbx), %rcx
movslq 0x124060(%rbx), %r8
movq %r14, %rdi
callq 0x8408
movq 0x1240a0(%rbx), %rsi
movq 0x1240a8(%rbx), %rdx
movq 0x1240b0(%rbx), %rcx
movq 0x1240b8(%rbx), %r8
movq %r15, %rdi
callq 0x6156
movq 0x1240c8(%rbx), %rsi
movslq 0x124060(%rbx), %rdx
movq %r12, %rdi
callq 0x845c
jmp 0x7aad
movq (%rbp), %rdx
decq %rdx
leaq 0x9818(%rip), %rdi      # 0x11350
leaq 0x275f(%rip), %rsi      # 0xa29e
callq 0x309e
leaq 0x60(%rsp), %rdi
callq 0x52dc
movq %rsp, %rdi
callq 0x4988
leaq 0x3b0(%rsp), %rdi
callq 0x5cee
xorl %eax, %eax
addq $0xc8a28, %rsp          # imm = 0xC8A28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7b83
movq %rax, %rbx
jmp 0x7b90
movq %rax, %rbx
jmp 0x7b98
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x52dc
movq %rsp, %rdi
callq 0x4988
leaq 0x3b0(%rsp), %rdi
callq 0x5cee
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/usrs.cpp
// Function: UsrLoad::~UsrLoad()
UsrLoad::~UsrLoad() {
    DELETE(x_llen);
    DELETE(x_qlen);
    DELETE(x_sgen);
    DELETE(x_sqlt);

    DELETE(x_lgen);
    DELETE(x_lqlt);
    DELETE(x_lrec);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x24080(%rdi), %r14
testq %r14, %r14
je 0x7e36
movq %r14, %rdi
callq 0x8618
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21f0
andq $0x0, 0x24080(%rbx)
movq 0x24088(%rbx), %r14
testq %r14, %r14
je 0x7e5f
movq %r14, %rdi
callq 0x8618
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21f0
andq $0x0, 0x24088(%rbx)
movq 0x24090(%rbx), %r14
testq %r14, %r14
je 0x7e88
movq %r14, %rdi
callq 0x8618
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21f0
andq $0x0, 0x24090(%rbx)
movq 0x24098(%rbx), %r14
testq %r14, %r14
je 0x7eb1
movq %r14, %rdi
callq 0x8618
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21f0
andq $0x0, 0x24098(%rbx)
movq 0x240a0(%rbx), %r14
testq %r14, %r14
je 0x7eda
movq %r14, %rdi
callq 0x8618
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21f0
andq $0x0, 0x240a0(%rbx)
movq 0x240a8(%rbx), %r14
testq %r14, %r14
je 0x7f03
movq %r14, %rdi
callq 0x8618
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21f0
andq $0x0, 0x240a8(%rbx)
movq 0x240b0(%rbx), %r14
testq %r14, %r14
je 0x7f2c
movq %r14, %rdi
callq 0x8618
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21f0
andq $0x0, 0x240b0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/usrs.cpp
// Function: UsrLoad::save()
void UsrLoad::save() {

    UCHAR* p_rec = flip ? m_rep : m_rec ;
    flip = flip ? 0 : 1 ;

    putline(p_rec, m_rec_size+1);
    if (m_2nd_rec) {
        putline(m_gen_ptr, m_llen + m_llen_factor);
        p_rec[0] = '+';
        putline(p_rec, m_rec_size+1);
        p_rec[0] = '@';
    }
    else {
        putline(m_gen_ptr, m_llen + m_llen_factor + 2);
    }
    putline(m_qlt_ptr, m_qlen + m_llen_factor);

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x60(%rdi), %al
leaq 0x2062(%rdi), %r14
leaq 0x61(%rdi), %rcx
testb %al, %al
cmovneq %rcx, %r14
xorb $0x1, %al
movb %al, 0x60(%rdi)
movl 0x54(%rdi), %edx
incl %edx
movq %r14, %rsi
callq 0x81a2
movq 0x24078(%rbx), %rsi
movl 0x40(%rbx), %edx
addl 0x38(%rbx), %edx
cmpb $0x1, 0x50(%rbx)
jne 0x817a
movq %rbx, %rdi
callq 0x81a2
movb $0x2b, (%r14)
movl 0x54(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x81a2
movb $0x40, (%r14)
jmp 0x8185
addl $0x2, %edx
movq %rbx, %rdi
callq 0x81a2
movl 0x40(%rbx), %edx
addl 0x48(%rbx), %edx
movq 0x24070(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x81a2
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/usrs.cpp
// Function: UsrLoad::putline(unsigned char*, unsigned int)
void UsrLoad::putline(UCHAR* buf, UINT32 size) {
    buf[size++] = '\n';
    size_t cnt = fwrite(buf, 1, size, m_out);

    rarely_if (cnt != size)
        croak("USR: Error writing output");
}

// Assembly:
pushq %rbx
movl %edx, %ebx
movq %rsi, %rax
movl %edx, %ecx
incl %ebx
movb $0xa, (%rsi,%rcx)
movq 0x30(%rdi), %rcx
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x2330
cmpq %rbx, %rax
jne 0x81c9
popq %rbx
retq
leaq 0x20da(%rip), %rdi      # 0xa2aa
xorl %eax, %eax
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/usrs.cpp
// Function: UsrLoad::decode()
int UsrLoad::decode() {

    size_t n_recs = conf.get_long("num_records");

    rarely_if( ! n_recs and not m_last.i_long)
        croak("Zero records, what's going on?");

    comp_version = conf.decoder_version;

    RecLoad rec;
    GenLoad gen;
    QltLoad qlt;

    UCHAR* b_qlt = m_qlt+1 ;
    UCHAR* b_gen = m_gen+1 ;

    while (1) {
        g_record_count++;
        update();
        if (g_record_count > n_recs)
            break;

        UCHAR* b_rec = (flip ? m_rep : m_rec)+1 ;
        UCHAR* p_rec = (flip ? m_rec : m_rep)+1 ;

        m_rec_size = rec.load(b_rec, p_rec);
        rarely_if (not m_rec_size)
            croak("premature EOF - %llu records left", n_recs+1);

        qlt.load(b_qlt, m_qlen);
        gen.load(b_gen, b_qlt, m_llen, m_qlen);
        save();
    }
    // sanity: verify all objects are done (by croak?)
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8a38, %rsp          # imm = 0xC8A38
movq %rdi, %rbx
leaq 0x915d(%rip), %r15      # 0x11350
leaq 0x20a4(%rip), %rsi      # 0xa29e
movq %r15, %rdi
xorl %edx, %edx
callq 0x2f54
movq 0x20(%rbx), %rcx
movq %rax, 0x8(%rsp)
orq %rax, %rcx
je 0x831e
movslq 0x8(%r15), %rax
movq %rax, 0x58(%rbx)
leaq 0x3c0(%rsp), %rdi
callq 0x5e8a
leaq 0x10(%rsp), %rdi
callq 0x4bdc
leaq 0x78(%rsp), %rdi
callq 0x55ac
leaq 0x4064(%rbx), %r15
leaq 0x14066(%rbx), %r12
leaq 0x61(%rbx), %rbp
leaq 0x2062(%rbx), %r13
leaq 0x6f71(%rip), %r14      # 0xf1d0
incq (%r14)
movq %rbx, %rdi
callq 0x7f3c
movq 0x8(%rsp), %rax
cmpq %rax, (%r14)
ja 0x82d3
cmpb $0x0, 0x60(%rbx)
movq %rbp, %rsi
movq %r13, %rdx
jne 0x8286
movq %r13, %rsi
movq %rbp, %rdx
incq %rsi
incq %rdx
leaq 0x3c0(%rsp), %rdi
callq 0x6660
movl %eax, 0x54(%rbx)
testl %eax, %eax
je 0x8308
movq 0x48(%rbx), %rdx
leaq 0x78(%rsp), %rdi
movq %r15, %rsi
callq 0x8480
movq 0x38(%rbx), %rcx
movq 0x48(%rbx), %r8
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x84a4
movq %rbx, %rdi
callq 0x8118
jmp 0x825f
leaq 0x78(%rsp), %rdi
callq 0x570c
leaq 0x10(%rsp), %rdi
callq 0x4d28
leaq 0x3c0(%rsp), %rdi
callq 0x5f5a
xorl %eax, %eax
addq $0xc8a38, %rsp          # imm = 0xC8A38
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rsi
incq %rsi
leaq 0x1fcc(%rip), %rdi      # 0xa2e3
xorl %eax, %eax
callq 0x2350
leaq 0x1f9f(%rip), %rdi      # 0xa2c4
xorl %eax, %eax
callq 0x2350
movq %rax, %rbx
jmp 0x8347
movq %rax, %rbx
jmp 0x8351
jmp 0x833a
jmp 0x833a
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x570c
leaq 0x10(%rsp), %rdi
callq 0x4d28
leaq 0x3c0(%rsp), %rdi
callq 0x5f5a
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/usrs.cpp
// Function: UsrSave::load_check()
void UsrSave::load_check() {
    likely_if (m_cur+PLL_STRT < m_end)
        return;
    for (int i = m_cur, cnt=0; i < m_end; i++)
        if (m_buff[i] == '\n')
            if (++cnt >= 4)
                return;
    load_page();
}

// Assembly:
movslq 0x124048(%rdi), %rax
leal 0x24000(%rax), %edx
movslq 0x12404c(%rdi), %rcx
cmpl %ecx, %edx
jge 0x83b1
retq
xorl %edx, %edx
cmpq %rcx, %rax
jge 0x6f6c
cmpb $0xa, 0x31(%rdi,%rax)
jne 0x83ca
cmpl $0x2, %edx
jg 0x83b0
incl %edx
incq %rax
jmp 0x83b3
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/xfile.cpp
// Function: XFileSave::~XFileSave()
XFileSave::~XFileSave() {
    if (filer) {
        put(0);                 // no more exceptions
        rcoder.done();
        delete filer;
        filer = NULL;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x2da8(%rdi)
je 0x85a3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x85be
leaq 0x10(%rbx), %rdi
callq 0x2962
movq 0x2da8(%rbx), %r14
testq %r14, %r14
je 0x858e
movq %r14, %rdi
callq 0x411a
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21f0
andq $0x0, 0x2da8(%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28d4
movq %rax, %rdi
callq 0x2957
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/xfile.cpp
// Function: XFileLoad::~XFileLoad()
XFileLoad::~XFileLoad() {
    if (filer) {
        rcoder.done();
        delete filer;
        filer = NULL;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x2da8(%rdi)
je 0x865b
leaq 0x10(%rbx), %rdi
callq 0x2962
movq 0x2da8(%rbx), %r14
testq %r14, %r14
je 0x8646
movq %r14, %rdi
callq 0x4584
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21f0
andq $0x0, 0x2da8(%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28d4
movq %rax, %rdi
callq 0x2957
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/xfile.cpp
// Function: XFileLoad::init()
void XFileLoad::init() {
    filer = new FilerLoad(m_filename, &m_valid);
    assert(filer);
    if (m_valid)
        rcoder.init(filer);
    else
        DELETE(filer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x4040, %edi           # imm = 0x4040
callq 0x21e0
movq %rax, %r14
movq (%rbx), %rsi
leaq 0x8(%rbx), %rdx
movq %rax, %rdi
callq 0x435a
movq %r14, 0x2da8(%rbx)
cmpb $0x0, 0x8(%rbx)
je 0x877c
addq $0x10, %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2996
movq %r14, %rdi
callq 0x4584
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21f0
andq $0x0, 0x2da8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/xfile.cpp
// Function: XFileLoad::get_str(unsigned char*)
UCHAR* XFileLoad::get_str(UCHAR* p) {
    size_t len = get();
    for (UINT32 j = 0; j < len; j++)
        p[j] = ranger_str.get(&rcoder);
    return p + len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x87ba
movq %rax, %r15
leaq 0x2a9a(%r14), %r12
addq $0x10, %r14
xorl %eax, %eax
movl %eax, %r13d
cmpq %r13, %r15
jbe 0x887f
movq %r12, %rdi
movq %r14, %rsi
callq 0x29da
movb %al, (%rbx,%r13)
leal 0x1(%r13), %eax
jmp 0x8862
addq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop