LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/./coder.hpp
// Function: RCoder::Encode(unsigned int, unsigned int, unsigned int)
void Encode (UINT32 cumFreq, UINT32 freq, UINT32 totFreq) {

        range /= totFreq ;
        low   += cumFreq * range ;
        range *= freq;

        // assert (cumFreq + freq <= totFreq);

        while( range<TOP ) {
            rarely_if ( (low^(low+range)) & (0xffULL<<56) )
                range = ((UINT32(low)|(TOP-1))-UINT32(low));
            m_out->put(low >> 56);
            range <<= 8;
            low   <<= 8;
        }
    }

// Assembly:
pushq %rbx
movl %edx, %r8d
movq %rdi, %rbx
movl 0x10(%rdi), %eax
xorl %edx, %edx
divl %ecx
imull %eax, %esi
addq (%rdi), %rsi
movq %rsi, (%rdi)
imull %eax, %r8d
movl %r8d, 0x10(%rdi)
cmpl $0xffffff, %r8d         # imm = 0xFFFFFF
ja 0x2ade
movl %r8d, %eax
addq %rsi, %rax
xorq %rsi, %rax
shrq $0x38, %rax
jne 0x2ad0
movq 0x20(%rbx), %rdi
shrq $0x38, %rsi
callq 0x2b5c
movl 0x10(%rbx), %r8d
shll $0x8, %r8d
movl %r8d, 0x10(%rbx)
movq (%rbx), %rsi
shlq $0x8, %rsi
movq %rsi, (%rbx)
jmp 0x2a93
movl %esi, %eax
notl %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, 0x10(%rbx)
jmp 0x2aab
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/./power_ranger.hpp
// Function: PowerRanger::update_freq(int)
inline UCHAR update_freq(int i) {

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

            normalize();
        }

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r14
movzwl 0x4(%rdi,%r14,2), %eax
cmpl $0x7fd3, %eax           # imm = 0x7FD3
jae 0x2b31
addl $0xe, %eax
movw %ax, 0x4(%rbx,%r14,2)
addl $0xe, (%rbx)
testl %ebp, %ebp
je 0x2b24
movb 0x206(%rbx), %cl
incb %cl
movb %cl, 0x206(%rbx)
testb $0xf, %cl
jne 0x2b24
cmpw 0x2(%rbx,%r14,2), %ax
ja 0x2b4e
movb 0x207(%rbx,%r14), %al
popq %rbx
popq %r14
popq %rbp
retq
testl %ebp, %ebp
jne 0x2b3e
addl $0x100, %eax            # imm = 0x100
cmpl (%rbx), %eax
ja 0x2b24
movq %rbx, %rdi
callq 0x2ba0
movzwl 0x4(%rbx,%r14,2), %eax
jmp 0x2af9
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x2bca
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/./filer.hpp
// Function: FilerSave::put(unsigned char)
inline bool put(UCHAR c) {
        rarely_if(m_cur >= FILER_PAGE)
            save_page();
        m_buff[m_cur++] = c;
        return m_valid;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x2018(%rdi), %rax
cmpq $0x2000, %rax           # imm = 0x2000
jae 0x2b8d
leaq 0x1(%rax), %rcx
movq %rcx, 0x2018(%rbx)
movb %bpl, 0x9(%rbx,%rax)
movb 0x8(%rbx), %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4148
movq 0x2018(%rbx), %rax
jmp 0x2b73
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/./coder.hpp
// Function: RCoder::Decode(unsigned int, unsigned int, unsigned int)
void Decode (UINT32 cumFreq, UINT32 freq, UINT32 totFreq) {
        UINT32 temp = cumFreq*range;
        low  += temp;
        code -= temp;
        range*= freq;

        while( range<TOP ) {
            rarely_if ( (low^(low+range)) & (0xffULL<<56) )
                range = ((UINT32(low)|(TOP-1))-UINT32(low));
            code <<=8;
            code |= m_in->get();
            range<<=8;
            low  <<=8;
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %edi
imull %edi, %esi
movq (%rbx), %rcx
addq %rsi, %rcx
movq %rcx, (%rbx)
movq 0x8(%rbx), %rax
subq %rsi, %rax
movq %rax, 0x8(%rbx)
imull %edi, %edx
movl %edx, 0x10(%rbx)
cmpl $0xffffff, %edx         # imm = 0xFFFFFF
ja 0x2cb4
movl %edx, %edx
addq %rcx, %rdx
xorq %rcx, %rdx
shrq $0x38, %rdx
jne 0x2ca7
shlq $0x8, %rax
movq %rax, 0x8(%rbx)
movq 0x18(%rbx), %rdi
callq 0x2bfc
movzbl %al, %eax
orq 0x8(%rbx), %rax
movq %rax, 0x8(%rbx)
movl 0x10(%rbx), %edx
shll $0x8, %edx
movl %edx, 0x10(%rbx)
movq (%rbx), %rcx
shlq $0x8, %rcx
movq %rcx, (%rbx)
jmp 0x2c60
notl %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
movl %ecx, 0x10(%rbx)
jmp 0x2c76
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/config.cpp
// Function: Config::get_info(char const*) const
const char* Config::get_info(const char* key) const {
    const char* something = info_map[key].c_str();
    if (0 == strlen(something))
        // croak("%s: no value for '%s'\n", m_info_filename, ke);
        return "";

    return something;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x38e6
leaq 0xc50a(%rip), %rdi      # 0xf1e0
movq %rbx, %rsi
callq 0x3880
movq (%rax), %rbx
leaq 0x10(%rsp), %rdi
callq 0x2110
cmpb $0x0, (%rbx)
leaq 0x6c18(%rip), %rax      # 0x990d
cmovneq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/config.cpp
// Function: Config::statistics_dump() const
void Config::statistics_dump() const {
    fprintf(stderr, ":::: Info ::::\n");
    for (std::map<std::string, std::string>::iterator it = info_map.begin();
         it != info_map.end();
         it ++ )
        fprintf(stderr, "%-16s = %s\n", it->first.c_str(), it->second.c_str());
    fprintf(stderr, "\n:::: Files stream ::::\n");
    FilerLoad::confess();
    exit(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0xc2ad(%rip), %r15      # 0xefd0
movq (%r15), %rcx
leaq 0x6382(%rip), %rdi      # 0x90af
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x2330
movq 0xc4b9(%rip), %r14      # 0xf1f8
leaq 0xc4a2(%rip), %r12      # 0xf1e8
leaq 0x6372(%rip), %rbx      # 0x90bf
movq (%r15), %rax
cmpq %r12, %r14
je 0x2d77
movq 0x20(%r14), %rdx
movq 0x40(%r14), %rcx
movq %rax, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x22a0
movq %r14, %rdi
callq 0x2160
movq %rax, %r14
jmp 0x2d4d
leaq 0x634d(%rip), %rdi      # 0x90cb
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
movq %rax, %rcx
callq 0x2330
callq 0x3f8e
xorl %edi, %edi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/config.cpp
// Function: put_str(FilerSave*, char const*)
void put_str(FilerSave* filer, const char* str) {
    int sanity = 0x200;
    while (*str and --sanity)
        filer->put(*str++);
    if (not sanity)
        croak("oversize string value");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movb (%rbx,%r15), %al
testb %al, %al
je 0x2fec
cmpl $0x1ff, %r15d           # imm = 0x1FF
je 0x2ff2
movzbl %al, %esi
movq %r14, %rdi
callq 0x2b5c
incq %r15
jmp 0x2fcb
popq %rbx
popq %r14
popq %r15
retq
leaq 0x60eb(%rip), %rdi      # 0x90e4
xorl %eax, %eax
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/config.cpp
// Function: Config::set_info(char const*, char const*) const
void Config::set_info(const char* key, const char* val) const {

    put_str(m_info_filer, key);
    m_info_filer->put('=');
    put_str(m_info_filer, val);
    m_info_filer->put('\n');

    info_map.insert(info_pair(key, val));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rdi, %r12
leaq 0x10(%rsp), %rbx
movq %rsi, (%rbx)
leaq 0x8(%rsp), %r14
movq %rdx, (%r14)
movq 0x18(%rdi), %rdi
callq 0x2fbd
movq 0x18(%r12), %rdi
pushq $0x3d
popq %rsi
callq 0x2b5c
movq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0x2fbd
movq 0x18(%r12), %rdi
pushq $0xa
popq %rsi
callq 0x2b5c
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3922
leaq 0xc175(%rip), %rdi      # 0xf1e0
movq %r15, %rsi
callq 0x3aa4
leaq 0x18(%rsp), %rdi
callq 0x386a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x386a
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/config.cpp
// Function: check_fh(_IO_FILE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
static void check_fh(FILE* f, std::string name, bool read=false) {
    if (f) return;
    fprintf(stderr, "Can't %s file '%s': %s\n",
            read?"read":"write", name.c_str(), strerror(errno));
    exit(1);
}

// Assembly:
testq %rdi, %rdi
je 0x3769
retq
pushq %r15
pushq %r14
pushq %rbx
movq 0xb85b(%rip), %rax      # 0xefd0
movq (%rax), %rbx
leaq 0x63fd(%rip), %rax      # 0x9b7c
leaq 0x63fb(%rip), %r14      # 0x9b81
testb %dl, %dl
cmovneq %rax, %r14
movq (%rsi), %r15
callq 0x2060
movl (%rax), %edi
callq 0x20d0
leaq 0x63c2(%rip), %rsi      # 0x9b64
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x22a0
pushq $0x1
popq %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/config.cpp
// Function: Config::finit()
void Config::finit() {
    if (m_info_filer) {
        UINT64 size = FilerSave::finit_size();
        set_info("comp.size", size);
        delete(m_info_filer);
        FilerSave::finit();
        m_info_filer = NULL;
    }
}

// Assembly:
cmpq $0x0, 0x18(%rdi)
je 0x3812
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3f9a
leaq 0x62d3(%rip), %rsi      # 0x9aab
movq %rbx, %rdi
movq %rax, %rdx
callq 0x309e
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x37f4
movq %r14, %rdi
callq 0x411a
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21f0
callq 0x3f72
andq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: FilerSave::init(_IO_FILE*)
void init_write(FILE* out) {
        next_findex = 1;
        m_in  = NULL;
        m_out = out;

        files[0].name = 0;
        files[0].first = 0;
        num_pages = 2;
    }

// Assembly:
movq $0x1, 0xd2e1(%rip) # 0x11228
andq $0x0, 0xd2f1(%rip)      # 0x11240
movq %rdi, 0xd2e2(%rip)      # 0x11238
andq $0x0, 0xb2ba(%rip)      # 0xf218
andl $0x0, 0xb2c3(%rip)      # 0xf228
movq $0x2, 0xd2c0(%rip) # 0x11230
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: FilerLoad::FilerLoad(int, bool*)
FilerBase::FilerBase() {
    m_node_i = 0;
    m_node_p = 0;

    m_valid = true;
    m_cur = m_count = 0;
    m_page_count = 0;
}

// Assembly:
andq $0x0, 0x4030(%rdi)
movb $0x1, 0x8(%rdi)
andq $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x2018(%rdi)
cmpl $0x2a, %esi
jne 0x4563
andl $0x0, 0x4038(%rdi)
movq %rdx, 0x2028(%rdi)
movb $0x1, %al
movb %al, 0x8(%rdi)
movb %al, (%rdx)
jmp 0x43ce
pushq %rax
leaq 0x5647(%rip), %rdi      # 0x9bb2
leaq 0x5650(%rip), %rsi      # 0x9bc2
leaq 0x56f1(%rip), %rcx      # 0x9c6a
movl $0x103, %edx            # imm = 0x103
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: FilerBase::tell() const
size_t FilerBase::tell() const {
    return
        ( m_page_count  ) ?
        ((m_page_count-1) * FILER_PAGE) +
        ( m_cur ) :
        ( m_cur ) ;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x3fdf
shlq $0xd, %rax
movq 0x2018(%rdi), %rcx
addq %rcx, %rax
addq $-0x2000, %rax          # imm = 0xE000
retq
movq 0x2018(%rdi), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: FilerSave::FilerSave(char const*)
FilerSave::FilerSave(const char* name) {
    UINT32 fi = m_onef_i = onef.get_findex();
    onef.files[fi].name = name2u(name);
    onef.files[fi].size = 0;
    onef.files[fi].node = 0;
    onef.files[fi].first = onef.allocate();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x4030(%rdi)
movb $0x1, 0x8(%rdi)
andq $0x0, (%rdi)
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x2018(%rdi)
leaq 0xb1f2(%rip), %r15      # 0xf218
movq %r15, %rdi
callq 0x46be
movl %eax, %ebp
movl %eax, 0x4038(%rbx)
movq %r14, %rdi
callq 0x4076
movl %ebp, %ecx
imulq $0x18, %rcx, %rcx
movq %rax, (%rcx,%r15)
andq $0x0, 0x8(%rcx,%r15)
andl $0x0, 0x14(%rcx,%r15)
movq 0xd1d5(%rip), %rax      # 0x11230
leaq 0x1(%rax), %rdx
movq %rdx, 0xd1ca(%rip)      # 0x11230
movl %eax, 0x10(%rcx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: name2u(char const*)
static UINT64 name2u(const char* name) {
    UINT64 uname ;
    assert(strlen(name) <=8 );
    strncpy((char*)&uname, name, 8);
    return uname;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2100
cmpq $0x9, %rax
jae 0x40a4
movq %rsp, %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2120
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5ca0(%rip), %rdi      # 0x9d4b
leaq 0x5b10(%rip), %rsi      # 0x9bc2
leaq 0x5ca3(%rip), %rcx      # 0x9d5c
movl $0x9a, %edx
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: FilerSave::~FilerSave()
FilerSave::~FilerSave() {
    save_page(true);
    m_valid = false;
    if (m_node_p)
        save_node(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x4148
movb $0x0, 0x8(%rbx)
cmpl $0x0, 0x4034(%rbx)
je 0x413d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x42c8
popq %rbx
retq
movq %rax, %rdi
callq 0x2957
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: FilerSave::save_page(bool)
void FilerSave::save_page(bool finit) {
    if (not m_valid or
        not m_cur)
        return ;

    assert(m_cur <= FILER_PAGE);

    rarely_if (not m_node_p) {
        assert(m_node_i == 0);
        onef.write_page(onef.files[m_onef_i].first, m_buff);
        if (not finit) // (m_cur == FILER_PAGE) // Don't allocate at EOF (harmless in the rare case of exact one page file)
            onef.files[m_onef_i].node = m_node_p =  onef.allocate();
    }
    else {
        onef.write_page(m_node[ m_node_i ++ ], m_buff);
        rarely_if (m_node_i == maxi_nodes and not finit)
            save_node(onef.allocate());
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x420c
movq %rdi, %rbx
movq 0x2018(%rdi), %rax
testq %rax, %rax
je 0x420c
cmpq $0x2001, %rax           # imm = 0x2001
jae 0x4289
movl %esi, %ebp
cmpl $0x0, 0x4034(%rbx)
je 0x4211
movl 0x4030(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4030(%rbx)
movl 0x2030(%rbx,%rax,4), %esi
leaq 0x9(%rbx), %rdx
leaq 0xb073(%rip), %rdi      # 0xf218
callq 0x4712
cmpl $0x7ff, 0x4030(%rbx)    # imm = 0x7FF
setne %al
orb %bpl, %al
je 0x426a
testb %bpl, %bpl
jne 0x41e4
movq 0xd064(%rip), %rax      # 0x11230
leaq 0x1(%rax), %rcx
movq %rcx, 0xd059(%rip)      # 0x11230
movl 0x4030(%rbx), %ecx
movl %eax, 0x2030(%rbx,%rcx,4)
movq 0x2018(%rbx), %rax
movl 0x4038(%rbx), %ecx
imulq $0x18, %rcx, %rcx
leaq 0xb01c(%rip), %rdx      # 0xf218
addq %rax, 0x8(%rcx,%rdx)
andq $0x0, 0x2018(%rbx)
incq (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x0, 0x4030(%rbx)
jne 0x42a8
movl 0x4038(%rbx), %eax
imulq $0x18, %rax, %rax
leaq 0xafe9(%rip), %r14      # 0xf218
movl 0x10(%rax,%r14), %esi
leaq 0x9(%rbx), %rdx
movq %r14, %rdi
callq 0x4712
testb %bpl, %bpl
jne 0x41e4
movq 0xcfe4(%rip), %rcx      # 0x11230
leaq 0x1(%rcx), %rax
movl %ecx, 0x4034(%rbx)
movl 0x4038(%rbx), %edx
imulq $0x18, %rdx, %rdx
movl %ecx, 0x14(%rdx,%r14)
jmp 0x41cc
movq 0xcfbf(%rip), %rsi      # 0x11230
leaq 0x1(%rsi), %rax
movq %rax, 0xcfb4(%rip)      # 0x11230
movq %rbx, %rdi
callq 0x42c8
jmp 0x41c0
leaq 0x5998(%rip), %rdi      # 0x9c28
leaq 0x592b(%rip), %rsi      # 0x9bc2
leaq 0x599e(%rip), %rcx      # 0x9c3c
movl $0xe0, %edx
callq 0x2150
leaq 0x59ad(%rip), %rdi      # 0x9c5c
leaq 0x590c(%rip), %rsi      # 0x9bc2
leaq 0x597f(%rip), %rcx      # 0x9c3c
movl $0xe3, %edx
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: FilerSave::save_node(unsigned int)
void FilerSave::save_node(UINT32 next_node) {
    assert(m_node_i <= maxi_nodes );
    assert(m_node_p);
    m_node[m_node_i ] = next_node;
    onef.write_page(m_node_p, (UCHAR*) m_node);
    m_node_p = next_node;
    m_node_i = 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl 0x4030(%rdi), %eax
cmpq $0x800, %rax            # imm = 0x800
jae 0x431b
movq %rdi, %rbx
cmpl $0x0, 0x4034(%rdi)
je 0x433a
movl %esi, %ebp
leaq 0x2030(%rbx), %rdx
movl %esi, 0x2030(%rbx,%rax,4)
movl 0x4034(%rbx), %esi
leaq 0xaf16(%rip), %rdi      # 0xf218
callq 0x4712
movl %ebp, 0x4034(%rbx)
andl $0x0, 0x4030(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x58c4(%rip), %rdi      # 0x9be6
leaq 0x5899(%rip), %rsi      # 0x9bc2
leaq 0x58cd(%rip), %rcx      # 0x9bfd
movl $0xd3, %edx
callq 0x2150
leaq 0x58de(%rip), %rdi      # 0x9c1f
leaq 0x587a(%rip), %rsi      # 0x9bc2
leaq 0x58ae(%rip), %rcx      # 0x9bfd
movl $0xd4, %edx
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: FilerLoad::FilerLoad(char const*, bool*)
FilerLoad::FilerLoad(const char* name, bool* valid_ptr) {

    m_onef_i = onef.get_findex(name2u(name));
    m_valid_ptr = valid_ptr;
    if (not m_onef_i) {
        *valid_ptr = m_valid = false;
        return;
    }
    * valid_ptr = m_valid = true ;
    load_page();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x4030(%rdi)
movb $0x1, 0x8(%rdi)
andq $0x0, (%rdi)
movq %rdx, %r14
movq %rsi, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x2018(%rbx)
callq 0x4076
leaq 0xae8b(%rip), %rdi      # 0xf218
movq %rax, %rsi
callq 0x4768
movl %eax, 0x4038(%rbx)
movq %r14, 0x2028(%rbx)
testl %eax, %eax
je 0x43bd
movb $0x1, %al
movb %al, 0x8(%rbx)
movb %al, (%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x43ce
xorl %eax, %eax
movb %al, 0x8(%rbx)
movb %al, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: FilerLoad::load_page()
void FilerLoad::load_page() {
    rarely_if(not m_valid)
        return;

    rarely_if (tell() >= onef.files[m_onef_i].size ) {
        *m_valid_ptr = m_valid = false;
        return;                 // EOF
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x8(%rdi)
jne 0x447f
movq %rdi, %rbx
callq 0x3fc2
movl 0x4038(%rbx), %ecx
imulq $0x18, %rcx, %rcx
leaq 0xae23(%rip), %r14      # 0xf218
cmpq 0x8(%rcx,%r14), %rax
jae 0x4487
cmpl $0x0, 0x4034(%rbx)
movl 0x4030(%rbx), %eax
je 0x4497
cmpl $0x7ff, %eax            # imm = 0x7FF
je 0x44e5
leal 0x1(%rax), %ecx
movl %ecx, 0x4030(%rbx)
movl %eax, %eax
movl 0x2030(%rbx,%rax,4), %esi
leaq 0x9(%rbx), %rdx
leaq 0xaddd(%rip), %rdi      # 0xf218
callq 0x47b2
andq $0x0, 0x2018(%rbx)
movl 0x4038(%rbx), %eax
imulq $0x18, %rax, %rax
movq 0x8(%rax,%r14), %rax
movq %rax, %rcx
shrq $0xd, %rcx
movq (%rbx), %rdx
andl $0x1fff, %eax           # imm = 0x1FFF
cmpq %rdx, %rcx
movl $0x2000, %ecx           # imm = 0x2000
cmoveq %rax, %rcx
movq %rcx, 0x2020(%rbx)
incq %rdx
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
movb %al, 0x8(%rbx)
movq 0x2028(%rbx), %rcx
movb %al, (%rcx)
jmp 0x447f
testl %eax, %eax
jne 0x450b
addq %r14, %rcx
movl 0x10(%rcx), %esi
leaq 0x9(%rbx), %rdx
movq %r14, %rdi
callq 0x47b2
movl 0x4038(%rbx), %eax
imulq $0x18, %rax, %rax
movl 0x14(%rax,%r14), %esi
movl %esi, 0x4034(%rbx)
testl %esi, %esi
je 0x44d9
leaq 0x2030(%rbx), %rdx
leaq 0xad44(%rip), %rdi      # 0xf218
callq 0x47b2
andl $0x0, 0x4030(%rbx)
jmp 0x4440
leaq 0x2030(%rbx), %rdx
movl 0x402c(%rbx), %esi
movl %esi, 0x4034(%rbx)
leaq 0xad19(%rip), %rdi      # 0xf218
callq 0x47b2
xorl %eax, %eax
jmp 0x441e
leaq 0x574a(%rip), %rdi      # 0x9c5c
leaq 0x56a9(%rip), %rsi      # 0x9bc2
leaq 0x576c(%rip), %rcx      # 0x9c8c
movl $0x11b, %edx            # imm = 0x11B
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: OneFile::finit_write()
void finit_write() {
        if (m_out) {
            files[0].first = next_findex;
            write_page(1, (UCHAR*)files);
            fclose(m_out);
            m_out = NULL;
        }
    }

// Assembly:
cmpq $0x0, 0x2020(%rdi)
je 0x45df
pushq %rbx
movq %rdi, %rbx
movl 0x2010(%rdi), %eax
movl %eax, 0x10(%rdi)
pushq $0x1
popq %rsi
movq %rdi, %rdx
callq 0x4712
movq 0x2020(%rbx), %rdi
callq 0x21d0
andq $0x0, 0x2020(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: OneFile::init_read(_IO_FILE*)
void init_read(FILE* in) {
        next_findex = 1;
        m_in  = in;
        m_out = NULL;

        read_page(1, (UCHAR*)files);
        next_findex = files[0].first;
        files[0].first = 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq $0x1, 0x2010(%rdi)
movq %rsi, 0x2028(%rdi)
andq $0x0, 0x2020(%rdi)
pushq $0x1
popq %rsi
movq %rdi, %rdx
callq 0x47b2
movl 0x10(%rbx), %eax
movq %rax, 0x2010(%rbx)
andl $0x0, 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: OneFile::do_confess() const
void do_confess() const {
        // i: 'name'       : size  : first : node
        fprintf(stderr, " i: name      : NODES count    : 1st    : 2nd\n");
        for (UINT32 i = 0;
             i < next_findex;
             i++) {
            char name[10];
            strncpy(name, (char*)&files[i].name, 8);
            fprintf(stderr, "%2d: %-10s: %-15lld: %d:\t: %d\n",
                    i, (i? name : "<info>"), files[i].size, files[i].first, files[i].node);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0xa99e(%rip), %rbp      # 0xefd0
movq (%rbp), %rcx
leaq 0x566b(%rip), %rdi      # 0x9ca8
pushq $0x2e
popq %rsi
pushq $0x1
popq %rdx
callq 0x2330
leaq 0xe(%rsp), %r14
leaq 0x5683(%rip), %r12      # 0x9cd7
xorl %eax, %eax
movl %eax, %r13d
cmpq %r13, 0x2010(%rbx)
jbe 0x46af
imulq $0x18, %r13, %r15
leaq (%rbx,%r15), %rsi
movq %r14, %rdi
pushq $0x8
popq %rdx
callq 0x2120
testq %r13, %r13
movq %r14, %rcx
leaq 0x5674(%rip), %rax      # 0x9cf6
cmoveq %rax, %rcx
movq (%rbp), %rdi
movq 0x8(%rbx,%r15), %r8
movl 0x10(%rbx,%r15), %r9d
movl 0x14(%rbx,%r15), %eax
movl %eax, (%rsp)
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x22a0
leal 0x1(%r13), %eax
jmp 0x4656
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: OneFile::get_findex()
UINT32 get_findex() {
        assert(m_out);
        rarely_if(next_findex >= max_root_files)
            croak("Internal error: Too many open files: %d %s", next_findex);
        return next_findex ++;
    }

// Assembly:
pushq %rax
cmpq $0x0, 0x2020(%rdi)
je 0x46f4
movq 0x2010(%rdi), %rax
cmpq $0x155, %rax            # imm = 0x155
jae 0x46e5
leaq 0x1(%rax), %rcx
movq %rcx, 0x2010(%rdi)
popq %rcx
retq
leaq 0x5634(%rip), %rdi      # 0x9d20
movq %rax, %rsi
callq 0x2445
leaq 0x5602(%rip), %rdi      # 0x9cfd
leaq 0x54c0(%rip), %rsi      # 0x9bc2
leaq 0x55fa(%rip), %rcx      # 0x9d03
pushq $0x3f
popq %rdx
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: OneFile::write_page(unsigned int, unsigned char*)
void write_page(UINT32 offset, UCHAR* page) {
        UINT64 offs = offset;
        offs *= FILER_PAGE;
        fseek(m_out, offs, SEEK_SET);
        UINT32 cnt = fwrite(page, 1, FILER_PAGE, m_out);
        if (cnt != FILER_PAGE)
            croak("Failed writing page index %d: %s", offset);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %ebx
movq %rbx, %rsi
shlq $0xd, %rsi
movq 0x2020(%rdi), %rdi
xorl %edx, %edx
callq 0x2220
movq 0x2020(%r15), %rcx
pushq $0x1
popq %rsi
movl $0x2000, %edx           # imm = 0x2000
movq %r14, %rdi
callq 0x2330
cmpl $0x2000, %eax           # imm = 0x2000
jne 0x4758
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5619(%rip), %rdi      # 0x9d78
movq %rbx, %rsi
callq 0x2445
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: OneFile::get_findex(unsigned long long)
UINT32 get_findex(UINT64 name) {
        assert(m_in);
        for(UINT32 i = 1; i < next_findex; i++)
            if (files[i].name == name)
                return i;
        return 0;
    }

// Assembly:
cmpq $0x0, 0x2028(%rdi)
je 0x4794
movq 0x2010(%rdi), %rcx
pushq $0x1
popq %rax
movl %eax, %edx
cmpq %rdx, %rcx
jbe 0x4791
imulq $0x18, %rdx, %rdx
cmpq %rsi, (%rdi,%rdx)
je 0x4793
incl %eax
jmp 0x477c
xorl %eax, %eax
retq
pushq %rax
leaq 0x55fd(%rip), %rdi      # 0x9d99
leaq 0x541f(%rip), %rsi      # 0x9bc2
leaq 0x55f4(%rip), %rcx      # 0x9d9e
pushq $0x45
popq %rdx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/filer.cpp
// Function: OneFile::read_page(unsigned int, unsigned char*)
void read_page(UINT32 offset, UCHAR* page) {
        // Note: -D_FILE_OFFSET_BITS=64 is required
        UINT64 offs = offset;
        offs *= FILER_PAGE;
        fseek(m_in, offs , SEEK_SET);
        UINT32 cnt = fread(page, 1, FILER_PAGE, m_in);
        if (cnt != FILER_PAGE)
            croak("Failed reading page index %d: %s", offset);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %ebx
movq %rbx, %rsi
shlq $0xd, %rsi
movq 0x2028(%rdi), %rdi
xorl %edx, %edx
callq 0x2220
movq 0x2028(%r15), %rcx
pushq $0x1
popq %rsi
movl $0x2000, %edx           # imm = 0x2000
movq %r14, %rdi
callq 0x22c0
cmpl $0x2000, %eax           # imm = 0x2000
jne 0x47f8
popq %rbx
popq %r14
popq %r15
retq
leaq 0x55c2(%rip), %rdi      # 0x9dc1
movq %rbx, %rsi
callq 0x2445
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/gens.cpp
// Function: GenSave::GenSave()
GenSave::GenSave() {

    BZERO(m_stats);
    BZERO(m_last);
    m_N_byte = 0;

    filer = new FilerSave("gen");
    assert(filer);
    rcoder.init(filer);
    ranger = new Base2Ranger[ranger_cnt()];
    range_init();

    x_Ns = new XFileSave("gen.Ns");
    x_Nn = new XFileSave("gen.Nn");

   memset(gencodes, 0x10, sizeof(gencodes));
   gencodes[(UINT8)'0'] = gencodes[(UINT8)'A'] = gencodes[(UINT8)'a'] = 0;
   gencodes[(UINT8)'1'] = gencodes[(UINT8)'C'] = gencodes[(UINT8)'c'] = 1;
   gencodes[(UINT8)'2'] = gencodes[(UINT8)'G'] = gencodes[(UINT8)'g'] = 2;
   gencodes[(UINT8)'3'] = gencodes[(UINT8)'T'] = gencodes[(UINT8)'t'] = 3;
   gencodes[(UINT8)'.'] = gencodes[(UINT8)'N'] = gencodes[(UINT8)'n'] = 4;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0x45(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
andl $0x0, 0x40(%rdi)
movl $0x4040, %edi           # imm = 0x4040
callq 0x21e0
movq %rax, %r15
leaq 0x5826(%rip), %rsi      # 0xa083
movq %rax, %rdi
callq 0x3ff8
movq %r15, 0x48(%rbx)
movq %r15, 0x28(%rbx)
andq $0x0, 0x20(%rbx)
andq $0x0, 0x8(%rbx)
orl $-0x1, 0x18(%rbx)
callq 0x4808
movq %rax, %r14
shlq $0x2, %r14
movq %r14, %rdi
callq 0x2040
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2130
movq %r15, (%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21e0
movq %rax, %r15
leaq 0x552b(%rip), %rsi      # 0x9de2
movq %rax, %rdi
callq 0x8534
movq %r15, 0x50(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21e0
movq %rax, %r15
leaq 0x5512(%rip), %rsi      # 0x9de9
movq %rax, %rdi
callq 0x8534
movq %r15, 0x58(%rbx)
leaq 0xc966(%rip), %rdi      # 0x11250
pushq $0x10
popq %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x2130
xorl %eax, %eax
movb %al, 0xc9b2(%rip)       # 0x112b1
movb %al, 0xc98c(%rip)       # 0x11291
movb $0x1, %al
movb %al, 0xc9a6(%rip)       # 0x112b3
movb %al, 0xc980(%rip)       # 0x11293
movb $0x2, %al
movb %al, 0xc99c(%rip)       # 0x112b7
movb %al, 0xc976(%rip)       # 0x11297
movb $0x3, %al
movb %al, 0xc99b(%rip)       # 0x112c4
movb %al, 0xc975(%rip)       # 0x112a4
movl $0x3020100, 0xc947(%rip) # imm = 0x3020100
movb $0x4, %al
movb %al, 0xc97d(%rip)       # 0x112be
movb %al, 0xc957(%rip)       # 0x1129e
movb %al, 0xc931(%rip)       # 0x1127e
popq %rbx
popq %r14
popq %r15
retq
jmp 0x4955
movq %rax, %r14
movl $0x2db0, %esi           # imm = 0x2DB0
jmp 0x4967
movq %rax, %r14
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21f0
jmp 0x4974
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x28d4
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/gens.cpp
// Function: GenSave::~GenSave()
GenSave::~GenSave() {
    rcoder.done();
    if (not conf.quiet) {
    }
    delete []ranger;
    delete filer;

    DELETE(x_Ns);
    DELETE(x_Nn);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x2962
movq (%r14), %rdi
testq %rdi, %rdi
je 0x49a9
callq 0x2260
movq 0x48(%r14), %r15
testq %r15, %r15
je 0x49ba
movq %r15, %rdi
callq 0x411a
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21f0
movq 0x50(%r14), %r15
testq %r15, %r15
je 0x49e5
movq %r15, %rdi
callq 0x8556
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r15, %rdi
callq 0x21f0
andq $0x0, 0x50(%r14)
movq 0x58(%r14), %r15
testq %r15, %r15
je 0x4a08
movq %r15, %rdi
callq 0x8556
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r15, %rdi
callq 0x21f0
andq $0x0, 0x58(%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x28d4
movq %rax, %rdi
callq 0x2957
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/gens.cpp
// Function: GenSave::bad_q_or_bad_n(unsigned char, unsigned char, bool, bool)
void GenSave::bad_q_or_bad_n(UCHAR gen, UCHAR qlt, bool bad_n, bool bad_q)
{
    if (not bad_n) {
        // bad_q only
        x_Nn->put(g_genofs_count - m_last.Nn_index);
        m_last.Nn_index = g_genofs_count;
        return;
    }

    rarely_if(not m_N_byte) {
        // TODO: make a single m_last - exceptions file
        m_N_byte = gen;
        if ('N' != gen)
            conf.set_info("gen.N_byte", gen);
    }
    // TODO: eliminate this temp sanity
    rarely_if (gen != m_N_byte)
        croak("switched N_byte: %c", gen);

    if (not bad_q) {
        x_Ns->put(g_genofs_count - m_last.Ns_index);
        m_last.Ns_index = g_genofs_count ;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %ecx, %ecx
je 0x4a53
movl %r8d, %ebp
movl %esi, %r15d
movb 0x45(%rbx), %al
movzbl %r15b, %r14d
testb %al, %al
je 0x4a83
cmpb %r15b, %al
jne 0x4aaa
testb %bpl, %bpl
jne 0x4a78
pushq $0x30
popq %r14
pushq $0x50
jmp 0x4a59
pushq $0x38
popq %r14
pushq $0x58
popq %rax
movq (%rbx,%rax), %rdi
leaq 0xa773(%rip), %r15      # 0xf1d8
movq (%r15), %rsi
subq (%rbx,%r14), %rsi
callq 0x85be
movq (%r15), %rax
movq %rax, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb %r15b, 0x45(%rbx)
movb $0x4e, %al
cmpb $0x4e, %r15b
je 0x4a41
leaq 0xc8ba(%rip), %rdi      # 0x11350
leaq 0x5353(%rip), %rsi      # 0x9df0
movq %r14, %rdx
callq 0x309e
movb 0x45(%rbx), %al
jmp 0x4a41
leaq 0x534a(%rip), %rdi      # 0x9dfb
movl %r14d, %esi
xorl %eax, %eax
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/gens.cpp
// Function: GenSave::save_x(unsigned char const*, unsigned char const*, unsigned long long, unsigned long long)
void GenSave::save_x(const UCHAR* gen, const UCHAR* qlt, UINT64 size, const UINT64 mask) {
    UINT32 last = 0x007616c7;
    const UCHAR* g = gen; const UCHAR* q = qlt;
    for (; g < gen + size ; g++, q++) {
        UCHAR n = normalize_gen(*g, *q);
        last &= mask;
        PREFETCH(ranger + last);
        ranger[last].put(&rcoder, n);
        last = ((last<<2) | n);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
addq %rsi, %rcx
movq %rcx, 0x10(%rsp)
movl %r8d, %eax
movq %rax, 0x8(%rsp)
leaq 0x8(%rdi), %r13
movl $0x7616c7, %ebx         # imm = 0x7616C7
cmpq 0x10(%rsp), %r15
jae 0x4b2e
movzbl (%r15), %esi
movzbl (%r14), %edx
movq %r12, %rdi
callq 0x4ef2
andl 0x8(%rsp), %ebx
movq (%r12), %rcx
leaq (%rcx,%rbx,4), %rdi
prefetcht0 (%rdi)
movzbl %al, %ebp
movq %r13, %rsi
movl %ebp, %edx
callq 0x4f52
shlq $0x2, %rbx
orq %rbp, %rbx
incq %r15
incq %r14
jmp 0x4aec
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/gens.cpp
// Function: GenSave::save_x(unsigned char const*, unsigned char const*, unsigned long long, unsigned long long, unsigned long long)
void GenSave::save_x(const UCHAR* gen, const UCHAR* qlt, UINT64 llen, UINT64 qlen, const UINT64 mask) {
    UINT32 last = 0x007616c7;
    for (UINT32 i = 0; i < llen; i++) {
        UCHAR n = normalize_gen(gen[i], i < qlen ? qlt[i] : 40);
        last &= mask;
        PREFETCH(ranger + last);
        ranger[last].put(&rcoder, n);
        last = ((last<<2) | n);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movl %r9d, %ebx
leaq 0x8(%rdi), %rbp
movl $0x7616c7, %r12d        # imm = 0x7616C7
xorl %eax, %eax
movl %eax, %r14d
cmpq 0x20(%rsp), %r14
jae 0x4bcd
movb $0x28, %al
cmpq 0x18(%rsp), %r14
jae 0x4b8e
movq 0x8(%rsp), %rax
movb (%rax,%r14), %al
movq 0x10(%rsp), %rcx
movzbl (%rcx,%r14), %esi
movzbl %al, %edx
movq %r13, %rdi
callq 0x4ef2
andl %ebx, %r12d
movq (%r13), %rcx
leaq (%rcx,%r12,4), %rdi
prefetcht0 (%rdi)
movzbl %al, %r15d
movq %rbp, %rsi
movl %r15d, %edx
callq 0x4f52
shlq $0x2, %r12
orq %r15, %r12
leal 0x1(%r14), %eax
jmp 0x4b72
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/gens.cpp
// Function: GenLoad::GenLoad()
GenLoad::GenLoad() {
    BZERO(m_last);
    m_valid = true;

    m_N_byte          = conf.get_long("gen.N_byte", 'N') ;
    bool is_solid     = conf.get_bool("usr.solid");
    bool is_lowercase = false;

    m_gencode =
        is_solid ?
        "0123" :
        is_lowercase ?
        "acgt" :
        "ACGT" ;

    filer = new FilerLoad("gen", &m_valid);
    assert(filer);
    rcoder.init(filer);
    ranger = new Base2Ranger[ranger_cnt()];
    range_init();

    x_Ns = new XFileLoad("gen.Ns");
    x_Nn = new XFileLoad("gen.Nn");
    m_last.Ns_index = x_Ns->get();
    m_last.Nn_index = x_Nn->get();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movb $0x1, 0x44(%rdi)
leaq 0xc756(%rip), %rdi      # 0x11350
leaq 0x51ef(%rip), %rsi      # 0x9df0
pushq $0x4e
popq %rdx
callq 0x2f54
movb %al, 0x45(%rbx)
leaq 0xc73d(%rip), %rdi      # 0x11350
leaq 0x51f5(%rip), %rsi      # 0x9e0f
callq 0x2ef8
leaq 0x51f3(%rip), %rcx      # 0x9e19
leaq 0x51f1(%rip), %rdx      # 0x9e1e
testb %al, %al
cmovneq %rcx, %rdx
movq %rdx, 0x48(%rbx)
movl $0x4040, %edi           # imm = 0x4040
callq 0x21e0
movq %rax, %r15
leaq 0x44(%rbx), %rdx
leaq 0x5434(%rip), %rsi      # 0xa083
movq %rax, %rdi
callq 0x435a
movq %r15, 0x50(%rbx)
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x2996
callq 0x4808
movq %rax, %r14
shlq $0x2, %r14
movq %r14, %rdi
callq 0x2040
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2130
movq %r15, (%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21e0
movq %rax, %r15
leaq 0x513f(%rip), %rsi      # 0x9de2
movq %rax, %rdi
callq 0x85f6
movq %r15, 0x58(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21e0
movq %rax, %r15
leaq 0x5126(%rip), %rsi      # 0x9de9
movq %rax, %rdi
callq 0x85f6
movq %r15, 0x60(%rbx)
movq 0x58(%rbx), %rdi
callq 0x87ba
movq %rax, 0x30(%rbx)
movq 0x60(%rbx), %rdi
callq 0x87ba
movq %rax, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
jmp 0x4cf1
movq %rax, %r14
movl $0x2db0, %esi           # imm = 0x2DB0
jmp 0x4d03
movq %rax, %r14
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21f0
jmp 0x4d14
jmp 0x4d11
jmp 0x4d11
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x28d4
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/gens.cpp
// Function: GenLoad::~GenLoad()
GenLoad::~GenLoad() {
    rcoder.done();
    delete []ranger;
    delete   filer;
    DELETE(x_Ns);
    DELETE(x_Nn);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x2962
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4d49
callq 0x2260
movq 0x50(%r14), %r15
testq %r15, %r15
je 0x4d5a
movq %r15, %rdi
callq 0x4584
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21f0
movq 0x58(%r14), %r15
testq %r15, %r15
je 0x4d85
movq %r15, %rdi
callq 0x8618
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r15, %rdi
callq 0x21f0
andq $0x0, 0x58(%r14)
movq 0x60(%r14), %r15
testq %r15, %r15
je 0x4da8
movq %r15, %rdi
callq 0x8618
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r15, %rdi
callq 0x21f0
andq $0x0, 0x60(%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x28d4
movq %rax, %rdi
callq 0x2957
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/gens.cpp
// Function: GenLoad::load_x(unsigned char*, unsigned char const*, unsigned long long, unsigned long long)
UINT32 GenLoad::load_x(UCHAR* gen, const UCHAR* qlt, UINT64 size, const UINT64 mask) {

    UINT32 last = 0x007616c7;

    UCHAR* g = gen; const UCHAR* q = qlt;
    for (; g < gen + size ; g++, q++) {
        last &= mask ;
        PREFETCH(ranger + last);
        UCHAR b = ranger[last].get(&rcoder);

        *g = m_gencode [ b ];
        last = ((last<<2) + b);
        normalize_gen(*g, *q);
    }

    return m_valid ? size : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rcx, 0x8(%rsp)
leaq (%rsi,%rcx), %rbp
movl %r8d, %eax
movq %rax, 0x10(%rsp)
leaq 0x8(%rdi), %r13
movl $0x7616c7, %ebx         # imm = 0x7616C7
cmpq %rbp, %r12
jae 0x4e37
andl 0x10(%rsp), %ebx
movq (%r14), %rax
leaq (%rax,%rbx,4), %rdi
prefetcht0 (%rdi)
movq %r13, %rsi
callq 0x4fae
movq 0x48(%r14), %rcx
movzbl %al, %eax
movb (%rcx,%rax), %cl
movb %cl, (%r12)
leaq (%rax,%rbx,4), %rbx
movzbl (%r15), %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x503c
incq %r12
incq %r15
jmp 0x4df3
xorl %eax, %eax
cmpb $0x0, 0x44(%r14)
cmovnel 0x8(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/gens.cpp
// Function: GenLoad::load_x(unsigned char*, unsigned char const*, unsigned long long, unsigned long long, unsigned long long)
UINT32 GenLoad::load_x(UCHAR* gen, const UCHAR* qlt, UINT64 llen, UINT64 qlen, const UINT64 mask) {
    // rare: mismatch qlt/gen line sizes. This typically happens when padding the gen line. In this
    // case, assume valid base.
    UINT32 last = 0x007616c7;

    for (UINT32 i = 0; i < llen; i++) {
        last &= mask ;
        PREFETCH(ranger + last);
        UCHAR b = ranger[last].get(&rcoder);

        gen[i] = m_gencode[ b ];
        last = ((last<<2) + b);
        normalize_gen(gen[i], i < qlen ? qlt[i] : 40);
    }

    return m_valid ? llen : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, (%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r13
movq %rdi, %r15
movl %r9d, %r12d
leaq 0x8(%rdi), %rbp
movl $0x7616c7, %r14d        # imm = 0x7616C7
xorl %ebx, %ebx
movl %ebx, %ebx
cmpq (%rsp), %rbx
jae 0x4ed7
andl %r12d, %r14d
movq (%r15), %rax
leaq (%rax,%r14,4), %rdi
prefetcht0 (%rdi)
movq %rbp, %rsi
callq 0x4fae
movq 0x48(%r15), %rcx
movzbl %al, %eax
movb (%rcx,%rax), %cl
movb %cl, (%r13,%rbx)
movb $0x28, %cl
cmpq 0x10(%rsp), %rbx
jae 0x4ec0
movq 0x8(%rsp), %rcx
movb (%rcx,%rbx), %cl
leaq (%rbx,%r13), %rsi
leaq (%rax,%r14,4), %r14
movzbl %cl, %edx
movq %r15, %rdi
callq 0x503c
incl %ebx
jmp 0x4e83
xorl %eax, %eax
cmpb $0x0, 0x44(%r15)
cmovnel (%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/gens.cpp
// Function: GenSave::normalize_gen(unsigned char, unsigned char)
inline UCHAR GenSave::normalize_gen(UCHAR gen, UCHAR qlt) {

    bool bad_n; //  = false;
    const bool bad_q = qlt == '!';

    UCHAR n = gencodes[gen];
    likely_if (n <= 3)
        bad_n = false;
    else {
        rarely_if( n > 4)
            croak("unexpected genome char: %c", gen);
        bad_n = true;
        n = 0;
    }

// Assembly:
pushq %rbx
movl %esi, %eax
leaq 0xc354(%rip), %rcx      # 0x11250
movb (%rax,%rcx), %al
movl %eax, %ebx
cmpb $0x4, %al
jae 0x4f1c
leaq 0xa2cc(%rip), %rcx      # 0xf1d8
incq (%rcx)
cmpb $0x21, %dl
je 0x4f22
cmpb $0x4, %al
jae 0x4f22
movl %ebx, %eax
popq %rbx
retq
jne 0x4f40
xorl %ebx, %ebx
jmp 0x4f05
xorl %ecx, %ecx
cmpb $0x4, %al
setae %cl
xorl %r8d, %r8d
cmpb $0x21, %dl
sete %r8b
movzbl %sil, %esi
xorl %edx, %edx
callq 0x4a22
jmp 0x4f18
movzbl %sil, %esi
leaq 0x4ed8(%rip), %rdi      # 0x9e23
xorl %eax, %eax
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/./base2_ranger.hpp
// Function: Base2Ranger::put(RCoder*, unsigned char)
inline void put(RCoder *rc, UCHAR sym) {
        UINT16 total = getsum();
        UINT16 offs = 0;
        switch(sym) {
        case 3: offs += freq[2];
        case 2: offs += freq[1];
        case 1: offs += freq[0];
        }
        rc->Encode( offs, freq[sym], total);
        update_freq(sym, total);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movzbl (%rdi), %edi
movzbl 0x1(%rbx), %ecx
movzbl 0x2(%rbx), %ebp
movzbl 0x3(%rbx), %r8d
xorl %esi, %esi
cmpl $0x1, %edx
je 0x4f81
cmpl $0x2, %edx
je 0x4f7f
cmpl $0x3, %edx
jne 0x4f83
movl %ebp, %esi
addl %ecx, %esi
addl %edi, %esi
addl %edi, %ecx
addl %r8d, %ebp
addl %ecx, %ebp
movzbl %dl, %r14d
movzbl (%rbx,%r14), %edx
movq %rax, %rdi
movl %ebp, %ecx
callq 0x2a74
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x508e
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/./base2_ranger.hpp
// Function: Base2Ranger::get(RCoder*)
inline UCHAR get(RCoder *rc) {

        UINT16 total = getsum();
        UINT32 prob = rc->GetFreq(total);

        UINT32 sumf = 0;
        int i;
        for (i = 0; i < 4; i++) {
            if (sumf +  freq[i] <= prob)
                sumf += freq[i];
            else
                break;
        }
        assert(i<4);
        rc->Decode(sumf, freq[i], total);

        update_freq(i, total);
        return i;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %eax
movzbl 0x1(%rdi), %ecx
addl %eax, %ecx
movzbl 0x2(%rdi), %eax
movzbl 0x3(%rdi), %ebp
addl %eax, %ebp
addl %ecx, %ebp
movl 0x10(%rsi), %eax
xorl %r14d, %r14d
xorl %edx, %edx
divl %ebp
movl %eax, %ecx
movl %eax, 0x10(%rsi)
movq 0x8(%rsi), %rax
xorl %edx, %edx
divq %rcx
xorl %ecx, %ecx
cmpq $0x4, %r14
je 0x501f
movzbl (%rbx,%r14), %edx
leal (%rcx,%rdx), %edi
cmpl %eax, %edi
ja 0x4ffd
incq %r14
movl %edi, %ecx
jmp 0x4fe4
movq %rsi, %rdi
movl %ecx, %esi
movl %ebp, %ecx
callq 0x2c3c
movzwl %bp, %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x508e
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4e18(%rip), %rdi      # 0x9e3e
leaq 0x4e15(%rip), %rsi      # 0x9e42
leaq 0x4e21(%rip), %rcx      # 0x9e55
pushq $0x63
popq %rdx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/gens.cpp
// Function: GenLoad::normalize_gen(unsigned char&, unsigned char)
void GenLoad::normalize_gen(UCHAR & gen, UCHAR qlt) {
    g_genofs_count ++ ;

    rarely_if (m_last.Nn_index == g_genofs_count)
        m_last.Nn_index += x_Nn->get();

    else rarely_if (qlt == '!')
        gen = m_N_byte;

    else rarely_if (m_last.Ns_index == g_genofs_count) {
        gen = m_N_byte;
        m_last.Ns_index += x_Ns->get();
   }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xa191(%rip), %rcx      # 0xf1d8
movq (%rcx), %rax
incq %rax
movq %rax, (%rcx)
cmpq %rax, 0x38(%rdi)
je 0x5063
cmpb $0x21, %dl
je 0x5072
cmpq %rax, 0x30(%rbx)
je 0x5079
popq %rbx
retq
movq 0x60(%rbx), %rdi
callq 0x87ba
addq %rax, 0x38(%rbx)
jmp 0x5061
movb 0x45(%rbx), %al
movb %al, (%rsi)
jmp 0x5061
movb 0x45(%rbx), %al
movb %al, (%rsi)
movq 0x58(%rbx), %rdi
callq 0x87ba
addq %rax, 0x30(%rbx)
jmp 0x5061
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/./base2_ranger.hpp
// Function: Base2Ranger::update_freq(int, unsigned short)
inline void update_freq(int sym , UINT16 total) {
        rarely_if(freq[sym] > (MAX_FREQ))
            normalize();

        // freq[sym] += STEP;
        freq[sym]++;
    }

// Assembly:
movslq %esi, %rax
movb (%rdi,%rax), %cl
cmpb $-0x1, %cl
je 0x509f
incb %cl
movb %cl, (%rdi,%rax)
retq
movl (%rdi), %ecx
movl %ecx, %edx
shrl %edx
andl $0x7f7f7f7f, %edx       # imm = 0x7F7F7F7F
andl $0x1010101, %ecx        # imm = 0x1010101
orl %edx, %ecx
movl %ecx, (%rdi)
movb (%rdi,%rax), %cl
jmp 0x5099
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/main.cpp
// Function: main
int main(int argc, char** argv) {

    conf.init(argc, argv);
    int ret =
        conf.encode ?
        UsrSave () . encode() :
        UsrLoad () . decode() ;

    conf.finit();
    return ret;
}

// Assembly:
pushq %rbx
subq $0x1480d0, %rsp         # imm = 0x1480D0
movq %rsi, %rdx
movl %edi, %esi
leaq 0xc280(%rip), %rdi      # 0x11350
callq 0x310e
cmpb $0x1, 0xc280(%rip)      # 0x1135c
jne 0x50fd
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x6dd8
movq %rbx, %rdi
callq 0x7a46
movl %eax, %ebx
movq %rsp, %rdi
callq 0x729a
jmp 0x5117
movq %rsp, %rdi
callq 0x7bae
movq %rsp, %rdi
callq 0x81d8
movl %eax, %ebx
movq %rsp, %rdi
callq 0x7e0e
leaq 0xc232(%rip), %rdi      # 0x11350
callq 0x37be
movl %ebx, %eax
addq $0x1480d0, %rsp         # imm = 0x1480D0
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7e0e
jmp 0x514b
movq %rax, %rbx
jmp 0x514b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x729a
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/Infinidat[P]slimfastq/qlts.cpp
// Function: QltSave::QltSave()
QltSave::QltSave()  {
    filer  = new FilerSave("qlt");
    ranger = new Log64Ranger[ranger_cnt()];
    assert(filer);
    assert(ranger);
    rcoder.init(filer);
    BZERO(m_last);
    // range_init();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rdi
movl $0x307, %edx            # imm = 0x307
xorl %esi, %esi
callq 0x2130
xorps %xmm0, %xmm0
movups %xmm0, 0x328(%rbx)
movl $0x4040, %edi           # imm = 0x4040
callq 0x21e0
movq %rax, %r14
leaq 0x4ee6(%rip), %rsi      # 0xa08c
movq %rax, %rdi
callq 0x3ff8
movq %r14, 0x340(%rbx)
leaq 0xc194(%rip), %rax      # 0x11350
movl 0x4(%rax), %ebp
cmpl $0x1, %ebp
movl $0xc7000, %eax          # imm = 0xC7000
movl $0xc70000, %edi         # imm = 0xC70000
cmoveq %rax, %rdi
callq 0x2040
cmpl $0x1, %ebp
movl $0x1000, %edx           # imm = 0x1000
movl $0x10000, %ecx          # imm = 0x10000
cmoveq %rdx, %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movq %rax, %rdx
subq $-0x80, %rdx
xorl %esi, %esi
movdqa 0x4c9b(%rip), %xmm1     # 0x9ea0
movdqa 0x4ca3(%rip), %xmm2     # 0x9eb0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rsi, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0x5255
andq $0x0, (%rdx)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x526c
andq $0x0, 0xc7(%rdx)
addq $0x2, %rsi
addq $0x18e, %rdx            # imm = 0x18E
cmpq %rsi, %rcx
jne 0x5215
movq %rax, (%rbx)
movq %r14, 0x330(%rbx)
andq $0x0, 0x328(%rbx)
andq $0x0, 0x310(%rbx)
orl $-0x1, 0x320(%rbx)
andl $0x0, 0x348(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21f0
jmp 0x52c4
movq %rax, %r15
addq $0x310, %rbx            # imm = 0x310
movq %rbx, %rdi
callq 0x28d4
movq %r15, %rdi
callq 0x2300
nop