LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl 0x10(%rdi), %eax
imull %eax, %esi
addq %rsi, (%rdi)
subq %rsi, 0x8(%rdi)
imull %eax, %edx
movl %edx, 0x10(%rdi)
cmpl $0xffffff, %edx         # imm = 0xFFFFFF
ja 0x3763
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rax
movl %edx, %ecx
addq %rax, %rcx
xorq %rax, %rcx
shrq $0x38, %rcx
jne 0x3746
shlq $0x8, 0x8(%rbx)
movq 0x18(%rbx), %r14
movq 0x2020(%r14), %rax
cmpq 0x2018(%r14), %rax
jbe 0x3752
cmpb $0x1, 0x8(%r14)
jne 0x3729
movq 0x2018(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x2018(%r14)
movzbl 0x9(%r14,%rax), %eax
jmp 0x372b
xorl %eax, %eax
orq %rax, 0x8(%rbx)
movl 0x10(%rbx), %edx
shll $0x8, %edx
movl %edx, 0x10(%rbx)
shlq $0x8, (%rbx)
cmpl $0x1000000, %edx        # imm = 0x1000000
jb 0x36de
jmp 0x375c
notl %eax
andl $0xffffff, %eax         # imm = 0xFFFFFF
movl %eax, 0x10(%rbx)
jmp 0x36ef
movq %r14, %rdi
callq 0x533a
jmp 0x3708
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x478c
leaq 0xca2e(%rip), %rdi      # 0x101b0
movq %rbx, %rsi
callq 0x4710
movq (%rax), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37a8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21c0
cmpb $0x0, (%rbx)
leaq 0x715b(%rip), %rax      # 0xa90d
cmovneq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37da
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc7df(%rip), %r15      # 0xffd0
movq (%r15), %rcx
leaq 0x68b4(%rip), %rdi      # 0xa0af
movl $0xf, %esi
movl $0x1, %edx
callq 0x22e0
movq 0xc9b7(%rip), %rbx      # 0x101c8
leaq 0xc9a0(%rip), %r12      # 0x101b8
cmpq %r12, %rbx
je 0x3849
leaq 0x689b(%rip), %r14      # 0xa0bf
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 0x3824
movq (%r15), %rcx
leaq 0x6878(%rip), %rdi      # 0xa0cb
movl $0x18, %esi
movl $0x1, %edx
callq 0x22e0
callq 0x4f20
xorl %edi, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3bf5
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %r15d
cmpl $0x200, %r15d           # imm = 0x200
je 0x3c00
cmpq $0x2000, 0x2018(%r14) # imm = 0x2000
jae 0x3be9
movq 0x2018(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x2018(%r14)
movb %bpl, 0x9(%r14,%rax)
movb (%rbx,%r15), %bpl
incq %r15
testb %bpl, %bpl
jne 0x3bae
jmp 0x3bf5
movq %r14, %rdi
xorl %esi, %esi
callq 0x5126
jmp 0x3bc4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2415
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rdi), %rdi
callq 0x3b93
movq 0x18(%rbx), %r14
cmpq $0x2000, 0x2018(%r14) # imm = 0x2000
jae 0x3cee
movq 0x2018(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x2018(%r14)
movb $0x3d, 0x9(%r14,%rax)
movq 0x18(%rbx), %rdi
movq 0x8(%rsp), %rsi
callq 0x3b93
movq 0x18(%rbx), %rbx
cmpq $0x2000, 0x2018(%rbx) # imm = 0x2000
jae 0x3cfd
movq 0x2018(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x2018(%rbx)
movb $0xa, 0x9(%rbx,%rax)
leaq 0x18(%rsp), %rbx
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x47ca
leaq 0xc508(%rip), %rdi      # 0x101b0
movq %rbx, %rsi
callq 0x49fc
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ccb
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21c0
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ce6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21c0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
xorl %esi, %esi
callq 0x5126
jmp 0x3c38
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5126
jmp 0x3c73
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x46da
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4657
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x4f2c
leaq 0x64d6(%rip), %rsi      # 0xaad9
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x20a0
leaq 0x6491(%rip), %rsi      # 0xaaab
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3c06
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x4643
movq %r14, %rdi
callq 0x50f6
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
callq 0x4ec8
movq $0x0, 0x18(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0xd35d(%rip) # 0x121f8
xorl %eax, %eax
movq %rax, 0xd36c(%rip)      # 0x12210
movq %rdi, 0xd35d(%rip)      # 0x12208
movq %rax, 0xb336(%rip)      # 0x101e8
movl $0x0, 0xb33c(%rip)      # 0x101f8
movq $0x2, 0xd339(%rip) # 0x12200
retq
// File: /workspace/github_cpp_makefile_star2_O1/Infinidat[P]slimfastq/filer.cpp
// Function: FilerBase::FilerBase()
FilerBase::FilerBase() {
    m_node_i = 0;
    m_node_p = 0;

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

// Assembly:
xorl %eax, %eax
movq %rax, 0x4030(%rdi)
movb $0x1, 0x8(%rdi)
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x2018(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4f71
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_O1/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 0xb1ee(%rip), %r15      # 0x101e8
movq %r15, %rdi
callq 0x54fc
movl %eax, %ebp
movl %eax, 0x4038(%r14)
movq %rbx, %rdi
callq 0x504b
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 0xd1ce(%rip), %rax      # 0x12200
leaq 0x1(%rax), %rdx
movq %rdx, 0xd1c3(%rip)      # 0x12200
movl %eax, 0x10(%r15,%rcx,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x507b
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 0x5cc9(%rip), %rdi      # 0xad4b
leaq 0x5b39(%rip), %rsi      # 0xabc2
leaq 0x5ccc(%rip), %rcx      # 0xad5c
movl $0x9a, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5126
movb $0x0, 0x8(%rbx)
cmpl $0x0, 0x4034(%rbx)
je 0x511b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5232
popq %rbx
retq
movq %rax, %rdi
callq 0x33b3
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x51e8
movq %rdi, %rbx
movq 0x2018(%rdi), %rax
testq %rax, %rax
je 0x51e8
cmpq $0x2001, %rax           # imm = 0x2001
jae 0x5212
movl %esi, %ebp
cmpl $0x0, 0x4034(%rbx)
je 0x51ef
movl 0x4030(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4030(%rbx)
movl 0x2030(%rbx,%rax,4), %esi
leaq 0x9(%rbx), %rdx
leaq 0xb066(%rip), %rdi      # 0x101e8
callq 0x5552
cmpl $0x7ff, 0x4030(%rbx)    # imm = 0x7FF
setne %al
orb %bpl, %al
je 0x5208
testb %bpl, %bpl
jne 0x51bd
movq 0xd05b(%rip), %rax      # 0x12200
leaq 0x1(%rax), %rcx
movq %rcx, 0xd050(%rip)      # 0x12200
movl 0x4030(%rbx), %ecx
movl %eax, 0x2030(%rbx,%rcx,4)
movq 0x2018(%rbx), %rax
movl 0x4038(%rbx), %ecx
leaq (%rcx,%rcx,2), %rcx
leaq 0xb013(%rip), %rdx      # 0x101e8
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 %rbx, %rdi
callq 0x2614
testb $0x1, %al
je 0x5199
jmp 0x51bd
movq %rbx, %rdi
callq 0x25fd
jmp 0x5199
leaq 0x5a0f(%rip), %rdi      # 0xac28
leaq 0x59a2(%rip), %rsi      # 0xabc2
leaq 0x5a15(%rip), %rcx      # 0xac3c
movl $0xe0, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5288
movq %rdi, %rbx
cmpl $0x0, 0x4034(%rdi)
je 0x52a7
movl %esi, %ebp
leaq 0x2030(%rbx), %rdx
movl %esi, 0x2030(%rbx,%rax,4)
movl 0x4034(%rbx), %esi
leaq 0xaf7c(%rip), %rdi      # 0x101e8
callq 0x5552
movl %ebp, 0x4034(%rbx)
movl $0x0, 0x4030(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5957(%rip), %rdi      # 0xabe6
leaq 0x592c(%rip), %rsi      # 0xabc2
leaq 0x5960(%rip), %rcx      # 0xabfd
movl $0xd3, %edx
callq 0x2130
leaq 0x5971(%rip), %rdi      # 0xac1f
leaq 0x590d(%rip), %rsi      # 0xabc2
leaq 0x5941(%rip), %rcx      # 0xabfd
movl $0xd4, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x504b
leaq 0xaeef(%rip), %rdi      # 0x101e8
movq %rax, %rsi
callq 0x55aa
movl %eax, 0x4038(%r14)
movq %rbx, 0x2028(%r14)
testl %eax, %eax
je 0x532a
movb $0x1, %al
movb %al, 0x8(%r14)
movb %al, (%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x533a
xorl %eax, %eax
movb %al, 0x8(%r14)
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x53bd
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x5367
shlq $0xd, %rax
movq 0x2018(%rbx), %rcx
addq %rax, %rcx
addq $-0x2000, %rcx          # imm = 0xE000
jmp 0x536e
movq 0x2018(%rbx), %rcx
movl 0x4038(%rbx), %eax
leaq (%rax,%rax,2), %rax
leaq 0xae69(%rip), %r15      # 0x101e8
cmpq 0x8(%r15,%rax,8), %rcx
jae 0x53c3
leaq 0x4030(%rbx), %r14
cmpl $0x0, 0x4034(%rbx)
movl 0x4030(%rbx), %edi
je 0x53d3
leaq 0x4034(%rbx), %rcx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x26a8
leaq 0x4038(%rbx), %rsi
movq %rbx, %rdi
callq 0x2705
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
movb %al, 0x8(%rbx)
movq 0x2028(%rbx), %rcx
movb %al, (%rcx)
jmp 0x53bd
testl %edi, %edi
jne 0x541f
leaq (%r15,%rax,8), %rax
movl 0x10(%rax), %esi
leaq 0x9(%rbx), %rdx
movq %r15, %rdi
callq 0x5606
movl 0x4038(%rbx), %eax
leaq (%rax,%rax,2), %rax
movl 0x14(%r15,%rax,8), %esi
movl %esi, 0x4034(%rbx)
testl %esi, %esi
je 0x5416
leaq 0x2030(%rbx), %rdx
leaq 0xadd7(%rip), %rdi      # 0x101e8
callq 0x5606
movl $0x0, (%r14)
jmp 0x53ae
leaq 0x5836(%rip), %rdi      # 0xac5c
leaq 0x5795(%rip), %rsi      # 0xabc2
leaq 0x5858(%rip), %rcx      # 0xac8c
movl $0x11b, %edx            # imm = 0x11B
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x547a
movl $0x0, 0x4038(%rdi)
movq %rdx, 0x2028(%rdi)
movb $0x1, %al
movb %al, 0x8(%rdi)
movb %al, (%rdx)
jmp 0x533a
pushq %rax
leaq 0x5730(%rip), %rdi      # 0xabb2
leaq 0x5739(%rip), %rsi      # 0xabc2
leaq 0x57da(%rip), %rcx      # 0xac6a
movl $0x103, %edx            # imm = 0x103
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x54fa
pushq %rbx
movq %rdi, %rbx
movl 0x2010(%rdi), %eax
movl %eax, 0x10(%rdi)
movl $0x1, %esi
movq %rdi, %rdx
callq 0x5552
movq 0x2020(%rbx), %rdi
callq 0x21a0
movq $0x0, 0x2020(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5532
movq 0x2010(%rdi), %rax
cmpq $0x155, %rax            # imm = 0x155
jae 0x5523
leaq 0x1(%rax), %rcx
movq %rcx, 0x2010(%rdi)
popq %rcx
retq
leaq 0x57f6(%rip), %rdi      # 0xad20
movq %rax, %rsi
callq 0x25a4
leaq 0x57c4(%rip), %rdi      # 0xacfd
leaq 0x5682(%rip), %rsi      # 0xabc2
leaq 0x57bc(%rip), %rcx      # 0xad03
movl $0x3f, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x559a
popq %rbx
popq %r14
popq %r15
retq
leaq 0x57d7(%rip), %rdi      # 0xad78
movq %rbx, %rsi
callq 0x25a4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x55e6
movq 0x2010(%rdi), %rcx
xorl %eax, %eax
cmpq $0x2, %rcx
jb 0x55e2
movl $0x1, %edx
movl $0x1, %r8d
leaq (%r8,%r8,2), %r8
cmpq %rsi, (%rdi,%r8,8)
je 0x55e3
incl %edx
movq %rdx, %r8
cmpq %rdx, %rcx
ja 0x55ce
retq
movl %edx, %eax
retq
pushq %rax
leaq 0x57ab(%rip), %rdi      # 0xad99
leaq 0x55cd(%rip), %rsi      # 0xabc2
leaq 0x57a2(%rip), %rcx      # 0xad9e
movl $0x45, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x564e
popq %rbx
popq %r14
popq %r15
retq
leaq 0x576c(%rip), %rdi      # 0xadc1
movq %rbx, %rsi
callq 0x25a4
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a0b(%rip), %rsi      # 0xb0c3
movq %rax, %rdi
callq 0x4fca
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 0xcc40(%rip), %rax      # 0x12320
movl 0x4(%rax), %eax
decl %eax
movl $0x1000000, %r14d       # imm = 0x1000000
cmpl $0x3, %eax
ja 0x56fd
movl %eax, %eax
leaq 0x57bf(%rip), %rcx      # 0xaeb8
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 0x56d5(%rip), %rsi      # 0xae04
movq %rax, %rdi
callq 0x979c
movq %r15, 0x50(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r15
leaq 0x56bc(%rip), %rsi      # 0xae0b
movq %rax, %rdi
callq 0x979c
movq %r15, 0x58(%rbx)
leaq 0xcabe(%rip), %rdi      # 0x12220
movl $0x100, %edx            # imm = 0x100
movl $0x10, %esi
callq 0x2110
xorl %eax, %eax
movb %al, 0xcb08(%rip)       # 0x12281
movb %al, 0xcae2(%rip)       # 0x12261
movb $0x1, %al
movb %al, 0xcafc(%rip)       # 0x12283
movb %al, 0xcad6(%rip)       # 0x12263
movb $0x2, %al
movb %al, 0xcaf2(%rip)       # 0x12287
movb %al, 0xcacc(%rip)       # 0x12267
movb $0x3, %al
movb %al, 0xcaf1(%rip)       # 0x12294
movb %al, 0xcacb(%rip)       # 0x12274
movl $0x3020100, 0xca9d(%rip) # imm = 0x3020100
movb $0x4, %al
movb %al, 0xcad3(%rip)       # 0x1228e
movb %al, 0xcaad(%rip)       # 0x1226e
movb %al, 0xca87(%rip)       # 0x1224e
popq %rbx
popq %r14
popq %r15
retq
jmp 0x57cf
movq %rax, %r14
movl $0x2db0, %esi           # imm = 0x2DB0
jmp 0x57e1
movq %rax, %r14
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21c0
jmp 0x57ee
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x33be
movq %r14, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x33b3
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33be
movq (%r14), %rdi
testq %rdi, %rdi
je 0x582b
callq 0x2230
movq 0x48(%r14), %r15
testq %r15, %r15
je 0x5849
movq %r15, %rdi
callq 0x50f6
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21c0
movq 0x50(%r14), %r15
testq %r15, %r15
je 0x5867
movq %r15, %rdi
callq 0x97c0
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r15, %rdi
callq 0x21c0
movq $0x0, 0x50(%r14)
movq 0x58(%r14), %r15
testq %r15, %r15
je 0x588d
movq %r15, %rdi
callq 0x97c0
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r15, %rdi
callq 0x21c0
movq $0x0, 0x58(%r14)
movq %rbx, %rdi
callq 0x33be
popq %rbx
popq %r14
popq %r15
retq
jmp 0x58a5
movq %rax, %rdi
callq 0x33b3
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x58e3
movl %r8d, %ebp
movl %esi, %r14d
leaq 0x45(%rbx), %r15
cmpb $0x0, 0x45(%rbx)
je 0x5917
cmpb %r14b, (%r15)
jne 0x5925
testb %bpl, %bpl
jne 0x590c
movl $0x30, %r14d
movl $0x50, %eax
jmp 0x58ee
movl $0x38, %r14d
movl $0x58, %eax
movq (%rbx,%rax), %rdi
leaq 0xa8af(%rip), %r15      # 0x101a8
movq (%r15), %rsi
subq (%rbx,%r14), %rsi
callq 0x982e
movq (%r15), %rax
movq %rax, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %r14b, %edi
movq %r15, %rsi
callq 0x2748
jmp 0x58cc
movzbl %r14b, %esi
leaq 0x54ed(%rip), %rdi      # 0xae1d
xorl %eax, %eax
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, (%rsp)
testq %rcx, %rcx
jle 0x5a78
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
addq %rsi, %rbx
movl %r8d, %eax
movq %rax, 0x10(%rsp)
movq (%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movl $0x7616c7, %r12d        # imm = 0x7616C7
movzbl (%r15), %esi
movb (%r14), %al
leaq 0xc898(%rip), %rcx      # 0x12220
movb (%rsi,%rcx), %dl
movl %edx, %ebp
cmpb $0x4, %dl
jae 0x5a44
leaq 0xa80b(%rip), %rcx      # 0x101a8
incq (%rcx)
cmpb $0x21, %al
je 0x5a57
cmpb $0x4, %dl
jae 0x5a57
andl 0x10(%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, %r13d
xorl %r9d, %r9d
leaq 0x53fd(%rip), %rsi      # 0xade4
movslq (%rsi,%r13,4), %r10
addq %rsi, %r10
movl %r13d, %esi
jmpq *%r10
movl %ecx, %r9d
addl %eax, %r9d
addl %edx, %r9d
movl %r9d, %esi
leaq (%rdi,%r12,4), %rbp
addl %edx, %eax
addl %r8d, %ecx
addl %eax, %ecx
movzbl (%rbp,%r13), %edx
movq 0x8(%rsp), %rdi
callq 0x3610
cmpb $-0x1, (%rbp,%r13)
je 0x5a4d
incb (%rbp,%r13)
leaq (,%r12,4), %r12
addq %r13, %r12
incq %r15
incq %r14
cmpq %rbx, %r15
jb 0x597a
jmp 0x5a78
jne 0x5a87
xorl %ebp, %ebp
jmp 0x5996
movq %rbp, %rdi
callq 0x2769
jmp 0x5a23
xorl %ecx, %ecx
cmpb $0x4, %dl
setae %cl
xorl %r8d, %r8d
cmpb $0x21, %al
sete %r8b
movq (%rsp), %rdi
xorl %edx, %edx
callq 0x58ae
jmp 0x59b1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x53b7(%rip), %rdi      # 0xae45
xorl %eax, %eax
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rcx, 0x20(%rsp)
testq %rcx, %rcx
je 0x5bec
movq %rdi, %r13
movl %r9d, %eax
movq %rax, 0x18(%rsp)
leaq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
movl $0x7616c7, %r12d        # imm = 0x7616C7
movl $0x1, %ebx
xorl %ecx, %ecx
leaq 0x530b(%rip), %rbp      # 0xadf4
cmpq 0x30(%rsp), %rcx
jae 0x5afe
movq 0x8(%rsp), %rax
cmpb $0x21, (%rax,%rcx)
sete %al
jmp 0x5b00
xorl %eax, %eax
movq 0x28(%rsp), %rdx
movzbl (%rdx,%rcx), %esi
leaq 0xc710(%rip), %rcx      # 0x12220
movb (%rsi,%rcx), %dl
movl %edx, %r14d
cmpb $0x4, %dl
jae 0x5bbd
cmpb $0x4, %dl
setb %cl
leaq 0xa67c(%rip), %rdi      # 0x101a8
incq (%rdi)
movl %eax, %edi
notb %dil
testb %cl, %dil
je 0x5bc7
andl 0x18(%rsp), %r12d
movq (%r13), %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 %r14b, %r14d
xorl %r9d, %r9d
movslq (%rbp,%r14,4), %r10
addq %rbp, %r10
movl %r14d, %esi
jmpq *%r10
movl %ecx, %r9d
addl %eax, %r9d
addl %edx, %r9d
movl %r9d, %esi
leaq (%rdi,%r12,4), %r15
addl %edx, %eax
addl %r8d, %ecx
addl %eax, %ecx
movzbl (%r15,%r14), %edx
movq 0x10(%rsp), %rdi
callq 0x3610
cmpb $-0x1, (%r15,%r14)
je 0x5be2
incb (%r15,%r14)
leaq (%r14,%r12,4), %r12
movl %ebx, %ecx
incl %ebx
cmpq 0x20(%rsp), %rcx
jb 0x5ae9
jmp 0x5bec
jne 0x5bfb
xorl %r14d, %r14d
jmp 0x5b1f
xorl %ecx, %ecx
cmpb $0x4, %dl
setae %cl
movzbl %al, %r8d
movq %r13, %rdi
xorl %edx, %edx
callq 0x58ae
jmp 0x5b3d
movq %r15, %rdi
callq 0x277f
jmp 0x5ba4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5243(%rip), %rdi      # 0xae45
xorl %eax, %eax
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc6f8(%rip), %rdi      # 0x12320
leaq 0x51e3(%rip), %rsi      # 0xae12
movl $0x4e, %edx
callq 0x3b08
movb %al, 0x45(%rbx)
leaq 0xc6dd(%rip), %r14      # 0x12320
leaq 0x51e7(%rip), %rsi      # 0xae31
movq %r14, %rdi
callq 0x3a8a
leaq 0x51e2(%rip), %rcx      # 0xae3b
leaq 0x51e0(%rip), %rdx      # 0xae40
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 0x5441(%rip), %rsi      # 0xb0c3
movq %rax, %rdi
callq 0x52c6
movq %r15, 0x50(%rbx)
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x342a
movl 0x4(%r14), %eax
decl %eax
movl $0x1000000, %r14d       # imm = 0x1000000
cmpl $0x3, %eax
ja 0x5cb8
movl %eax, %eax
leaq 0x5204(%rip), %rcx      # 0xaeb8
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 0x511a(%rip), %rsi      # 0xae04
movq %rax, %rdi
callq 0x9866
movq %r15, 0x58(%rbx)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x21b0
movq %rax, %r15
leaq 0x5101(%rip), %rsi      # 0xae0b
movq %rax, %rdi
callq 0x9866
movq %r15, 0x60(%rbx)
movq 0x58(%rbx), %rdi
callq 0x9a38
movq %rax, 0x30(%rbx)
movq 0x60(%rbx), %rdi
callq 0x9a38
movq %rax, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5d38
movq %rax, %r14
movl $0x2db0, %esi           # imm = 0x2DB0
jmp 0x5d4a
movq %rax, %r14
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21c0
jmp 0x5d5b
jmp 0x5d58
jmp 0x5d58
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x33be
movq %r14, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x33b3
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33be
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5d99
callq 0x2230
movq 0x50(%r14), %r15
testq %r15, %r15
je 0x5db7
movq %r15, %rdi
callq 0x549a
movl $0x4040, %esi           # imm = 0x4040
movq %r15, %rdi
callq 0x21c0
movq 0x58(%r14), %r15
testq %r15, %r15
je 0x5dd5
movq %r15, %rdi
callq 0x988a
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r15, %rdi
callq 0x21c0
movq $0x0, 0x58(%r14)
movq 0x60(%r14), %r15
testq %r15, %r15
je 0x5dfb
movq %r15, %rdi
callq 0x988a
movl $0x2db0, %esi           # imm = 0x2DB0
movq %r15, %rdi
callq 0x21c0
movq $0x0, 0x60(%r14)
movq %rbx, %rdi
callq 0x33be
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5e13
movq %rax, %rdi
callq 0x33b3
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5f64
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, %ebx         # imm = 0x7616C7
andl 0x20(%rsp), %ebx
movq (%r14), %rax
leaq (%rax,%rbx,4), %rbp
prefetcht0 (%rax,%rbx,4)
movzbl (%rax,%rbx,4), %ecx
movzbl 0x1(%rax,%rbx,4), %edx
addl %ecx, %edx
movzbl 0x2(%rax,%rbx,4), %esi
movzbl 0x3(%rax,%rbx,4), %ecx
addl %esi, %ecx
addl %edx, %ecx
movl 0x18(%r14), %eax
xorl %r13d, %r13d
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 (%rbp,%r13), %edx
leal (%rsi,%rdx), %edi
cmpl %eax, %edi
ja 0x5ec5
incq %r13
movl %edi, %esi
cmpq $0x4, %r13
jne 0x5ea8
jmp 0x5f7f
movq 0x10(%rsp), %rdi
callq 0x36b8
cmpb $-0x1, (%r13,%rbp)
je 0x5f2a
incb (%rbp,%r13)
movq 0x48(%r14), %rax
movb (%rax,%r13), %al
movb %al, (%r12)
movb (%r15), %cl
leaq 0xa2b6(%rip), %rdx      # 0x101a8
movq (%rdx), %rax
incq %rax
movq %rax, (%rdx)
cmpq %rax, 0x38(%r14)
je 0x5f34
cmpb $0x21, %cl
je 0x5f43
cmpq %rax, 0x30(%r14)
je 0x5f4d
leaq (,%rbx,4), %rbx
addq %r13, %rbx
incq %r12
incq %r15
cmpq 0x18(%rsp), %r12
jb 0x5e64
jmp 0x5f64
movq %rbp, %rdi
callq 0x2795
jmp 0x5ed7
movq 0x60(%r14), %rdi
callq 0x9a38
addq %rax, 0x38(%r14)
jmp 0x5f0c
movb 0x45(%r14), %al
movb %al, (%r12)
jmp 0x5f0c
movb 0x45(%r14), %al
movb %al, (%r12)
movq 0x58(%r14), %rdi
callq 0x9a38
addq %rax, 0x30(%r14)
jmp 0x5f0c
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 0x4eda(%rip), %rdi      # 0xae60
leaq 0x4ed7(%rip), %rsi      # 0xae64
leaq 0x4ee3(%rip), %rcx      # 0xae77
movl $0x63, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6100
movl %r9d, %eax
movq %rax, 0x18(%rsp)
leaq 0x8(%r15), %rax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
movl $0x7616c7, %r14d        # imm = 0x7616C7
andl 0x18(%rsp), %r14d
movq (%r15), %rax
leaq (%rax,%r14,4), %r12
prefetcht0 (%rax,%r14,4)
movzbl (%rax,%r14,4), %ecx
movzbl 0x1(%rax,%r14,4), %edx
addl %ecx, %edx
movzbl 0x2(%rax,%r14,4), %esi
movzbl 0x3(%rax,%r14,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 0x6048
incq %rbp
movl %edi, %esi
cmpq $0x4, %rbp
jne 0x602c
jmp 0x6119
movq 0x10(%rsp), %rdi
callq 0x36b8
cmpb $-0x1, (%rbp,%r12)
je 0x60be
incb (%r12,%rbp)
movq 0x48(%r15), %rax
movb (%rax,%rbp), %al
movq (%rsp), %rcx
movb %al, (%rcx,%r13)
cmpq 0x20(%rsp), %r13
jae 0x6083
movq 0x8(%rsp), %rax
cmpb $0x21, (%rax,%r13)
sete %al
jmp 0x6085
xorl %eax, %eax
leaq 0xa11c(%rip), %rdx      # 0x101a8
movq (%rdx), %rcx
incq %rcx
movq %rcx, (%rdx)
cmpq %rcx, 0x38(%r15)
je 0x60c8
testb %al, %al
jne 0x60d7
cmpq %rcx, 0x30(%r15)
je 0x60e5
leaq (,%r14,4), %r14
addq %rbp, %r14
incl %r13d
cmpq %rbx, %r13
jb 0x5fe3
jmp 0x6100
movq %r12, %rdi
callq 0x27ab
jmp 0x605a
movq 0x60(%r15), %rdi
callq 0x9a38
addq %rax, 0x38(%r15)
jmp 0x60a5
movb 0x45(%r15), %al
movq (%rsp), %rcx
movb %al, (%rcx,%r13)
jmp 0x60a5
movb 0x45(%r15), %al
movq (%rsp), %rcx
movb %al, (%rcx,%r13)
movq 0x58(%r15), %rdi
callq 0x9a38
addq %rax, 0x30(%r15)
jmp 0x60a5
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 0x4d40(%rip), %rdi      # 0xae60
leaq 0x4d3d(%rip), %rsi      # 0xae64
leaq 0x4d49(%rip), %rcx      # 0xae77
movl $0x63, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %rbx
subq $0x1480d8, %rsp         # imm = 0x1480D8
movq %rsi, %rdx
movl %edi, %esi
leaq 0xc1d3(%rip), %rdi      # 0x12320
callq 0x3d94
movb 0xc1d3(%rip), %bpl      # 0x1232c
cmpb $0x1, %bpl
jne 0x6176
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x80bc
movq %rbx, %rdi
callq 0x8e70
jmp 0x618a
leaq 0x8(%rsp), %rdi
callq 0x901a
leaq 0x8(%rsp), %rdi
callq 0x9518
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
testb %bpl, %bpl
je 0x619d
callq 0x852c
jmp 0x61a2
callq 0x927e
leaq 0xc177(%rip), %rdi      # 0x12320
callq 0x45e6
movl %ebx, %eax
addq $0x1480d8, %rsp         # imm = 0x1480D8
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x927e
jmp 0x61ce
jmp 0x61cb
movq %rax, %rbx
testb %bpl, %bpl
je 0x61dd
leaq 0x8(%rsp), %rdi
callq 0x852c
movq %rbx, %rdi
callq 0x22c0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4e92(%rip), %rsi      # 0xb0cc
movq %rax, %rdi
callq 0x4fca
movq %r14, 0x340(%rbx)
leaq 0xc0d0(%rip), %rax      # 0x12320
movl 0x4(%rax), %ebp
cmpl $0x1, %ebp
movl $0xc7000, %eax          # imm = 0xC7000
movl $0xc70000, %edi         # imm = 0xC70000
cmoveq %rax, %rdi
callq 0x2040
cmpl $0x1, %ebp
movl $0x1000, %edx           # imm = 0x1000
movl $0x10000, %ecx          # imm = 0x10000
cmoveq %rdx, %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movq %rax, %rdx
subq $-0x80, %rdx
xorl %esi, %esi
movdqa 0x4c47(%rip), %xmm1     # 0xaee0
movdqa 0x4c4f(%rip), %xmm2     # 0xaef0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rsi, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0x62ec
movq $0x0, (%rdx)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x6306
movq $0x0, 0xc7(%rdx)
addq $0x2, %rsi
addq $0x18e, %rdx            # imm = 0x18E
cmpq %rsi, %rcx
jne 0x62a9
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 0x6364
movq %rax, %r15
addq $0x310, %rbx            # imm = 0x310
movq %rbx, %rdi
callq 0x33be
movq %r15, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x33b3
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33be
leaq 0xbf7f(%rip), %rax      # 0x12320
cmpb $0x0, 0xe(%rax)
jne 0x63c6
movl 0x348(%r14), %edx
testq %rdx, %rdx
je 0x63c6
leaq 0xbf66(%rip), %rdi      # 0x12320
leaq 0x4b3f(%rip), %rsi      # 0xaf00
callq 0x3d22
movq (%r14), %rdi
testq %rdi, %rdi
je 0x63d3
callq 0x2230
movq 0x340(%r14), %r14
testq %r14, %r14
je 0x63f4
movq %r14, %rdi
callq 0x50f6
movl $0x4040, %esi           # imm = 0x4040
movq %r14, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x33be
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x6406
movq %rax, %rdi
callq 0x33b3
// File: /workspace/github_cpp_makefile_star2_O1/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 0x64cb
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 0x649c
movl %ebp, %edx
callq 0x6b70
andl $0x3f, %r13d
shll $0x6, %r13d
orl %ebp, %r13d
incq %r14
cmpq %rbx, %r14
jb 0x645c
jmp 0x64bd
movl $0x3f, %edx
callq 0x6b70
movq (%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x3270
incl 0x348(%r15)
jmp 0x6487
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Infinidat[P]slimfastq/qlts.cpp
// Function: QltSave::save_2(unsigned char const*, unsigned long)
void QltSave::save_2(const UCHAR* buf, size_t size) {
    UINT32 last = 0;
    for (const UCHAR* p = buf ; p < buf + size; p++) {
        UCHAR b = UCHAR(*p-'!');

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

// Assembly:
testq %rdx, %rdx
jle 0x656d
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 0x653e
movl %ebp, %edx
callq 0x6b70
shll $0x6, %r13d
movzwl %r13w, %r13d
orl %ebp, %r13d
incq %r14
cmpq %rbx, %r14
jb 0x64fe
jmp 0x655f
movl $0x3f, %edx
callq 0x6b70
movq (%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x3270
incl 0x348(%r15)
jmp 0x6529
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq