LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %edx, %r8d
movl %esi, %r14d
movl 0x10(%rdi), %eax
xorl %edx, %edx
divl %ecx
imull %eax, %r14d
addq (%rdi), %r14
movq %r14, (%rdi)
imull %eax, %r8d
movl %r8d, 0x10(%rdi)
cmpl $0xffffff, %r8d         # imm = 0xFFFFFF
ja 0x4273
movq %rdi, %rbx
movl %r8d, %eax
addq %r14, %rax
xorq %r14, %rax
shrq $0x38, %rax
jne 0x4251
movq 0x20(%rbx), %r15
movq 0x2018(%r15), %rax
cmpq $0x2000, %rax           # imm = 0x2000
jae 0x4260
shrq $0x38, %r14
leaq 0x1(%rax), %rcx
movq %rcx, 0x2018(%r15)
movb %r14b, 0x9(%r15,%rax)
movl 0x10(%rbx), %r8d
shll $0x8, %r8d
movl %r8d, 0x10(%rbx)
movq (%rbx), %r14
shlq $0x8, %r14
movq %r14, (%rbx)
cmpl $0x1000000, %r8d        # imm = 0x1000000
jb 0x41fa
jmp 0x4273
movl %r14d, %eax
notl %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, 0x10(%rbx)
jmp 0x4209
movq %r15, %rdi
xorl %esi, %esi
callq 0x5cfe
movq 0x2018(%r15), %rax
jmp 0x421c
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
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 0x4336
movl %edx, %edx
addq %rcx, %rdx
xorq %rcx, %rdx
shrq $0x38, %rdx
jne 0x431f
shlq $0x8, %rax
movq %rax, 0x8(%rbx)
movq 0x18(%rbx), %r14
movq 0x2020(%r14), %rax
cmpq 0x2018(%r14), %rax
jbe 0x432c
cmpb $0x1, 0x8(%r14)
jne 0x42f8
movq 0x2018(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x2018(%r14)
movzbl 0x9(%r14,%rax), %eax
jmp 0x42fa
xorl %eax, %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)
cmpl $0x1000000, %edx        # imm = 0x1000000
jb 0x42ad
jmp 0x4336
notl %ecx
andl $0xffffff, %ecx         # imm = 0xFFFFFF
movl %ecx, 0x10(%rbx)
jmp 0x42bb
movq %r14, %rdi
callq 0x5f18
jmp 0x42d7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x535a
leaq 0xce52(%rip), %rdi      # 0x111b0
movq %rbx, %rsi
callq 0x52de
movq (%rax), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4384
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21c0
cmpb $0x0, (%rbx)
leaq 0x760f(%rip), %rax      # 0xb99d
cmovneq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43b6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xcc03(%rip), %r15      # 0x10fd0
movq (%r15), %rcx
leaq 0x6d68(%rip), %rdi      # 0xb13f
movl $0xf, %esi
movl $0x1, %edx
callq 0x22e0
movq 0xcddb(%rip), %rbx      # 0x111c8
leaq 0xcdc4(%rip), %r12      # 0x111b8
cmpq %r12, %rbx
je 0x4425
leaq 0x6d4f(%rip), %r14      # 0xb14f
movq (%r15), %rdi
movq 0x20(%rbx), %rdx
movq 0x40(%rbx), %rcx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2250
movq %rbx, %rdi
callq 0x2140
movq %rax, %rbx
cmpq %r12, %rax
jne 0x4400
movq (%r15), %rcx
leaq 0x6d2c(%rip), %rdi      # 0xb15b
movl $0x18, %esi
movl $0x1, %edx
callq 0x22e0
callq 0x5af8
xorl %edi, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb (%rsi), %bpl
testb %bpl, %bpl
je 0x47d7
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %r15d
cmpl $0x200, %r15d           # imm = 0x200
je 0x47e2
movq 0x2018(%r14), %rax
cmpq $0x2000, %rax           # imm = 0x2000
jae 0x47c4
leaq 0x1(%rax), %rcx
movq %rcx, 0x2018(%r14)
movb %bpl, 0x9(%r14,%rax)
movb (%rbx,%r15), %bpl
incq %r15
testb %bpl, %bpl
jne 0x478e
jmp 0x47d7
movq %r14, %rdi
xorl %esi, %esi
callq 0x5cfe
movq 0x2018(%r14), %rax
jmp 0x47a6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x23f5
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x18(%rdi), %rdi
callq 0x4773
movq 0x18(%rbx), %r15
movq 0x2018(%r15), %rax
cmpq $0x2000, %rax           # imm = 0x2000
jae 0x48c8
leaq 0x1(%rax), %rcx
movq %rcx, 0x2018(%r15)
movb $0x3d, 0x9(%r15,%rax)
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x4773
movq 0x18(%rbx), %rbx
movq 0x2018(%rbx), %rax
cmpq $0x2000, %rax           # imm = 0x2000
jae 0x48de
leaq 0x1(%rax), %rcx
movq %rcx, 0x2018(%rbx)
movb $0xa, 0x9(%rbx,%rax)
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x5398
leaq 0xc930(%rip), %rdi      # 0x111b0
movq %rbx, %rsi
callq 0x55d6
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x48a3
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21c0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x48be
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21c0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
xorl %esi, %esi
callq 0x5cfe
movq 0x2018(%r15), %rax
jmp 0x4820
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5cfe
movq 0x2018(%rbx), %rax
jmp 0x4854
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x52a8
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5225
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x5b04
leaq 0x6998(%rip), %rsi      # 0xbb69
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x20a0
leaq 0x6953(%rip), %rsi      # 0xbb3b
movq %rbx, %rdi
movq %r14, %rdx
callq 0x47e8
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x5204
movq %r14, %rdi
callq 0x5cce
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
callq 0x5aa0
movq $0x0, 0x18(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0xd785(%rip) # 0x131f8
xorl %eax, %eax
movq %rax, 0xd794(%rip)      # 0x13210
movq %rdi, 0xd785(%rip)      # 0x13208
movq %rax, 0xb75e(%rip)      # 0x111e8
movl $0x0, 0xb764(%rip)      # 0x111f8
movq $0x2, 0xd761(%rip) # 0x13200
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5b49
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_O3/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 %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq %r12, 0x4030(%rdi)
movb $0x1, 0x8(%rdi)
movq %r12, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x2018(%rdi)
leaq 0xb616(%rip), %r15      # 0x111e8
movq %r15, %rdi
callq 0x60da
movl %eax, %ebp
movl %eax, 0x4038(%r14)
movq %rbx, %rdi
callq 0x5c23
movl %ebp, %ecx
leaq (%rcx,%rcx,2), %rcx
movq %rax, (%r15,%rcx,8)
movq %r12, 0x8(%r15,%rcx,8)
movl $0x0, 0x14(%r15,%rcx,8)
movq 0xd5f6(%rip), %rax      # 0x13200
leaq 0x1(%rax), %rdx
movq %rdx, 0xd5eb(%rip)      # 0x13200
movl %eax, 0x10(%r15,%rcx,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20f0
cmpq $0x9, %rax
jae 0x5c53
movq %rsp, %r14
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2100
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6181(%rip), %rdi      # 0xbddb
leaq 0x5ff1(%rip), %rsi      # 0xbc52
leaq 0x6184(%rip), %rcx      # 0xbdec
movl $0x9a, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x1, %esi
callq 0x5cfe
movb $0x0, 0x8(%rbx)
cmpl $0x0, 0x4034(%rbx)
je 0x5cf3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5e10
popq %rbx
retq
movq %rax, %rdi
callq 0x3f61
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
cmpb $0x1, 0x8(%rdi)
jne 0x5dc0
movq %rdi, %rbx
movq 0x2018(%rdi), %rax
testq %rax, %rax
je 0x5dc0
cmpq $0x2001, %rax           # imm = 0x2001
jae 0x5df1
movl %esi, %ebp
cmpl $0x0, 0x4034(%rbx)
je 0x5dc7
movl 0x4030(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4030(%rbx)
movl 0x2030(%rbx,%rax,4), %esi
leaq 0x9(%rbx), %rdx
leaq 0xb48e(%rip), %rdi      # 0x111e8
callq 0x6130
cmpl $0x7ff, 0x4030(%rbx)    # imm = 0x7FF
setne %al
orb %bpl, %al
je 0x5de7
testb %bpl, %bpl
jne 0x5d95
movq 0xd483(%rip), %rax      # 0x13200
leaq 0x1(%rax), %rcx
movq %rcx, 0xd478(%rip)      # 0x13200
movl 0x4030(%rbx), %ecx
movl %eax, 0x2030(%rbx,%rcx,4)
movq 0x2018(%rbx), %rax
movl 0x4038(%rbx), %ecx
leaq (%rcx,%rcx,2), %rcx
leaq 0xb43b(%rip), %rdx      # 0x111e8
addq %rax, 0x8(%rdx,%rcx,8)
movq $0x0, 0x2018(%rbx)
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4034(%rbx), %rdx
movzbl %bpl, %esi
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x25f4
testb $0x1, %al
jne 0x5d95
movq (%rsp), %rax
jmp 0x5d7d
movq %rbx, %rdi
callq 0x25dd
jmp 0x5d71
leaq 0x5ec0(%rip), %rdi      # 0xbcb8
leaq 0x5e53(%rip), %rsi      # 0xbc52
leaq 0x5ec6(%rip), %rcx      # 0xbccc
movl $0xe0, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5e66
movq %rdi, %rbx
cmpl $0x0, 0x4034(%rdi)
je 0x5e85
movl %esi, %ebp
leaq 0x2030(%rbx), %rdx
movl %esi, 0x2030(%rbx,%rax,4)
movl 0x4034(%rbx), %esi
leaq 0xb39e(%rip), %rdi      # 0x111e8
callq 0x6130
movl %ebp, 0x4034(%rbx)
movl $0x0, 0x4030(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5e09(%rip), %rdi      # 0xbc76
leaq 0x5dde(%rip), %rsi      # 0xbc52
leaq 0x5e12(%rip), %rcx      # 0xbc8d
movl $0xd3, %edx
callq 0x2130
leaq 0x5e23(%rip), %rdi      # 0xbcaf
leaq 0x5dbf(%rip), %rsi      # 0xbc52
leaq 0x5df3(%rip), %rcx      # 0xbc8d
movl $0xd4, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdx, %rbx
movq %rdi, %r14
xorl %eax, %eax
movq %rax, 0x4030(%rdi)
movb $0x1, 0x8(%rdi)
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x2018(%rdi)
movq %rsi, %rdi
callq 0x5c23
leaq 0xb311(%rip), %rdi      # 0x111e8
movq %rax, %rsi
callq 0x6188
movl %eax, 0x4038(%r14)
movq %rbx, 0x2028(%r14)
testl %eax, %eax
je 0x5f08
movb $0x1, %al
movb %al, 0x8(%r14)
movb %al, (%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5f18
xorl %eax, %eax
movb %al, 0x8(%r14)
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x5f9b
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x5f45
shlq $0xd, %rax
movq 0x2018(%rbx), %rcx
addq %rax, %rcx
addq $-0x2000, %rcx          # imm = 0xE000
jmp 0x5f4c
movq 0x2018(%rbx), %rcx
movl 0x4038(%rbx), %eax
leaq (%rax,%rax,2), %rax
leaq 0xb28b(%rip), %r15      # 0x111e8
cmpq 0x8(%r15,%rax,8), %rcx
jae 0x5fa1
leaq 0x4030(%rbx), %r14
cmpl $0x0, 0x4034(%rbx)
movl 0x4030(%rbx), %edi
je 0x5fb1
leaq 0x4034(%rbx), %rcx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2686
leaq 0x4038(%rbx), %rsi
movq %rbx, %rdi
callq 0x26e0
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
movb %al, 0x8(%rbx)
movq 0x2028(%rbx), %rcx
movb %al, (%rcx)
jmp 0x5f9b
testl %edi, %edi
jne 0x5ffd
leaq (%r15,%rax,8), %rax
movl 0x10(%rax), %esi
leaq 0x9(%rbx), %rdx
movq %r15, %rdi
callq 0x61e4
movl 0x4038(%rbx), %eax
leaq (%rax,%rax,2), %rax
movl 0x14(%r15,%rax,8), %esi
movl %esi, 0x4034(%rbx)
testl %esi, %esi
je 0x5ff4
leaq 0x2030(%rbx), %rdx
leaq 0xb1f9(%rip), %rdi      # 0x111e8
callq 0x61e4
movl $0x0, (%r14)
jmp 0x5f8c
leaq 0x5ce8(%rip), %rdi      # 0xbcec
leaq 0x5c47(%rip), %rsi      # 0xbc52
leaq 0x5d0a(%rip), %rcx      # 0xbd1c
movl $0x11b, %edx            # imm = 0x11B
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/Infinidat[P]slimfastq/filer.cpp
// Function: FilerLoad::FilerLoad(int, bool*)
FilerLoad::FilerLoad(int forty_two, bool* valid_ptr) {
    assert(forty_two == 42);    // Verify this constructor wasn't called by mistake
    m_onef_i = 0;
    m_valid_ptr = valid_ptr;
    * valid_ptr = m_valid = true ;
    load_page();
}

// Assembly:
xorl %eax, %eax
movq %rax, 0x4030(%rdi)
movb $0x1, 0x8(%rdi)
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x2018(%rdi)
cmpl $0x2a, %esi
jne 0x6058
movl $0x0, 0x4038(%rdi)
movq %rdx, 0x2028(%rdi)
movb $0x1, %al
movb %al, 0x8(%rdi)
movb %al, (%rdx)
jmp 0x5f18
pushq %rax
leaq 0x5be2(%rip), %rdi      # 0xbc42
leaq 0x5beb(%rip), %rsi      # 0xbc52
leaq 0x5c8c(%rip), %rcx      # 0xbcfa
movl $0x103, %edx            # imm = 0x103
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/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 0x60d8
pushq %rbx
movq %rdi, %rbx
movl 0x2010(%rdi), %eax
movl %eax, 0x10(%rdi)
movl $0x1, %esi
movq %rdi, %rdx
callq 0x6130
movq 0x2020(%rbx), %rdi
callq 0x21a0
movq $0x0, 0x2020(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6110
movq 0x2010(%rdi), %rax
cmpq $0x155, %rax            # imm = 0x155
jae 0x6101
leaq 0x1(%rax), %rcx
movq %rcx, 0x2010(%rdi)
popq %rcx
retq
leaq 0x5ca8(%rip), %rdi      # 0xbdb0
movq %rax, %rsi
callq 0x2584
leaq 0x5c76(%rip), %rdi      # 0xbd8d
leaq 0x5b34(%rip), %rsi      # 0xbc52
leaq 0x5c6e(%rip), %rcx      # 0xbd93
movl $0x3f, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x21f0
movq 0x2020(%r15), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %r14, %rdi
callq 0x22e0
cmpl $0x2000, %eax           # imm = 0x2000
jne 0x6178
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5c89(%rip), %rdi      # 0xbe08
movq %rbx, %rsi
callq 0x2584
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x61c4
movq 0x2010(%rdi), %rcx
xorl %eax, %eax
cmpq $0x2, %rcx
jb 0x61c0
movl $0x1, %edx
movl $0x1, %r8d
leaq (%r8,%r8,2), %r8
cmpq %rsi, (%rdi,%r8,8)
je 0x61c1
incl %edx
movq %rdx, %r8
cmpq %rdx, %rcx
ja 0x61ac
retq
movl %edx, %eax
retq
pushq %rax
leaq 0x5c5d(%rip), %rdi      # 0xbe29
leaq 0x5a7f(%rip), %rsi      # 0xbc52
leaq 0x5c54(%rip), %rcx      # 0xbe2e
movl $0x45, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/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 0x21f0
movq 0x2028(%r15), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %r14, %rdi
callq 0x2270
cmpl $0x2000, %eax           # imm = 0x2000
jne 0x622c
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5c1e(%rip), %rdi      # 0xbe51
movq %rbx, %rsi
callq 0x2584
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl $0x0, 0x40(%rdi)
movl $0x4040, %edi           # imm = 0x4040
callq 0x21b0
movq %rax, %r15
leaq 0x5e6f(%rip), %rsi      # 0xc103
movq %rax, %rdi
callq 0x5ba2
movq %r15, 0x48(%rbx)
movq %r15, 0x28(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movq %rax, 0x8(%rbx)
movl $0xffffffff, 0x18(%rbx) # imm = 0xFFFFFFFF
leaq 0xd064(%rip), %rax      # 0x13320
movl 0x4(%rax), %eax
decl %eax
movl $0x1000000, %r14d       # imm = 0x1000000
cmpl $0x3, %eax
ja 0x62d9
movl %eax, %eax
leaq 0x5c53(%rip), %rcx      # 0xbf28
movq (%rcx,%rax,8), %r14
movq %r14, %rdi
callq 0x2040
movq %rax, %r15
movq %rax, %rdi
movl $0x3, %esi
movq %r14, %rdx
callq 0x2110
movq %r15, (%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r15
leaq 0x5b67(%rip), %rsi      # 0xbe72
movq %rax, %rdi
callq 0xa2f0
movq %r15, 0x50(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r15
leaq 0x5b4e(%rip), %rsi      # 0xbe79
movq %rax, %rdi
callq 0xa2f0
movq %r15, 0x58(%rbx)
leaq 0xcee2(%rip), %rdi      # 0x13220
movl $0x100, %edx            # imm = 0x100
movl $0x10, %esi
callq 0x2110
xorl %eax, %eax
movb %al, 0xcf2c(%rip)       # 0x13281
movb %al, 0xcf06(%rip)       # 0x13261
movb $0x1, %al
movb %al, 0xcf20(%rip)       # 0x13283
movb %al, 0xcefa(%rip)       # 0x13263
movb $0x2, %al
movb %al, 0xcf16(%rip)       # 0x13287
movb %al, 0xcef0(%rip)       # 0x13267
movb $0x3, %al
movb %al, 0xcf15(%rip)       # 0x13294
movb %al, 0xceef(%rip)       # 0x13274
movl $0x3020100, 0xcec1(%rip) # imm = 0x3020100
movb $0x4, %al
movb %al, 0xcef7(%rip)       # 0x1328e
movb %al, 0xced1(%rip)       # 0x1326e
movb %al, 0xceab(%rip)       # 0x1324e
popq %rbx
popq %r14
popq %r15
retq
jmp 0x63ab
movq %rax, %r14
movl $0x2db0, %esi           # imm = 0x2DB0
jmp 0x63bd
movq %rax, %r14
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21c0
jmp 0x63ca
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x3f6c
movq %r14, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x3f61
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f6c
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6407
callq 0x2230
movq 0x48(%r14), %r15
testq %r15, %r15
je 0x6418
movq %r15, %rdi
callq 0x5cce
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21c0
movq 0x50(%r14), %r15
testq %r15, %r15
je 0x6443
movq %r15, %rdi
callq 0xa314
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r15, %rdi
callq 0x21c0
movq $0x0, 0x50(%r14)
movq 0x58(%r14), %r15
testq %r15, %r15
je 0x6469
movq %r15, %rdi
callq 0xa314
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r15, %rdi
callq 0x21c0
movq $0x0, 0x58(%r14)
movq %rbx, %rdi
callq 0x3f6c
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6481
movq %rax, %rdi
callq 0x3f61
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x64bc
movl %r8d, %ebp
movl %esi, %r14d
movb 0x45(%rbx), %al
testb %al, %al
je 0x64f0
cmpb %r14b, %al
jne 0x6518
testb %bpl, %bpl
jne 0x64e5
movl $0x30, %r14d
movl $0x50, %eax
jmp 0x64c7
movl $0x38, %r14d
movl $0x58, %eax
movq (%rbx,%rax), %rdi
leaq 0xacd6(%rip), %r15      # 0x111a8
movq (%r15), %rsi
subq (%rbx,%r14), %rsi
callq 0xa382
movq (%r15), %rax
movq %rax, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb %r14b, 0x45(%rbx)
movb $0x4e, %al
cmpb $0x4e, %r14b
je 0x64a5
movzbl %r14b, %edx
leaq 0xce19(%rip), %rdi      # 0x13320
leaq 0x5972(%rip), %rsi      # 0xbe80
callq 0x490a
movb 0x45(%rbx), %al
jmp 0x64a5
movzbl %r14b, %esi
leaq 0x5968(%rip), %rdi      # 0xbe8b
xorl %eax, %eax
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
testq %rcx, %rcx
jle 0x6683
movq %rdx, %r14
movq %rsi, %r15
addq %rsi, 0x10(%rsp)
movl %r8d, %eax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movl $0x7616c7, %r12d        # imm = 0x7616C7
movzbl (%r15), %ebp
movb (%r14), %bl
leaq 0xcca0(%rip), %rax      # 0x13220
movb (%rbp,%rax), %r13b
cmpb $0x4, %r13b
jae 0x662f
leaq 0xac12(%rip), %rax      # 0x111a8
incq (%rax)
movl %r13d, %eax
cmpb $0x21, %bl
je 0x6638
andl 0x20(%rsp), %r12d
movq 0x8(%rsp), %rax
movq (%rax), %rdi
prefetcht0 (%rdi,%r12,4)
movzbl (%rdi,%r12,4), %edx
movzbl 0x1(%rdi,%r12,4), %eax
movzbl 0x2(%rdi,%r12,4), %ecx
movzbl 0x3(%rdi,%r12,4), %r8d
movzbl %r13b, %ebp
xorl %esi, %esi
cmpb $0x1, %bpl
je 0x65e8
cmpl $0x2, %ebp
je 0x65e6
cmpl $0x3, %ebp
jne 0x65ea
movl %ecx, %esi
addl %eax, %esi
addl %edx, %esi
leaq (%rdi,%r12,4), %r13
addl %edx, %eax
addl %r8d, %ecx
addl %eax, %ecx
movzbl (%r13,%rbp), %edx
movq 0x18(%rsp), %rdi
callq 0x41ca
movb (%r13,%rbp), %al
cmpb $-0x1, %al
je 0x6663
incb %al
movb %al, (%r13,%rbp)
shlq $0x2, %r12
orq %rbp, %r12
incq %r15
incq %r14
cmpq 0x10(%rsp), %r15
jb 0x6572
jmp 0x6683
jne 0x6692
callq 0x2723
xorl %eax, %eax
xorl %ecx, %ecx
cmpb $0x4, %r13b
setae %cl
xorl %r8d, %r8d
cmpb $0x21, %bl
sete %r8b
movq 0x8(%rsp), %rdi
movl %ebp, %esi
xorl %edx, %edx
movl %eax, %ebx
callq 0x648a
movl %ebx, %r13d
jmp 0x65a5
movl (%r13), %eax
movl %eax, %ecx
shrl %ecx
andl $0x7f7f7f7f, %ecx       # imm = 0x7F7F7F7F
andl $0x1010101, %eax        # imm = 0x1010101
orl %ecx, %eax
movl %eax, (%r13)
movb (%r13,%rbp), %al
jmp 0x660e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x581a(%rip), %rdi      # 0xbeb3
movl %ebp, %esi
xorl %eax, %eax
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
movq %r8, 0x30(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, (%rsp)
movq %rcx, 0x20(%rsp)
testq %rcx, %rcx
je 0x6815
movl %r9d, %eax
movq %rax, 0x18(%rsp)
movq (%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movl $0x7616c7, %r12d        # imm = 0x7616C7
movl $0x1, %ebx
xorl %eax, %eax
cmpq 0x30(%rsp), %rax
jae 0x6709
movq 0x8(%rsp), %rcx
cmpb $0x21, (%rcx,%rax)
sete %r13b
jmp 0x670c
xorl %r13d, %r13d
movq 0x28(%rsp), %rcx
movzbl (%rcx,%rax), %r15d
leaq 0xcb03(%rip), %rax      # 0x13220
movb (%r15,%rax), %bpl
cmpb $0x4, %bpl
jae 0x67ca
leaq 0xaa76(%rip), %rax      # 0x111a8
incq (%rax)
movl %ebp, %r14d
testb %r13b, %r13b
jne 0x67d4
andl 0x18(%rsp), %r12d
movq (%rsp), %rax
movq (%rax), %rdi
prefetcht0 (%rdi,%r12,4)
movzbl (%rdi,%r12,4), %edx
movzbl 0x1(%rdi,%r12,4), %eax
movzbl 0x2(%rdi,%r12,4), %ecx
movzbl 0x3(%rdi,%r12,4), %r8d
movzbl %bpl, %r15d
xorl %esi, %esi
cmpb $0x1, %r15b
je 0x6785
cmpl $0x2, %r15d
je 0x6783
cmpl $0x3, %r15d
jne 0x6787
movl %ecx, %esi
addl %eax, %esi
addl %edx, %esi
leaq (%rdi,%r12,4), %rbp
addl %edx, %eax
addl %r8d, %ecx
addl %eax, %ecx
movzbl (%rbp,%r15), %edx
movq 0x10(%rsp), %rdi
callq 0x41ca
movb (%rbp,%r15), %al
cmpb $-0x1, %al
je 0x67f7
incb %al
movb %al, (%rbp,%r15)
shlq $0x2, %r12
orq %r15, %r12
movl %ebx, %eax
incl %ebx
cmpq 0x20(%rsp), %rax
jb 0x66f3
jmp 0x6815
jne 0x6824
callq 0x272e
xorl %r14d, %r14d
xorl %ecx, %ecx
cmpb $0x4, %bpl
setae %cl
movzbl %r13b, %r8d
movq (%rsp), %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x648a
movl %r14d, %ebp
jmp 0x6741
movl (%rbp), %eax
movl %eax, %ecx
shrl %ecx
andl $0x7f7f7f7f, %ecx       # imm = 0x7F7F7F7F
andl $0x1010101, %eax        # imm = 0x1010101
orl %ecx, %eax
movl %eax, (%rbp)
movb (%rbp,%r15), %al
jmp 0x67ab
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5688(%rip), %rdi      # 0xbeb3
movl %r15d, %esi
xorl %eax, %eax
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xcacc(%rip), %rdi      # 0x13320
leaq 0x5625(%rip), %rsi      # 0xbe80
movl $0x4e, %edx
callq 0x46e8
movb %al, 0x45(%rbx)
leaq 0xcab1(%rip), %r14      # 0x13320
leaq 0x5629(%rip), %rsi      # 0xbe9f
movq %r14, %rdi
callq 0x466a
leaq 0x5624(%rip), %rcx      # 0xbea9
leaq 0x5622(%rip), %rdx      # 0xbeae
testb %al, %al
cmovneq %rcx, %rdx
movq %rdx, 0x48(%rbx)
movl $0x4040, %edi           # imm = 0x4040
callq 0x21b0
movq %rax, %r15
leaq 0x44(%rbx), %rdx
leaq 0x5855(%rip), %rsi      # 0xc103
movq %rax, %rdi
callq 0x5ea4
movq %r15, 0x50(%rbx)
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x3fe2
movl 0x4(%r14), %eax
decl %eax
movl $0x1000000, %r14d       # imm = 0x1000000
cmpl $0x3, %eax
ja 0x68e4
movl %eax, %eax
leaq 0x5648(%rip), %rcx      # 0xbf28
movq (%rcx,%rax,8), %r14
movq %r14, %rdi
callq 0x2040
movq %rax, %r15
movq %rax, %rdi
movl $0x3, %esi
movq %r14, %rdx
callq 0x2110
movq %r15, (%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r15
leaq 0x555c(%rip), %rsi      # 0xbe72
movq %rax, %rdi
callq 0xa3ba
movq %r15, 0x58(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r15
leaq 0x5543(%rip), %rsi      # 0xbe79
movq %rax, %rdi
callq 0xa3ba
movq %r15, 0x60(%rbx)
movq 0x58(%rbx), %rdi
callq 0xa58c
movq %rax, 0x30(%rbx)
movq 0x60(%rbx), %rdi
callq 0xa58c
movq %rax, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6964
movq %rax, %r14
movl $0x2db0, %esi           # imm = 0x2DB0
jmp 0x6976
movq %rax, %r14
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21c0
jmp 0x6987
jmp 0x6984
jmp 0x6984
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x3f6c
movq %r14, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x3f61
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f6c
movq (%r14), %rdi
testq %rdi, %rdi
je 0x69c5
callq 0x2230
movq 0x50(%r14), %r15
testq %r15, %r15
je 0x69d6
movq %r15, %rdi
callq 0x6078
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21c0
movq 0x58(%r14), %r15
testq %r15, %r15
je 0x6a01
movq %r15, %rdi
callq 0xa3de
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r15, %rdi
callq 0x21c0
movq $0x0, 0x58(%r14)
movq 0x60(%r14), %r15
testq %r15, %r15
je 0x6a27
movq %r15, %rdi
callq 0xa3de
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r15, %rdi
callq 0x21c0
movq $0x0, 0x60(%r14)
movq %rbx, %rdi
callq 0x3f6c
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6a3f
movq %rax, %rdi
callq 0x3f61
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rdi, %r14
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
jle 0x6b9f
movq %rdx, %r15
movq %rsi, %r12
movq 0x8(%rsp), %rax
addq %rsi, %rax
movq %rax, 0x18(%rsp)
movl %r8d, %eax
movq %rax, 0x20(%rsp)
leaq 0x8(%r14), %rax
movq %rax, 0x10(%rsp)
movl $0x7616c7, %ebp         # imm = 0x7616C7
andl 0x20(%rsp), %ebp
movq (%r14), %rax
leaq (%rax,%rbp,4), %r13
prefetcht0 (%rax,%rbp,4)
movzbl (%rax,%rbp,4), %ecx
movzbl 0x1(%rax,%rbp,4), %edx
addl %ecx, %edx
movzbl 0x2(%rax,%rbp,4), %esi
movzbl 0x3(%rax,%rbp,4), %ecx
addl %esi, %ecx
addl %edx, %ecx
movl 0x18(%r14), %eax
xorl %ebx, %ebx
xorl %edx, %edx
divl %ecx
movl %eax, %esi
movl %eax, 0x18(%r14)
movq 0x10(%r14), %rax
xorl %edx, %edx
divq %rsi
xorl %esi, %esi
movzbl (%r13,%rbx), %edx
leal (%rsi,%rdx), %edi
cmpl %eax, %edi
ja 0x6af0
incq %rbx
movl %edi, %esi
cmpq $0x4, %rbx
jne 0x6ad3
jmp 0x6bba
movq 0x10(%rsp), %rdi
callq 0x427a
movb (%rbx,%r13), %al
cmpb $-0x1, %al
je 0x6b4f
incb %al
movb %al, (%r13,%rbx)
movq 0x48(%r14), %rax
movb (%rax,%rbx), %al
movb %al, (%r12)
movb (%r15), %cl
leaq 0xa68a(%rip), %rdx      # 0x111a8
movq (%rdx), %rax
incq %rax
movq %rax, (%rdx)
cmpq %rax, 0x38(%r14)
je 0x6b6f
cmpb $0x21, %cl
je 0x6b7e
cmpq %rax, 0x30(%r14)
je 0x6b88
leaq (%rbx,%rbp,4), %rbp
incq %r12
incq %r15
cmpq 0x18(%rsp), %r12
jb 0x6a90
jmp 0x6b9f
movl (%r13), %eax
movl %eax, %ecx
shrl %ecx
andl $0x7f7f7f7f, %ecx       # imm = 0x7F7F7F7F
andl $0x1010101, %eax        # imm = 0x1010101
orl %ecx, %eax
movl %eax, (%r13)
movb (%r13,%rbx), %al
jmp 0x6b02
movq 0x60(%r14), %rdi
callq 0xa58c
addq %rax, 0x38(%r14)
jmp 0x6b38
movb 0x45(%r14), %al
movb %al, (%r12)
jmp 0x6b38
movb 0x45(%r14), %al
movb %al, (%r12)
movq 0x58(%r14), %rdi
callq 0xa58c
addq %rax, 0x30(%r14)
jmp 0x6b38
xorl %eax, %eax
cmpb $0x0, 0x44(%r14)
cmovnel 0x8(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x530d(%rip), %rdi      # 0xbece
leaq 0x530a(%rip), %rsi      # 0xbed2
leaq 0x5316(%rip), %rcx      # 0xbee5
movl $0x63, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %r8, 0x20(%rsp)
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
movq %rsi, (%rsp)
movq %rdi, %r15
testq %rcx, %rcx
je 0x6d6a
movl %r9d, %eax
movq %rax, 0x18(%rsp)
leaq 0x8(%r15), %rax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
movl $0x7616c7, %r13d        # imm = 0x7616C7
andl 0x18(%rsp), %r13d
movq (%r15), %rax
leaq (%rax,%r13,4), %r12
prefetcht0 (%rax,%r13,4)
movzbl (%rax,%r13,4), %ecx
movzbl 0x1(%rax,%r13,4), %edx
addl %ecx, %edx
movzbl 0x2(%rax,%r13,4), %esi
movzbl 0x3(%rax,%r13,4), %ecx
addl %esi, %ecx
addl %edx, %ecx
movl 0x18(%r15), %eax
xorl %edx, %edx
divl %ecx
movl %eax, %esi
movl %eax, 0x18(%r15)
movq 0x10(%r15), %rax
xorl %edx, %edx
divq %rsi
xorl %ebp, %ebp
xorl %esi, %esi
movzbl (%r12,%rbp), %edx
leal (%rsi,%rdx), %edi
cmpl %eax, %edi
ja 0x6c84
incq %rbp
movl %edi, %esi
cmpq $0x4, %rbp
jne 0x6c68
jmp 0x6d83
movq 0x10(%rsp), %rdi
callq 0x427a
movb (%rbp,%r12), %al
cmpb $-0x1, %al
je 0x6d1e
incb %al
movb %al, (%r12,%rbp)
movq 0x48(%r15), %rax
movb (%rax,%rbp), %al
movq (%rsp), %rcx
movb %al, (%rcx,%r14)
cmpq 0x20(%rsp), %r14
jae 0x6ce9
movq 0x8(%rsp), %rax
movb (%rax,%r14), %cl
leaq 0xa4e1(%rip), %rdx      # 0x111a8
movq (%rdx), %rax
incq %rax
movq %rax, (%rdx)
cmpq %rax, 0x38(%r15)
je 0x6d40
cmpb $0x21, %cl
jne 0x6cff
movb 0x45(%r15), %al
movq (%rsp), %rcx
movb %al, (%rcx,%r14)
jmp 0x6d05
leaq 0xa4b8(%rip), %rcx      # 0x111a8
movq (%rcx), %rax
incq %rax
movq %rax, (%rcx)
cmpq %rax, 0x38(%r15)
je 0x6d40
cmpq %rax, 0x30(%r15)
je 0x6d4f
leaq (,%r13,4), %r13
addq %rbp, %r13
incl %r14d
cmpq %rbx, %r14
jb 0x6c1f
jmp 0x6d6a
movl (%r12), %eax
movl %eax, %ecx
shrl %ecx
andl $0x7f7f7f7f, %ecx       # imm = 0x7F7F7F7F
andl $0x1010101, %eax        # imm = 0x1010101
orl %ecx, %eax
movl %eax, (%r12)
movb (%r12,%rbp), %al
jmp 0x6c9b
movq 0x60(%r15), %rdi
callq 0xa58c
addq %rax, 0x38(%r15)
jmp 0x6d05
movb 0x45(%r15), %al
movq (%rsp), %rcx
movb %al, (%rcx,%r14)
movq 0x58(%r15), %rdi
callq 0xa58c
addq %rax, 0x30(%r15)
jmp 0x6d05
xorl %eax, %eax
cmpb $0x0, 0x44(%r15)
cmovnel %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5144(%rip), %rdi      # 0xbece
leaq 0x5141(%rip), %rsi      # 0xbed2
leaq 0x514d(%rip), %rcx      # 0xbee5
movl $0x63, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc568(%rip), %rdi      # 0x13320
callq 0x497c
cmpb $0x1, 0xc568(%rip)      # 0x1332c
jne 0x6de5
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x8b34
movq %rbx, %rdi
callq 0x996a
movl %eax, %ebx
movq %rsp, %rdi
callq 0x8fca
jmp 0x6dff
movq %rsp, %rdi
callq 0x9b18
movq %rsp, %rdi
callq 0xa06c
movl %eax, %ebx
movq %rsp, %rdi
callq 0x9d7c
leaq 0xc51a(%rip), %rdi      # 0x13320
callq 0x51b4
movl %ebx, %eax
addq $0x1480d0, %rsp         # imm = 0x1480D0
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9d7c
jmp 0x6e33
movq %rax, %rbx
jmp 0x6e33
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8fca
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2110
xorps %xmm0, %xmm0
movups %xmm0, 0x328(%rbx)
movl $0x4040, %edi           # imm = 0x4040
callq 0x21b0
movq %rax, %r14
leaq 0x527e(%rip), %rsi      # 0xc10c
movq %rax, %rdi
callq 0x5ba2
movq %r14, 0x340(%rbx)
leaq 0xc47c(%rip), %rax      # 0x13320
movl 0x4(%rax), %ebp
cmpl $0x1, %ebp
movl $0xc7000, %eax          # imm = 0xC7000
movl $0xc70000, %edi         # imm = 0xC70000
cmoveq %rax, %rdi
callq 0x2040
cmpl $0x1, %ebp
movl $0x1000, %edx           # imm = 0x1000
movl $0x10000, %ecx          # imm = 0x10000
cmoveq %rdx, %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movq %rax, %rdx
subq $-0x80, %rdx
xorl %esi, %esi
movdqa 0x4193(%rip), %xmm1     # 0xb080
movdqa 0x419b(%rip), %xmm2     # 0xb090
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rsi, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0x6f40
movq $0x0, (%rdx)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x6f5a
movq $0x0, 0xc7(%rdx)
addq $0x2, %rsi
addq $0x18e, %rdx            # imm = 0x18E
cmpq %rsi, %rcx
jne 0x6efd
movq %rax, (%rbx)
movq %r14, 0x330(%rbx)
xorl %eax, %eax
movq %rax, 0x328(%rbx)
movq %rax, 0x310(%rbx)
movl $0xffffffff, 0x320(%rbx) # imm = 0xFFFFFFFF
movl $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 0x21c0
jmp 0x6fb8
movq %rax, %r15
addq $0x310, %rbx            # imm = 0x310
movq %rbx, %rdi
callq 0x3f6c
movq %r15, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x3f61
nop
// File: /workspace/github_cpp_makefile_star2_O3/Infinidat[P]slimfastq/qlts.cpp
// Function: QltSave::~QltSave()
QltSave::~QltSave() {
    rcoder.done();
    if (not conf.quiet) {
        if (m_last.extra_hi_qlt) {
            conf.set_info("qlt.extra.hi", m_last.extra_hi_qlt);
        }
    }

    delete [] ranger;
    delete    filer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x310(%rdi), %rbx
movq %rbx, %rdi
callq 0x3f6c
leaq 0xc32b(%rip), %rax      # 0x13320
cmpb $0x0, 0xe(%rax)
jne 0x701a
movl 0x348(%r14), %edx
testq %rdx, %rdx
je 0x701a
leaq 0xc312(%rip), %rdi      # 0x13320
leaq 0x4f33(%rip), %rsi      # 0xbf48
callq 0x490a
movq (%r14), %rdi
testq %rdi, %rdi
je 0x7027
callq 0x2230
movq 0x340(%r14), %r14
testq %r14, %r14
je 0x703b
movq %r14, %rdi
callq 0x5cce
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x3f6c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x705a
movq %rax, %rdi
callq 0x3f61
// File: /workspace/github_cpp_makefile_star2_O3/Infinidat[P]slimfastq/qlts.cpp
// Function: QltSave::save_1(unsigned char const*, unsigned long)
void QltSave::save_1(const UCHAR* buf, size_t size) {
    UINT32 last = 0;
    for (const UCHAR* p = buf ; p < buf + size; p++) {
        UCHAR b = UCHAR(*p-'!');

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

// Assembly:
testq %rdx, %rdx
jle 0x711f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq %rsi, %rbx
leaq 0x310(%rdi), %r12
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
xorl %r13d, %r13d
movb (%r14), %al
addb $-0x21, %al
movq (%r15), %rcx
movl %r13d, %edx
imulq $0xc7, %rdx, %rdx
leaq (%rcx,%rdx), %rdi
prefetcht0 (%rcx,%rdx)
movzbl %al, %ebp
movq %r12, %rsi
cmpb $0x3e, %al
ja 0x70f0
movl %ebp, %edx
callq 0x77d0
andl $0x3f, %r13d
shll $0x6, %r13d
orl %ebp, %r13d
incq %r14
cmpq %rbx, %r14
jb 0x70b0
jmp 0x7111
movl $0x3f, %edx
callq 0x77d0
movq (%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x3842
incl 0x348(%r15)
jmp 0x70db
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq