LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x66d8
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 0x66aa
movq (%rsp), %rsi
movl %ebp, %edx
callq 0x6b70
movzbl %bl, %edx
movzbl 0x18(%rsp), %eax
testb $0x1, %r12b
jne 0x664d
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 0x6687
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 0x65c6
jmp 0x66d8
movq (%rsp), %rsi
movl $0x3f, %edx
callq 0x6b70
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movl %ebp, %edx
callq 0x3270
movq 0x8(%rsp), %rax
incl 0x348(%rax)
jmp 0x6600
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49a3(%rip), %rsi      # 0xb0cc
movq %rax, %rdi
callq 0x52c6
movq %r14, 0x340(%rbx)
leaq 0xbbe1(%rip), %rax      # 0x12320
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 0x4758(%rip), %xmm1     # 0xaee0
movdqa 0x4760(%rip), %xmm2     # 0xaef0
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 0x67db
movq $0x0, (%rdx)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x67f5
movq $0x0, 0xc7(%rdx)
addq $0x2, %rsi
addq $0x18e, %rdx            # imm = 0x18E
cmpq %rsi, %rcx
jne 0x6798
movq %rax, (%rbx)
leaq 0x310(%rbx), %rdi
movq %r14, %rsi
callq 0x342a
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 0x6837
movq %rax, %r15
addq $0x310, %rbx            # imm = 0x310
movq %rbx, %rdi
callq 0x33be
movq %r15, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x33b3
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6946
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 0x6ce4
cmpb $0x3f, %al
je 0x6938
movl %eax, %ecx
addb $0x21, %cl
movb %cl, (%r15)
movzbl %al, %eax
andl $0x3f, %r13d
shll $0x6, %r13d
orl %eax, %r13d
incq %r15
cmpq %rbp, %r15
jb 0x68ff
jmp 0x6946
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x34b4
jmp 0x6918
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_O1/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 0x69e4
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 0x6ce4
cmpb $0x3f, %al
je 0x69d6
movl %eax, %ecx
addb $0x21, %cl
movb %cl, (%r15)
movzbl %al, %eax
shll $0x6, %r13d
movzwl %r13w, %r13d
orl %eax, %r13d
incq %r15
cmpq %rbp, %r15
jb 0x6995
jmp 0x69e4
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x34b4
jmp 0x69b6
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_O1/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 0x6b4a
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 0x6ce4
cmpb $0x3f, %al
je 0x6b36
leal 0x21(%rax), %ecx
movb %cl, (%r15,%rbx)
movzbl %al, %ecx
movzbl %r12b, %edi
movzbl %bpl, %edx
testb $0x1, %bl
jne 0x6ace
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 0x6b10
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 0x6a53
jmp 0x6b4a
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x34b4
jmp 0x6a79
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_O1/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 0x423c(%rip), %rsi      # 0xb0d5
movq %rax, %rdi
callq 0x4fca
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 0x40d0(%rip), %rsi      # 0xafad
movq %rax, %rdi
callq 0x979c
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 0x6f12
movq %rax, %r14
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21c0
jmp 0x6f1f
movq %rax, %r14
movq %rbx, %rdi
callq 0x7f44
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33be
movq 0xc8668(%rbx), %r14
testq %r14, %r14
je 0x6f64
movq %r14, %rdi
callq 0x50f6
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0xc8668(%rbx)
movq 0xc8670(%rbx), %r14
testq %r14, %r14
je 0x6f90
movq %r14, %rdi
callq 0x97c0
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 0x7f44
movq %rax, %rdi
callq 0x33b3
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6fd2
movl %edx, %ecx
xorl %eax, %eax
movb (%rsi,%rax), %dl
testb %dl, %dl
je 0x6fce
movb %dl, (%rdi,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x6fba
movl %ecx, %eax
movl %eax, %ecx
jmp 0x6fd4
xorl %ecx, %ecx
leaq (%rdi,%rcx), %rax
movb $0x0, (%rdi,%rcx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7016
movl %edx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %eax, %eax
movb (%rsi,%rax), %dil
testb %dil, %dil
je 0x7012
movb %dil, (%rsp,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x6ffa
movq %rdx, %rax
movl %eax, %eax
jmp 0x7018
xorl %eax, %eax
movb $0x0, (%rsp,%rax)
leaq 0xb2fd(%rip), %rdi      # 0x12320
leaq 0x3f89(%rip), %rsi      # 0xafb3
movq %rsp, %rdx
callq 0x3c06
movb $0x1, 0xc7d08(%rbx)
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f93(%rip), %rsi      # 0xb0d5
movq %rax, %rdi
callq 0x52c6
movq %r15, 0xc8668(%rbx)
leaq 0xc7ce0(%rbx), %rdi
movq %r15, %rsi
callq 0x342a
xorps %xmm0, %xmm0
movups %xmm0, 0xc7d08(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r15
leaq 0x3e2f(%rip), %rsi      # 0xafad
movq %rax, %rdi
callq 0x9866
movq %r15, 0xc8670(%rbx)
movq %r15, %rdi
callq 0x9a38
movq %rax, 0xc7d10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x2db0, %esi           # imm = 0x2DB0
jmp 0x71b4
movq %rax, %r14
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21c0
jmp 0x71c1
movq %rax, %r14
movq %rbx, %rdi
callq 0x7f44
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb0e3(%rip), %rdi      # 0x12320
leaq 0x3d6f(%rip), %rsi      # 0xafb3
callq 0x3764
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_O1/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 0x7fea
movq %rax, %r12
testl %r12d, %r12d
je 0x7306
addq %r13, %r14
addq $0x307, %r14            # imm = 0x307
movl %r12d, %r13d
xorl %ebp, %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x34b4
movb %al, (%rbx,%rbp)
incq %rbp
cmpq %rbp, %r13
jne 0x72f0
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_O1/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 %rbx
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 %r15d, %r15d
movzbl (%rbx,%r15), %edi
leal -0x30(%rdi), %eax
cmpl $0xa, %eax
jb 0x73b1
callq 0x22a0
testl %eax, %eax
jne 0x73b1
movzbl 0x249(%r14), %eax
movl %r15d, %ecx
subl (%r14,%rax,4), %ecx
movl %ecx, 0x104(%r14,%rax,4)
movb (%rbx,%r15), %cl
leal 0x1(%rax), %edx
movb %dl, 0x249(%r14)
movb %cl, 0x208(%r14,%rax)
movzbl 0x249(%r14), %eax
leal 0x1(%r15), %ecx
movl %ecx, (%r14,%rax,4)
movzbl (%rbx,%r15), %ecx
cmpl $0xa, %ecx
je 0x73b6
testl %ecx, %ecx
je 0x73b6
cmpb $0x41, %al
jae 0x73bc
incq %r15
jmp 0x734c
popq %rbx
popq %r14
popq %r15
retq
callq 0x28de
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7fa5
movzbl %r14b, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3270
xorl %eax, %eax
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpq $0x7ffd, %r14           # imm = 0x7FFD
ja 0x7fcd
movl %r14d, %eax
shrl $0x8, %eax
orb $-0x80, %al
movzbl %al, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3270
addq $0x307, %r15            # imm = 0x307
jmp 0x7f86
leaq 0x7(%rsp), %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x2801
movb (%r12), %al
jmp 0x7f97
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34b4
movzwl %ax, %r15d
cmpl $0x80, %r15d
jae 0x8019
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 0x34b4
movzwl %ax, %eax
orq %r15, %rax
cmpq $0xfffd, %rax           # imm = 0xFFFD
ja 0x8044
andl $0x7fff, %eax           # imm = 0x7FFF
movq %rax, %r15
jmp 0x800a
cmpl $0xfffe, %eax           # imm = 0xFFFE
jne 0x8082
addq $0x60e, %r14            # imm = 0x60E
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34b4
movzwl %ax, %eax
movl %r12d, %ecx
shlq %cl, %rax
orq %rax, %r15
addq $0x8, %r12
addq $0x307, %r14            # imm = 0x307
cmpq $0x20, %r12
jne 0x8058
jmp 0x800a
addq $0x122a, %r14           # imm = 0x122A
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34b4
movzwl %ax, %eax
movl %r12d, %ecx
shlq %cl, %rax
orq %rax, %r15
addq $0x8, %r12
addq $0x307, %r14            # imm = 0x307
cmpq $0x40, %r12
jne 0x808f
jmp 0x800a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f89(%rip), %rsi      # 0xb0a0
movq %rax, %rdi
callq 0x979c
movq %r14, 0x124068(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r14
leaq 0x2f6c(%rip), %rsi      # 0xb0a6
movq %rax, %rdi
callq 0x979c
movq %r14, 0x124070(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r14
leaq 0x2f51(%rip), %rsi      # 0xb0ae
movq %rax, %rdi
callq 0x979c
movq %r14, 0x124078(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r14
leaq 0x2f36(%rip), %rsi      # 0xb0b6
movq %rax, %rdi
callq 0x979c
movq %r14, 0x124080(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r14
leaq 0x2f1b(%rip), %rsi      # 0xb0be
movq %rax, %rdi
callq 0x979c
movq %r14, 0x124088(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r14
leaq 0x2f01(%rip), %rsi      # 0xb0c7
movq %rax, %rdi
callq 0x979c
movq %r14, 0x124090(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r14
leaq 0x2ee7(%rip), %rsi      # 0xb0d0
movq %rax, %rdi
callq 0x979c
movq %r14, 0x124098(%rbx)
leaq 0xa121(%rip), %rax      # 0x12320
movq 0x10(%rax), %rax
movq %rax, 0x124050(%rbx)
movq %rbx, %rdi
callq 0x8254
cmpb $0x1, 0x30(%rbx)
jne 0x8227
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x836a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x823b
jmp 0x823b
jmp 0x823b
jmp 0x823b
jmp 0x823b
jmp 0x823b
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_O1/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 0x834a
movq %rdi, %rbx
movl $0x24000, %r14d         # imm = 0x24000
cmpl %ecx, %esi
je 0x82b4
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 0x829c
subq %rax, %r14
movq 0x1240a0(%rbx), %rax
testq %rax, %rax
je 0x8301
leaq 0x1240d0(%rbx), %rcx
movq %rcx, %rdx
cmpq 0x1240a8(%rbx), %rax
jae 0x82ee
movq %rcx, %rdx
movb (%rax), %sil
movb %sil, (%rdx)
incq %rax
incq %rdx
cmpq 0x1240a8(%rbx), %rax
jb 0x82d9
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 0x833b
movb $0x0, 0x30(%rbx)
jmp 0x8342
incq 0x124040(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2dcd(%rip), %rdi      # 0xb11e
leaq 0x2dd7(%rip), %rsi      # 0xb12f
leaq 0x2dd9(%rip), %rcx      # 0xb138
movl $0x63, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x88b6
movl %edx, %ebp
movq %rdi, %rbx
movl %esi, %eax
leaq 0x28b2(%rip), %rcx      # 0xb078
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x124068(%rbx), %rdi
leaq 0x79c3(%rip), %r15      # 0x101a0
movq (%r15), %rsi
subq (%rbx), %rsi
callq 0x982e
movq 0x124068(%rbx), %rdi
movzwl %bp, %r14d
movq %r14, %rsi
callq 0x982e
movq (%r15), %rax
movq %rax, (%rbx)
movl %r14d, 0x12405c(%rbx)
jmp 0x88ab
movq 0x124078(%rbx), %rdi
leaq 0x7985(%rip), %r14      # 0x101a0
movq (%r14), %rsi
subq 0x10(%rbx), %rsi
callq 0x982e
movq 0x124078(%rbx), %rdi
movzbl %bpl, %esi
callq 0x994a
movq (%r14), %rax
movq %rax, 0x10(%rbx)
movb %bpl, 0x28(%rbx)
jmp 0x88ab
movq 0x124080(%rbx), %rdi
leaq 0x794e(%rip), %r14      # 0x101a0
movq (%r14), %rsi
subq 0x18(%rbx), %rsi
callq 0x982e
movq 0x124080(%rbx), %rdi
movzbl %bpl, %esi
callq 0x994a
movq (%r14), %rax
movq %rax, 0x18(%rbx)
movb %bpl, 0x29(%rbx)
jmp 0x88ab
movq 0x124070(%rbx), %rdi
leaq 0x7917(%rip), %r14      # 0x101a0
movq (%r14), %rsi
subq 0x8(%rbx), %rsi
callq 0x982e
movq 0x124070(%rbx), %rdi
movzwl %bp, %esi
callq 0x982e
movq (%r14), %rax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23ab(%rip), %rdi      # 0xac68
leaq 0x286b(%rip), %rsi      # 0xb12f
leaq 0x2887(%rip), %rcx      # 0xb152
movl $0x9a, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7893(%rip), %r15      # 0x101a0
movq (%r15), %rsi
subq 0x20(%rbx), %rsi
callq 0x982e
movq (%r15), %rax
movq %rax, 0x20(%rbx)
movl %r14d, 0x124048(%rbx)
cmpl %r14d, 0x12404c(%rbx)
jg 0x8938
movq %rbx, %rdi
callq 0x8254
movslq 0x124048(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x124048(%rbx)
cmpb $0x40, 0x31(%rbx,%rax)
jne 0x8aba
movl 0x124048(%rbx), %eax
cmpl 0x12404c(%rbx), %eax
jl 0x8969
movq %rbx, %rdi
callq 0x8254
movslq 0x124048(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x124048(%rbx)
movzbl 0x31(%rbx,%rax), %r14d
movq 0x124098(%rbx), %rdi
movl %r14d, %esi
callq 0x994a
cmpl $0xa, %r14d
je 0x899a
cmpb $0x0, 0x30(%rbx)
jne 0x8953
cmpb $0x1, 0x30(%rbx)
jne 0x8abf
movl 0x124048(%rbx), %eax
cmpl 0x12404c(%rbx), %eax
jl 0x89ba
movq %rbx, %rdi
callq 0x8254
movslq 0x124048(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x124048(%rbx)
movzbl 0x31(%rbx,%rax), %r14d
movq 0x124088(%rbx), %rdi
movl %r14d, %esi
callq 0x994a
cmpl $0xa, %r14d
je 0x89eb
cmpb $0x0, 0x30(%rbx)
jne 0x89a4
cmpb $0x1, 0x30(%rbx)
jne 0x8ac4
movl 0x124048(%rbx), %eax
cmpl 0x12404c(%rbx), %eax
jl 0x8a0b
movq %rbx, %rdi
callq 0x8254
movslq 0x124048(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x124048(%rbx)
movzbl 0x31(%rbx,%rax), %r14d
movq 0x124098(%rbx), %rdi
movl %r14d, %esi
callq 0x994a
cmpl $0xa, %r14d
je 0x8a3c
cmpb $0x0, 0x30(%rbx)
jne 0x89f5
cmpb $0x1, 0x30(%rbx)
jne 0x8ac9
movl 0x124048(%rbx), %eax
cmpl 0x12404c(%rbx), %eax
jl 0x8a5c
movq %rbx, %rdi
callq 0x8254
movslq 0x124048(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x124048(%rbx)
movzbl 0x31(%rbx,%rax), %r14d
movq 0x124090(%rbx), %rdi
movl %r14d, %esi
callq 0x994a
cmpl $0xa, %r14d
je 0x8a8d
cmpb $0x0, 0x30(%rbx)
jne 0x8a46
cmpb $0x0, 0x30(%rbx)
je 0x8ace
testb %bpl, %bpl
je 0x8aad
incq (%r15)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ad4
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a8a
callq 0x2aa3
callq 0x2abc
callq 0x2ad5
callq 0x2aee
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9495(%rip), %rax      # 0x12320
movb 0xd(%rax), %bpl
leaq 0x3b0(%rsp), %rdi
callq 0x6e48
movq %rsp, %rdi
callq 0x5686
leaq 0x60(%rsp), %rdi
callq 0x6202
testb %bpl, %bpl
movl $0x186a0, %eax          # imm = 0x186A0
movl $0xb2d05e00, %ebp       # imm = 0xB2D05E00
cmovneq %rax, %rbp
leaq 0x72da(%rip), %r13      # 0x101a0
movq (%r13), %rax
incq %rax
movq %rax, (%r13)
cmpq %rbp, %rax
jae 0x8f97
movq %rsp, %r14
leaq 0x3b0(%rsp), %r15
leaq 0x60(%rsp), %r12
movq %rbx, %rdi
callq 0x8ad4
testb %al, %al
je 0x8f97
movq 0x1240c0(%rbx), %rsi
movq 0x1240c8(%rbx), %rdx
movslq 0x12405c(%rbx), %rcx
movslq 0x124060(%rbx), %r8
movq %r14, %rdi
callq 0x96de
movq 0x1240a0(%rbx), %rsi
movq 0x1240a8(%rbx), %rdx
movq 0x1240b0(%rbx), %rcx
movq 0x1240b8(%rbx), %r8
movq %r15, %rdi
callq 0x73c2
movq 0x1240c8(%rbx), %rsi
movslq 0x124060(%rbx), %rdx
leaq 0x93c9(%rip), %rax      # 0x12320
movl 0x4(%rax), %eax
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0x8f6c
movq %r12, %rdi
callq 0x656e
jmp 0x8f83
cmpl $0x2, %eax
jne 0x8f7b
movq %r12, %rdi
callq 0x64cc
jmp 0x8f83
movq %r12, %rdi
callq 0x642a
movq (%r13), %rax
incq %rax
movq %rax, (%r13)
cmpq %rbp, %rax
jb 0x8eea
movq (%r13), %rdx
decq %rdx
leaq 0x937b(%rip), %rdi      # 0x12320
leaq 0x2332(%rip), %rsi      # 0xb2de
callq 0x3d22
leaq 0x60(%rsp), %rdi
callq 0x6384
movq %rsp, %rdi
callq 0x580a
leaq 0x3b0(%rsp), %rdi
callq 0x6f30
xorl %eax, %eax
addq $0xc8a28, %rsp          # imm = 0xC8A28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8ff0
movq %rax, %rbx
jmp 0x8ffd
movq %rax, %rbx
jmp 0x9005
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x6384
movq %rsp, %rdi
callq 0x580a
leaq 0x3b0(%rsp), %rdi
callq 0x6f30
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x92a6
movq %r14, %rdi
callq 0x988a
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x24080(%rbx)
movq 0x24088(%rbx), %r14
testq %r14, %r14
je 0x92d2
movq %r14, %rdi
callq 0x988a
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x24088(%rbx)
movq 0x24090(%rbx), %r14
testq %r14, %r14
je 0x92fe
movq %r14, %rdi
callq 0x988a
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x24090(%rbx)
movq 0x24098(%rbx), %r14
testq %r14, %r14
je 0x932a
movq %r14, %rdi
callq 0x988a
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x24098(%rbx)
movq 0x240a0(%rbx), %r14
testq %r14, %r14
je 0x9356
movq %r14, %rdi
callq 0x988a
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x240a0(%rbx)
movq 0x240a8(%rbx), %r14
testq %r14, %r14
je 0x9382
movq %r14, %rdi
callq 0x988a
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x240a8(%rbx)
movq 0x240b0(%rbx), %r14
testq %r14, %r14
je 0x93ae
movq %r14, %rdi
callq 0x988a
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_O1/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
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
leaq 0x6dcb(%rip), %r15      # 0x101a0
movq (%r15), %rax
cmpq %rax, 0x20(%rbx)
jne 0x93eb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c6e
jmp 0x93d5
cmpq %rax, (%rbx)
je 0x9447
movq 0x8(%rbx), %rax
cmpq (%r15), %rax
je 0x9451
movq 0x38(%rbx), %rax
cmpq %rax, 0x48(%rbx)
je 0x9407
movq %rax, 0x48(%rbx)
cmpb $0x1, 0x51(%rbx)
jne 0x9416
movq (%r15), %rax
cmpq %rax, 0x10(%rbx)
je 0x942b
cmpb $0x1, 0x51(%rbx)
jne 0x9425
movq (%r15), %rax
cmpq %rax, 0x18(%rbx)
je 0x9439
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x2bfe
jmp 0x9416
leaq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x2c36
jmp 0x9425
movq %rbx, %rdi
callq 0x2b8c
jmp 0x93f0
leaq 0x8(%rbx), %rsi
movq %rbx, %rdi
callq 0x2bcd
jmp 0x9407
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x94ea
movq 0x24078(%rbx), %rsi
movl 0x40(%rbx), %edx
addl 0x38(%rbx), %edx
cmpb $0x1, 0x50(%rbx)
jne 0x94c2
movq %rbx, %rdi
callq 0x94ea
movb $0x2b, (%r14)
movl 0x54(%rbx), %edx
incl %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x94ea
movb $0x40, (%r14)
jmp 0x94cd
addl $0x2, %edx
movq %rbx, %rdi
callq 0x94ea
movl 0x40(%rbx), %edx
addl 0x48(%rbx), %edx
movq 0x24070(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x94ea
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9513
popq %rbx
retq
callq 0x2d22
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ded(%rip), %r14      # 0x12320
leaq 0x1da4(%rip), %rsi      # 0xb2de
movq %r14, %rdi
xorl %edx, %edx
callq 0x3b08
movq 0x20(%rbx), %rcx
movq %rax, 0x8(%rsp)
orq %rax, %rcx
je 0x969e
movslq 0x8(%r14), %rax
movq %rax, 0x58(%rbx)
leaq 0x3c0(%rsp), %rdi
callq 0x7102
leaq 0x10(%rsp), %rdi
callq 0x5c0a
leaq 0x78(%rsp), %rdi
callq 0x66e8
leaq 0x4064(%rbx), %r12
leaq 0x14066(%rbx), %r13
leaq 0x61(%rbx), %r15
leaq 0x2062(%rbx), %rbp
leaq 0x6c01(%rip), %r14      # 0x101a0
incq (%r14)
movq %rbx, %rdi
callq 0x93c2
movq 0x8(%rsp), %rax
cmpq %rax, (%r14)
ja 0x9653
cmpb $0x0, 0x60(%rbx)
movq %r15, %rsi
movq %rbp, %rdx
jne 0x95ca
movq %rbp, %rsi
movq %r15, %rdx
incq %rsi
incq %rdx
leaq 0x3c0(%rsp), %rdi
callq 0x793c
movl %eax, 0x54(%rbx)
testl %eax, %eax
je 0x9688
movq 0x48(%rbx), %rdx
leaq 0x8d2d(%rip), %rax      # 0x12320
movl 0x4(%rax), %eax
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jae 0x960d
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0x6a04
jmp 0x962e
cmpl $0x2, %eax
jne 0x9621
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0x6966
jmp 0x962e
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0x68d0
movq 0x38(%rbx), %rcx
movq 0x48(%rbx), %r8
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x9732
movq %rbx, %rdi
callq 0x9460
jmp 0x959f
leaq 0x78(%rsp), %rdi
callq 0x6856
leaq 0x10(%rsp), %rdi
callq 0x5d78
leaq 0x3c0(%rsp), %rdi
callq 0x71d2
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 0x1c8c(%rip), %rdi      # 0xb323
xorl %eax, %eax
callq 0x2320
callq 0x2d31
movq %rax, %rbx
jmp 0x96be
movq %rax, %rbx
jmp 0x96c8
jmp 0x96b1
jmp 0x96b1
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x6856
leaq 0x10(%rsp), %rdi
callq 0x5d78
leaq 0x3c0(%rsp), %rdi
callq 0x71d2
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8c3b(%rip), %rax      # 0x12320
movl 0x4(%rax), %eax
addl $-0x2, %eax
cmpq %r8, %rcx
jne 0x9711
movl $0x3ffff, %r8d          # imm = 0x3FFFF
cmpl $0x2, %eax
ja 0x5938
movl %eax, %eax
leaq 0x1980(%rip), %r8       # 0xb088
movq (%r8,%rax,8), %r8
jmp 0x5938
movl $0x3ffff, %r9d          # imm = 0x3FFFF
cmpl $0x2, %eax
ja 0x5a96
movl %eax, %eax
leaq 0x195f(%rip), %r9       # 0xb088
movq (%r9,%rax,8), %r9
jmp 0x5a96
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9810
movq %rbx, %rdi
xorl %esi, %esi
callq 0x982e
leaq 0x10(%rbx), %rdi
callq 0x33be
movq 0x2da8(%rbx), %r14
testq %r14, %r14
je 0x9805
movq %r14, %rdi
callq 0x50f6
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x2da8(%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x33be
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x9826
movq %rax, %rdi
callq 0x33b3
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98d0
leaq 0x10(%rbx), %rdi
callq 0x33be
movq 0x2da8(%rbx), %r14
testq %r14, %r14
je 0x98c5
movq %r14, %rdi
callq 0x549a
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
movq $0x0, 0x2da8(%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x33be
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x98e6
movq %rax, %rdi
callq 0x33b3
// File: /workspace/github_cpp_makefile_star2_O1/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 0x52c6
movq %r14, 0x2da8(%rbx)
cmpb $0x0, 0x8(%rbx)
je 0x99f8
addq $0x10, %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x342a
movq %r14, %rdi
callq 0x549a
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
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x9a38
movq %rax, %r15
testq %rax, %rax
je 0x9b08
leaq 0x2a9a(%r14), %r12
addq $0x10, %r14
movl $0x1, %ebp
xorl %r13d, %r13d
movq %r12, %rdi
movq %r14, %rsi
callq 0x34b4
movb %al, (%rbx,%r13)
movl %ebp, %r13d
incl %ebp
cmpq %r13, %r15
ja 0x9aef
addq %r15, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop