LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rdx, %rdx
jle 0x71c1
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
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 0x7192
movl %ebp, %edx
callq 0x77d0
shll $0x6, %r13d
movzwl %r13w, %r13d
orl %ebp, %r13d
incq %r14
cmpq %rbx, %r14
jb 0x7152
jmp 0x71b3
movl $0x3f, %edx
callq 0x77d0
movq (%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x3842
incl 0x348(%r15)
jmp 0x717d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
jle 0x732c
movq %rsi, %r14
addq %rsi, 0x10(%rsp)
movq 0x8(%rsp), %rax
leaq 0x310(%rax), %rcx
movq %rcx, (%rsp)
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movl $0x5, %r13d
xorl %r12d, %r12d
xorl %eax, %eax
movq $0x0, 0x18(%rsp)
xorl %ebx, %ebx
movb (%r14,%r12), %r15b
addb $-0x21, %r15b
movq 0x8(%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 0x72fe
movq (%rsp), %rsi
movl %ebp, %edx
callq 0x77d0
movzbl %bl, %edx
movzbl 0x18(%rsp), %eax
testb $0x1, %r12b
jne 0x72a1
movl %edx, %ecx
subl %ebp, %ecx
cmpb %bpl, %dl
movl $0x0, %esi
cmovbel %esi, %ecx
addl %ecx, %r13d
movl %r13d, %ecx
andl $0x38, %ecx
shll $0xa, %ecx
cmpl $0x38, %r13d
movl $0xe000, %esi           # imm = 0xE000
cmovael %esi, %ecx
xorl %esi, %esi
cmpb %al, %dl
cmoval %edx, %eax
sete %sil
shll $0xc, %esi
movl %r15d, %edx
movq %rdx, 0x18(%rsp)
jmp 0x72db
movl %eax, %ecx
subl %ebp, %ecx
cmpb %bpl, %al
movl $0x0, %esi
cmovbel %esi, %ecx
addl %ecx, %r13d
movl %r13d, %ecx
andl $0x38, %ecx
shll $0xa, %ecx
cmpl $0x38, %r13d
movl $0xe000, %esi           # imm = 0xE000
cmovael %esi, %ecx
xorl %esi, %esi
cmpb %dl, %al
cmoval %eax, %edx
sete %sil
shll $0xc, %esi
movl %edx, %eax
movl %r15d, %ebx
movzbl %al, %eax
shll $0x6, %eax
orl %esi, %eax
orl %ebp, %eax
orl %ecx, %eax
leaq (%r14,%r12), %rcx
incq %rcx
incq %r12
cmpq 0x10(%rsp), %rcx
jb 0x721a
jmp 0x732c
movq (%rsp), %rsi
movl $0x3f, %edx
callq 0x77d0
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movl %ebp, %edx
callq 0x3842
movq 0x8(%rsp), %rax
incl 0x348(%rax)
jmp 0x7254
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2110
pxor %xmm0, %xmm0
movdqu %xmm0, 0x328(%rbx)
movl $0x4040, %edi           # imm = 0x4040
callq 0x21b0
movq %rax, %r14
leaq 0x338(%rbx), %rdx
leaq 0x4d8f(%rip), %rsi      # 0xc10c
movq %rax, %rdi
callq 0x5ea4
movq %r14, 0x340(%rbx)
leaq 0xbf8d(%rip), %rax      # 0x13320
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 0x3ca4(%rip), %xmm1     # 0xb080
movdqa 0x3cac(%rip), %xmm2     # 0xb090
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 0x742f
movq $0x0, (%rdx)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x7449
movq $0x0, 0xc7(%rdx)
addq $0x2, %rsi
addq $0x18e, %rdx            # imm = 0x18E
cmpq %rsi, %rcx
jne 0x73ec
movq %rax, (%rbx)
leaq 0x310(%rbx), %rdi
movq %r14, %rsi
callq 0x3fe2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
jmp 0x748b
movq %rax, %r15
addq $0x310, %rbx            # imm = 0x310
movq %rbx, %rdi
callq 0x3f6c
movq %r15, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x3f61
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %r14
leaq (%rsi,%rdx), %rbp
testq %rdx, %rdx
jle 0x759f
movq %rsi, %r15
leaq 0x310(%r14), %r12
leaq 0x8(%r14), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
movl %r13d, %eax
imulq $0xc7, %rax, %rdi
addq (%r14), %rdi
movq %r12, %rsi
callq 0x7806
movzbl %al, %ecx
cmpw $0x3f, %cx
je 0x758e
addb $0x21, %al
movb %al, (%r15)
movzwl %cx, %eax
andl $0x3f, %r13d
shll $0x6, %r13d
orl %eax, %r13d
incq %r15
cmpq %rbp, %r15
jb 0x7553
jmp 0x759f
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x406a
movzbl %al, %ecx
jmp 0x7571
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %r14
leaq (%rsi,%rdx), %rbp
testq %rdx, %rdx
jle 0x7643
movq %rsi, %r15
leaq 0x310(%r14), %r12
leaq 0x8(%r14), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
movq (%r14), %rax
movl %r13d, %ecx
imulq $0xc7, %rcx, %rcx
leaq (%rax,%rcx), %rdi
prefetcht0 (%rax,%rcx)
movq %r12, %rsi
callq 0x7806
movzbl %al, %ecx
cmpw $0x3f, %cx
je 0x7632
addb $0x21, %al
movb %al, (%r15)
movzwl %cx, %eax
shll $0x6, %r13d
movzwl %r13w, %r13d
orl %eax, %r13d
incq %r15
cmpq %rbp, %r15
jb 0x75ef
jmp 0x7643
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x406a
movzbl %al, %ecx
jmp 0x7615
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rdi, %r14
leaq (%rsi,%rdx), %rax
movq %rax, 0x10(%rsp)
movq %rdx, 0x20(%rsp)
testq %rdx, %rdx
jle 0x77aa
movq %rsi, %r15
leaq 0x310(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%r14), %rax
movq %rax, 0x18(%rsp)
movl $0x5, %r13d
xorl %ebx, %ebx
xorl %ebp, %ebp
xorl %r12d, %r12d
xorl %edx, %edx
movq (%r14), %rax
movl %edx, %ecx
imulq $0xc7, %rcx, %rcx
leaq (%rax,%rcx), %rdi
prefetcht0 (%rax,%rcx)
movq 0x8(%rsp), %rsi
callq 0x7806
cmpb $0x3f, %al
je 0x7796
leal 0x21(%rax), %ecx
movb %cl, (%r15,%rbx)
movzbl %al, %ecx
movzbl %r12b, %edi
movzbl %bpl, %edx
testb $0x1, %bl
jne 0x772e
movl %edi, %esi
subl %ecx, %esi
cmpb %al, %dil
movl $0x0, %r8d
cmovbel %r8d, %esi
addl %esi, %r13d
movl %r13d, %esi
andl $0x38, %esi
shll $0xa, %esi
cmpl $0x38, %r13d
movl $0xe000, %r8d           # imm = 0xE000
cmovael %r8d, %esi
xorl %r8d, %r8d
cmpb %dl, %dil
sete %r8b
cmoval %edi, %edx
shll $0xc, %r8d
jmp 0x7770
movl %edx, %esi
subl %ecx, %esi
cmpb %al, %dl
movl $0x0, %r8d
cmovbel %r8d, %esi
addl %esi, %r13d
movl %r13d, %esi
andl $0x38, %esi
shll $0xa, %esi
cmpl $0x38, %r13d
movl $0xe000, %r8d           # imm = 0xE000
cmovael %r8d, %esi
xorl %r8d, %r8d
cmpb %dil, %dl
sete %r8b
cmoval %edx, %edi
shll $0xc, %r8d
movl %edi, %edx
movl %eax, %r12d
movl %ebp, %eax
movzbl %dl, %edx
shll $0x6, %edx
orl %r8d, %edx
orl %ecx, %edx
orl %esi, %edx
leaq (%r15,%rbx), %rcx
incq %rcx
incq %rbx
movl %eax, %ebp
cmpq 0x10(%rsp), %rcx
jb 0x76b3
jmp 0x77aa
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x406a
jmp 0x76d9
movq 0x10(%rsp), %rax
movb $0xa, (%rax)
xorl %eax, %eax
cmpb $0x0, 0x338(%r14)
cmovnel 0x20(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2110
xorps %xmm0, %xmm0
movups %xmm0, 0xc7cf8(%rbx)
movb $0x1, 0xc7d2c(%rbx)
movups %xmm0, 0xc7d08(%rbx)
movups %xmm0, 0xc7d18(%rbx)
movl $0x0, 0xc7d28(%rbx)
movl $0x4040, %edi           # imm = 0x4040
callq 0x21b0
movq %rax, %r15
leaq 0x475c(%rip), %rsi      # 0xc115
movq %rax, %rdi
callq 0x5ba2
movq %r15, 0xc8668(%rbx)
movq %r15, 0xc7d00(%rbx)
xorl %eax, %eax
movq %rax, 0xc7cf8(%rbx)
movq %rax, 0xc7ce0(%rbx)
movl $0xffffffff, 0xc7cf0(%rbx) # imm = 0xFFFFFFFF
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r15
leaq 0x45f0(%rip), %rsi      # 0xbfed
movq %rax, %rdi
callq 0xa2f0
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 0x7a32
movq %rax, %r14
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21c0
jmp 0x7a3f
movq %rax, %r14
movq %rbx, %rdi
callq 0x89bc
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f6c
movq 0xc8668(%rbx), %r14
testq %r14, %r14
je 0x7a84
movq %r14, %rdi
callq 0x5cce
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0xc8668(%rbx)
movq 0xc8670(%rbx), %r14
testq %r14, %r14
je 0x7ab0
movq %r14, %rdi
callq 0xa314
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0xc8670(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x89bc
movq %rax, %rdi
callq 0x3f61
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %edx, %edx
jle 0x7af2
movl %edx, %ecx
xorl %eax, %eax
movb (%rsi,%rax), %dl
testb %dl, %dl
je 0x7aee
movb %dl, (%rdi,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x7ada
movl %ecx, %eax
movl %eax, %ecx
jmp 0x7af4
xorl %ecx, %ecx
leaq (%rdi,%rcx), %rax
movb $0x0, (%rdi,%rcx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
subq %rsi, %rdx
testl %edx, %edx
jle 0x7b36
movl %edx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %eax, %eax
movb (%rsi,%rax), %dil
testb %dil, %dil
je 0x7b32
movb %dil, (%rsp,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x7b1a
movq %rdx, %rax
movl %eax, %eax
jmp 0x7b38
xorl %eax, %eax
movb $0x0, (%rsp,%rax)
leaq 0xb7dd(%rip), %rdi      # 0x13320
leaq 0x44a9(%rip), %rsi      # 0xbff3
movq %rsp, %rdx
callq 0x47e8
movb $0x1, 0xc7d08(%rbx)
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2110
xorps %xmm0, %xmm0
movups %xmm0, 0xc7cf8(%rbx)
movb $0x1, 0xc7d2c(%rbx)
movl $0x4040, %edi           # imm = 0x4040
callq 0x21b0
movq %rax, %r15
leaq 0xc7d2c(%rbx), %rdx
leaq 0x44b3(%rip), %rsi      # 0xc115
movq %rax, %rdi
callq 0x5ea4
movq %r15, 0xc8668(%rbx)
leaq 0xc7ce0(%rbx), %rdi
movq %r15, %rsi
callq 0x3fe2
xorps %xmm0, %xmm0
movups %xmm0, 0xc7d08(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r15
leaq 0x434f(%rip), %rsi      # 0xbfed
movq %rax, %rdi
callq 0xa3ba
movq %r15, 0xc8670(%rbx)
movq %r15, %rdi
callq 0xa58c
movq %rax, 0xc7d10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x2db0, %esi           # imm = 0x2DB0
jmp 0x7cd4
movq %rax, %r14
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21c0
jmp 0x7ce1
movq %rax, %r14
movq %rbx, %rdi
callq 0x89bc
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb5c3(%rip), %rdi      # 0x13320
leaq 0x428f(%rip), %rsi      # 0xbff3
callq 0x4340
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2190
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movl %esi, %eax
imulq $0x3070, %rax, %r13     # imm = 0x3070
addq %r13, %rdi
addq $0x60e, %rdi            # imm = 0x60E
leaq 0xc7ce0(%r14), %r15
movq %r15, %rsi
callq 0x8a62
movq %rax, %r12
testl %r12d, %r12d
je 0x7e26
addq %r13, %r14
addq $0x307, %r14            # imm = 0x307
movl %r12d, %r13d
xorl %ebp, %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x406a
movb %al, (%rbx,%rbp)
incq %rbp
cmpq %rbp, %r13
jne 0x7e10
movl %r12d, %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_O3/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
movq %rsi, %rbx
movl %edx, %eax
imulq $0x24c, %rax, %rax      # imm = 0x24C
leaq (%rdi,%rax), %r14
addq $0xc7d30, %r14          # imm = 0xC7D30
movb $0x0, 0x249(%r14)
movl $0x0, (%r14)
xorl %r12d, %r12d
xorl %r15d, %r15d
movzbl (%rbx,%r15), %edi
leal -0x30(%rdi), %eax
cmpl $0xa, %eax
jb 0x7ed6
callq 0x22a0
testl %eax, %eax
jne 0x7ed6
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 0x7edb
testl %eax, %eax
je 0x7edb
cmpb $0x41, %r12b
jae 0x7ee7
incq %r15
jmp 0x7e72
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2f2c
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8a1d
movzbl %r14b, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3842
xorl %eax, %eax
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpq $0x7ffd, %r14           # imm = 0x7FFD
ja 0x8a45
movl %r14d, %eax
shrl $0x8, %eax
orb $-0x80, %al
movzbl %al, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3842
addq $0x307, %r15            # imm = 0x307
jmp 0x89fe
leaq 0x7(%rsp), %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x2e6f
movb (%r12), %al
jmp 0x8a0f
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x406a
movzwl %ax, %r15d
cmpl $0x80, %r15d
jae 0x8a91
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 0x406a
movzwl %ax, %eax
orq %r15, %rax
cmpq $0xfffd, %rax           # imm = 0xFFFD
ja 0x8abc
andl $0x7fff, %eax           # imm = 0x7FFF
movq %rax, %r15
jmp 0x8a82
cmpl $0xfffe, %eax           # imm = 0xFFFE
jne 0x8afa
addq $0x60e, %r14            # imm = 0x60E
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x406a
movzwl %ax, %eax
movl %r12d, %ecx
shlq %cl, %rax
orq %rax, %r15
addq $0x8, %r12
addq $0x307, %r14            # imm = 0x307
cmpq $0x20, %r12
jne 0x8ad0
jmp 0x8a82
addq $0x122a, %r14           # imm = 0x122A
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x406a
movzwl %ax, %eax
movl %r12d, %ecx
shlq %cl, %rax
orq %rax, %r15
addq $0x8, %r12
addq $0x307, %r14            # imm = 0x307
cmpq $0x40, %r12
jne 0x8b07
jmp 0x8a82
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x12405c(%rdi)
movb $0x0, 0x124064(%rdi)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r14
leaq 0x3551(%rip), %rsi      # 0xc0e0
movq %rax, %rdi
callq 0xa2f0
movq %r14, 0x124068(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r14
leaq 0x3534(%rip), %rsi      # 0xc0e6
movq %rax, %rdi
callq 0xa2f0
movq %r14, 0x124070(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r14
leaq 0x3519(%rip), %rsi      # 0xc0ee
movq %rax, %rdi
callq 0xa2f0
movq %r14, 0x124078(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r14
leaq 0x34fe(%rip), %rsi      # 0xc0f6
movq %rax, %rdi
callq 0xa2f0
movq %r14, 0x124080(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r14
leaq 0x34e3(%rip), %rsi      # 0xc0fe
movq %rax, %rdi
callq 0xa2f0
movq %r14, 0x124088(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r14
leaq 0x34c9(%rip), %rsi      # 0xc107
movq %rax, %rdi
callq 0xa2f0
movq %r14, 0x124090(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r14
leaq 0x34af(%rip), %rsi      # 0xc110
movq %rax, %rdi
callq 0xa2f0
movq %r14, 0x124098(%rbx)
leaq 0xa6a9(%rip), %rax      # 0x13320
movq 0x10(%rax), %rax
movq %rax, 0x124050(%rbx)
movq %rbx, %rdi
callq 0x8ccc
cmpb $0x1, 0x30(%rbx)
jne 0x8c9f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8de2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x8cb3
jmp 0x8cb3
jmp 0x8cb3
jmp 0x8cb3
jmp 0x8cb3
jmp 0x8cb3
movq %rax, %rbx
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rsi
movslq 0x124048(%rdi), %rcx
movq %rsi, %rax
subq %rcx, %rax
cmpl $0x24001, %eax          # imm = 0x24001
jae 0x8dc2
movq %rdi, %rbx
movl $0x24000, %r14d         # imm = 0x24000
cmpl %ecx, %esi
je 0x8d2c
cmpq $0x1, %rax
movq %rax, %rdx
adcq $0x0, %rdx
subq %rsi, %rcx
addq $0x24031, %rcx          # imm = 0x24031
movq %rbx, %rsi
movslq 0x124048(%rbx), %rdi
movb 0x31(%rsi,%rdi), %dil
movb %dil, (%rsi,%rcx)
incq %rsi
decq %rdx
jne 0x8d14
subq %rax, %r14
movq 0x1240a0(%rbx), %rax
testq %rax, %rax
je 0x8d79
leaq 0x1240d0(%rbx), %rcx
movq %rcx, %rdx
cmpq 0x1240a8(%rbx), %rax
jae 0x8d66
movq %rcx, %rdx
movb (%rax), %sil
movb %sil, (%rdx)
incq %rax
incq %rdx
cmpq 0x1240a8(%rbx), %rax
jb 0x8d51
movq %rcx, 0x1240a0(%rbx)
movq %rdx, 0x1240a8(%rbx)
movw $0xa, (%rdx)
leaq 0x24031(%rbx), %rdi
movq 0x124050(%rbx), %rcx
movl $0x1, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x2270
movl %r14d, 0x124048(%rbx)
addl $0x24000, %eax          # imm = 0x24000
movl %eax, 0x12404c(%rbx)
cmpl %r14d, %eax
jne 0x8db3
movb $0x0, 0x30(%rbx)
jmp 0x8dba
incq 0x124040(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3395(%rip), %rdi      # 0xc15e
leaq 0x339f(%rip), %rsi      # 0xc16f
leaq 0x33a1(%rip), %rcx      # 0xc178
movl $0x63, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9354
movl %edx, %ebp
movq %rdi, %rbx
movl %esi, %eax
leaq 0x2e54(%rip), %rcx      # 0xc0b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x124068(%rbx), %rdi
leaq 0x7f25(%rip), %r15      # 0x111a0
movq (%r15), %rsi
subq (%rbx), %rsi
callq 0xa382
movq 0x124068(%rbx), %rdi
movzwl %bp, %r14d
movq %r14, %rsi
callq 0xa382
movq (%r15), %rax
movq %rax, (%rbx)
movl %r14d, 0x12405c(%rbx)
jmp 0x9349
movq 0x124078(%rbx), %rdi
leaq 0x7ee7(%rip), %r14      # 0x111a0
movq (%r14), %rsi
subq 0x10(%rbx), %rsi
callq 0xa382
movq 0x124078(%rbx), %rdi
movzbl %bpl, %esi
callq 0xa49e
movq (%r14), %rax
movq %rax, 0x10(%rbx)
movb %bpl, 0x28(%rbx)
jmp 0x9349
movq 0x124080(%rbx), %rdi
leaq 0x7eb0(%rip), %r14      # 0x111a0
movq (%r14), %rsi
subq 0x18(%rbx), %rsi
callq 0xa382
movq 0x124080(%rbx), %rdi
movzbl %bpl, %esi
callq 0xa49e
movq (%r14), %rax
movq %rax, 0x18(%rbx)
movb %bpl, 0x29(%rbx)
jmp 0x9349
movq 0x124070(%rbx), %rdi
leaq 0x7e79(%rip), %r14      # 0x111a0
movq (%r14), %rsi
subq 0x8(%rbx), %rsi
callq 0xa382
movq 0x124070(%rbx), %rdi
movzwl %bp, %esi
callq 0xa382
movq (%r14), %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x299d(%rip), %rdi      # 0xbcf8
leaq 0x2e0d(%rip), %rsi      # 0xc16f
leaq 0x2e29(%rip), %rcx      # 0xc192
movl $0x9a, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7df5(%rip), %r15      # 0x111a0
movq (%r15), %rsi
subq 0x20(%rbx), %rsi
callq 0xa382
movq (%r15), %rax
movq %rax, 0x20(%rbx)
movl %r14d, 0x124048(%rbx)
cmpl %r14d, 0x12404c(%rbx)
jg 0x93dd
movq %rbx, %rdi
callq 0x8ccc
movl 0x124048(%rbx), %r14d
leal 0x1(%r14), %eax
movl %eax, 0x124048(%rbx)
movslq %r14d, %rax
cmpb $0x40, 0x31(%rbx,%rax)
jne 0x9564
movl 0x124048(%rbx), %eax
cmpl 0x12404c(%rbx), %eax
jl 0x9411
movq %rbx, %rdi
callq 0x8ccc
movl 0x124048(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x124048(%rbx)
cltq
movzbl 0x31(%rbx,%rax), %r14d
movq 0x124098(%rbx), %rdi
movl %r14d, %esi
callq 0xa49e
movb 0x30(%rbx), %al
cmpl $0xa, %r14d
je 0x9443
testb $0x1, %al
jne 0x93f5
callq 0x3102
testb $0x1, %al
je 0x943e
movl 0x124048(%rbx), %eax
cmpl 0x12404c(%rbx), %eax
jl 0x9463
movq %rbx, %rdi
callq 0x8ccc
movl 0x124048(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x124048(%rbx)
cltq
movzbl 0x31(%rbx,%rax), %r14d
movq 0x124088(%rbx), %rdi
movl %r14d, %esi
callq 0xa49e
movb 0x30(%rbx), %al
cmpl $0xa, %r14d
je 0x9495
testb $0x1, %al
jne 0x9447
callq 0x311b
testb $0x1, %al
je 0x9490
movl 0x124048(%rbx), %eax
cmpl 0x12404c(%rbx), %eax
jl 0x94b5
movq %rbx, %rdi
callq 0x8ccc
movl 0x124048(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x124048(%rbx)
cltq
movzbl 0x31(%rbx,%rax), %r14d
movq 0x124098(%rbx), %rdi
movl %r14d, %esi
callq 0xa49e
movb 0x30(%rbx), %al
cmpl $0xa, %r14d
je 0x94e7
testb $0x1, %al
jne 0x9499
callq 0x3134
testb $0x1, %al
je 0x94e2
movl 0x124048(%rbx), %eax
cmpl 0x12404c(%rbx), %eax
jl 0x9507
movq %rbx, %rdi
callq 0x8ccc
movl 0x124048(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x124048(%rbx)
cltq
movzbl 0x31(%rbx,%rax), %r14d
movq 0x124090(%rbx), %rdi
movl %r14d, %esi
callq 0xa49e
movb 0x30(%rbx), %al
cmpl $0xa, %r14d
je 0x9539
testb $0x1, %al
jne 0x94eb
callq 0x314d
testb $0x1, %al
je 0x9534
testb %bpl, %bpl
je 0x9557
incq (%r15)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x956a
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x30e9
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x999b(%rip), %rax      # 0x13320
movb 0xd(%rax), %bpl
leaq 0x3b0(%rsp), %rdi
callq 0x7968
movq %rsp, %rdi
callq 0x6262
leaq 0x60(%rsp), %rdi
callq 0x6e56
testb %bpl, %bpl
movl $0x186a0, %eax          # imm = 0x186A0
movl $0xb2d05e00, %ebp       # imm = 0xB2D05E00
cmovneq %rax, %rbp
leaq 0x77e0(%rip), %r13      # 0x111a0
movq (%r13), %rdx
leaq 0x1(%rdx), %rax
movq %rax, (%r13)
cmpq %rbp, %rax
jae 0x9a9c
movq %rsp, %r14
leaq 0x3b0(%rsp), %r15
leaq 0x60(%rsp), %r12
movq %rbx, %rdi
callq 0x956a
testb %al, %al
je 0x9a95
movq 0x1240c0(%rbx), %rsi
movq 0x1240c8(%rbx), %rdx
movslq 0x12405c(%rbx), %rcx
movslq 0x124060(%rbx), %r8
movq %r14, %rdi
callq 0xa232
movq 0x1240a0(%rbx), %rsi
movq 0x1240a8(%rbx), %rdx
movq 0x1240b0(%rbx), %rcx
movq 0x1240b8(%rbx), %r8
movq %r15, %rdi
callq 0x7eec
movq 0x1240c8(%rbx), %rsi
movslq 0x124060(%rbx), %rdx
leaq 0x98ce(%rip), %rax      # 0x13320
movl 0x4(%rax), %eax
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0x9a67
movq %r12, %rdi
callq 0x71c2
jmp 0x9a7e
cmpl $0x2, %eax
jne 0x9a76
movq %r12, %rdi
callq 0x7120
jmp 0x9a7e
movq %r12, %rdi
callq 0x707e
movq (%r13), %rdx
leaq 0x1(%rdx), %rax
movq %rax, (%r13)
cmpq %rbp, %rax
jb 0x99e5
jmp 0x9a9c
movq (%r13), %rdx
decq %rdx
leaq 0x987d(%rip), %rdi      # 0x13320
leaq 0x2874(%rip), %rsi      # 0xc31e
callq 0x490a
leaq 0x60(%rsp), %rdi
callq 0x6fd8
movq %rsp, %rdi
callq 0x63e6
leaq 0x3b0(%rsp), %rdi
callq 0x7a50
xorl %eax, %eax
addq $0xc8a28, %rsp          # imm = 0xC8A28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9aee
movq %rax, %rbx
jmp 0x9afb
movq %rax, %rbx
jmp 0x9b03
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x6fd8
movq %rsp, %rdi
callq 0x63e6
leaq 0x3b0(%rsp), %rdi
callq 0x7a50
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9da4
movq %r14, %rdi
callq 0xa3de
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x24080(%rbx)
movq 0x24088(%rbx), %r14
testq %r14, %r14
je 0x9dd0
movq %r14, %rdi
callq 0xa3de
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x24088(%rbx)
movq 0x24090(%rbx), %r14
testq %r14, %r14
je 0x9dfc
movq %r14, %rdi
callq 0xa3de
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x24090(%rbx)
movq 0x24098(%rbx), %r14
testq %r14, %r14
je 0x9e28
movq %r14, %rdi
callq 0xa3de
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x24098(%rbx)
movq 0x240a0(%rbx), %r14
testq %r14, %r14
je 0x9e54
movq %r14, %rdi
callq 0xa3de
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x240a0(%rbx)
movq 0x240a8(%rbx), %r14
testq %r14, %r14
je 0x9e80
movq %r14, %rdi
callq 0xa3de
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x240a8(%rbx)
movq 0x240b0(%rbx), %r14
testq %r14, %r14
je 0x9eac
movq %r14, %rdi
callq 0xa3de
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x240b0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Infinidat[P]slimfastq/usrs.cpp
// Function: UsrLoad::update()
void UsrLoad::update() {

    rarely_if(m_last.i_long == g_record_count) {
        UCHAR c = '@';
        fputc(c, m_out);
#define PUT_LINE(X) do { c = X->get_chr(); fputc(c, m_out); } while (c != '\n')
        PUT_LINE(x_lrec);
        PUT_LINE(x_lgen);
        PUT_LINE(x_lrec);
        PUT_LINE(x_lqlt);
#undef PUT_LINE
        m_last.i_long += x_lrec->get();
        g_record_count++;
        return update();
    }

    rarely_if(m_last.i_llen == g_record_count) {
        m_llen = x_llen -> get();
        m_qlen = m_llen;
        m_last.i_llen += x_llen->get();
        m_gen[m_llen+1] = '\n';
        m_gen[m_llen+2] = '+';
    }
    rarely_if(m_last.i_qlen == g_record_count) {
        m_qlen = x_qlen -> get();
        m_last.i_qlen += x_qlen->get();
    }
    else if (m_qlen != m_llen)
        m_qlen = m_llen;
    rarely_if(m_solid and
              m_last.i_sgen == g_record_count) {
        m_last.solid_pf_gen = m_gen[0] = x_sgen->get_chr();
        m_last.i_sgen += x_sgen->get();
    }
    rarely_if(m_solid and
              m_last.i_sqlt == g_record_count) {
        m_last.solid_pf_qlt = m_qlt[0] = x_sqlt->get_chr();
        m_last.i_sqlt += x_sqlt->get();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x72cd(%rip), %r15      # 0x111a0
movq (%r15), %rax
cmpq %rax, 0x20(%rdi)
je 0x9f20
cmpq %rax, (%rbx)
je 0x9f74
cmpq %rax, 0x8(%rbx)
je 0x9f8c
movq 0x38(%rbx), %rcx
cmpq %rcx, 0x48(%rbx)
je 0x9efd
movq %rcx, 0x48(%rbx)
movb 0x51(%rbx), %cl
cmpb $0x1, %cl
jne 0x9f0b
cmpq %rax, 0x10(%rbx)
je 0x9f39
testb $0x1, %cl
je 0x9f16
cmpq %rax, 0x18(%rbx)
je 0x9f66
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x20(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3197
movq (%r14), %rax
jmp 0x9edc
movq 0x24090(%rbx), %rdi
callq 0xa4d8
movb %al, 0x14065(%rbx)
movb %al, 0x28(%rbx)
movq 0x24090(%rbx), %rdi
callq 0xa58c
addq %rax, 0x10(%rbx)
movb 0x51(%rbx), %cl
movq (%r15), %rax
jmp 0x9f0b
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x32dc
jmp 0x9f16
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3280
movq (%r14), %rax
jmp 0x9ee5
movq 0x24088(%rbx), %rdi
callq 0xa58c
movq %rax, 0x48(%rbx)
movq 0x24088(%rbx), %rdi
callq 0xa58c
addq %rax, 0x8(%rbx)
movq (%r15), %rax
jmp 0x9efd
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa03e
movq 0x24078(%rbx), %rsi
movl 0x40(%rbx), %edx
addl 0x38(%rbx), %edx
cmpb $0x1, 0x50(%rbx)
jne 0xa016
movq %rbx, %rdi
callq 0xa03e
movb $0x2b, (%r14)
movl 0x54(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa03e
movb $0x40, (%r14)
jmp 0xa021
addl $0x2, %edx
movq %rbx, %rdi
callq 0xa03e
movl 0x40(%rbx), %edx
addl 0x48(%rbx), %edx
movq 0x24070(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa03e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x1, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x22e0
cmpq %rbx, %rax
jne 0xa067
popq %rbx
retq
callq 0x3314
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9299(%rip), %r14      # 0x13320
leaq 0x2290(%rip), %rsi      # 0xc31e
movq %r14, %rdi
xorl %edx, %edx
callq 0x46e8
movq 0x20(%rbx), %rcx
movq %rax, 0x8(%rsp)
orq %rax, %rcx
je 0xa1f2
movslq 0x8(%r14), %rax
movq %rax, 0x58(%rbx)
leaq 0x3c0(%rsp), %rdi
callq 0x7c22
leaq 0x10(%rsp), %rdi
callq 0x6836
leaq 0x78(%rsp), %rdi
callq 0x733c
leaq 0x4064(%rbx), %r12
leaq 0x14066(%rbx), %r13
leaq 0x61(%rbx), %r15
leaq 0x2062(%rbx), %rbp
leaq 0x70ad(%rip), %r14      # 0x111a0
incq (%r14)
movq %rbx, %rdi
callq 0x9ec0
movq 0x8(%rsp), %rax
cmpq %rax, (%r14)
ja 0xa1a7
cmpb $0x0, 0x60(%rbx)
movq %r15, %rsi
movq %rbp, %rdx
jne 0xa11e
movq %rbp, %rsi
movq %r15, %rdx
incq %rsi
incq %rdx
leaq 0x3c0(%rsp), %rdi
callq 0x8412
movl %eax, 0x54(%rbx)
testl %eax, %eax
je 0xa1dc
movq 0x48(%rbx), %rdx
leaq 0x91d9(%rip), %rax      # 0x13320
movl 0x4(%rax), %eax
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0xa161
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0x7664
jmp 0xa182
cmpl $0x2, %eax
jne 0xa175
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0x75c0
jmp 0xa182
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0x7524
movq 0x38(%rbx), %rcx
movq 0x48(%rbx), %r8
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xa286
movq %rbx, %rdi
callq 0x9fb4
jmp 0xa0f3
leaq 0x78(%rsp), %rdi
callq 0x74aa
leaq 0x10(%rsp), %rdi
callq 0x69a4
leaq 0x3c0(%rsp), %rdi
callq 0x7cf2
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 0x2178(%rip), %rdi      # 0xc363
xorl %eax, %eax
callq 0x2300
callq 0x3323
movq %rax, %rbx
jmp 0xa212
movq %rax, %rbx
jmp 0xa21c
jmp 0xa205
jmp 0xa205
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x74aa
leaq 0x10(%rsp), %rdi
callq 0x69a4
leaq 0x3c0(%rsp), %rdi
callq 0x7cf2
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Infinidat[P]slimfastq/./gens.hpp
// Function: GenSave::save(unsigned char const*, unsigned char*, unsigned long long, unsigned long long)
inline UINT64 get_mask() const {
        switch (conf.level) {
        default:
        case 1: return BRANGER_MASK_1;
        case 2: return BRANGER_MASK_2;
        case 3: return BRANGER_MASK_3;
        case 4: return BRANGER_MASK_4;
        }
    }

// Assembly:
leaq 0x90e7(%rip), %rax      # 0x13320
movl 0x4(%rax), %eax
addl $-0x2, %eax
cmpq %r8, %rcx
jne 0xa265
movl $0x3ffff, %r8d          # imm = 0x3FFFF
cmpl $0x2, %eax
ja 0x652a
movl %eax, %eax
leaq 0x1e6c(%rip), %r8       # 0xc0c8
movq (%r8,%rax,8), %r8
jmp 0x652a
movl $0x3ffff, %r9d          # imm = 0x3FFFF
cmpl $0x2, %eax
ja 0x66a2
movl %eax, %eax
leaq 0x1e4b(%rip), %r9       # 0xc0c8
movq (%r9,%rax,8), %r9
jmp 0x66a2
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa364
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa382
leaq 0x10(%rbx), %rdi
callq 0x3f6c
movq 0x2da8(%rbx), %r14
testq %r14, %r14
je 0xa34c
movq %r14, %rdi
callq 0x5cce
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x2da8(%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x3f6c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xa37a
movq %rax, %rdi
callq 0x3f61
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa424
leaq 0x10(%rbx), %rdi
callq 0x3f6c
movq 0x2da8(%rbx), %r14
testq %r14, %r14
je 0xa40c
movq %r14, %rdi
callq 0x6078
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x2da8(%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x3f6c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xa43a
movq %rax, %rdi
callq 0x3f61
// File: /workspace/github_cpp_makefile_star2_O3/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 0x21b0
movq %rax, %r14
movq (%rbx), %rsi
leaq 0x8(%rbx), %rdx
movq %rax, %rdi
callq 0x5ea4
movq %r14, 0x2da8(%rbx)
cmpb $0x0, 0x8(%rbx)
je 0xa54c
addq $0x10, %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3fe2
movq %r14, %rdi
callq 0x6078
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x2da8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0