LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Infinidat[P]slimfastq/config.cpp
// Function: croak(char const*, ...)
void croak(const char *format, ...) {
    va_list args;
    va_start(args, format);
    fprintf(stderr, "slimfastq: %s %s: ",
            ( conf.encode ? "encoding" : "decoding"),
            conf.get_info("orig.filename"));

    // if (errno)
    //     fprintf(stderr, "err=%s", strerror(errno));

    vfprintf(stderr, format, args);
    fprintf(stderr, "\n");

    exit(1);
}

// Assembly:
subq $0xf8, %rsp
testb %al, %al
je 0x3492
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r9, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, 0xf0(%rsp)
leaq 0xd0(%rsp), %rax
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x100(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x12aec(%rip), %rax     # 0x15fd0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x14eed(%rip), %rax     # 0x183e0
testb $0x1, 0xc(%rax)
je 0x3507
leaq 0xcca7(%rip), %rax      # 0x101a7
movq %rax, 0x10(%rsp)
jmp 0x3515
leaq 0xcca2(%rip), %rax      # 0x101b0
movq %rax, 0x10(%rsp)
jmp 0x3515
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x14eba(%rip), %rdi     # 0x183e0
leaq 0xcc8c(%rip), %rsi      # 0x101b9
callq 0x3590
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0xcc4e(%rip), %rsi      # 0x10194
movb $0x0, %al
callq 0x2380
movq 0x12a7c(%rip), %rax     # 0x15fd0
movq (%rax), %rdi
movq 0xf0(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
callq 0x2350
movq 0x12a5d(%rip), %rax     # 0x15fd0
movq (%rax), %rdi
leaq 0xd4a7(%rip), %rsi      # 0x10a24
movb $0x0, %al
callq 0x2380
movl $0x1, %edi
callq 0x2310
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2400
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x5000
jmp 0x35cd
leaq 0x12c9c(%rip), %rdi     # 0x16270
leaq 0x38(%rsp), %rsi
callq 0x4f10
movq %rax, 0x8(%rsp)
jmp 0x35e5
movq 0x8(%rsp), %rdi
callq 0x2110
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
callq 0x21a0
leaq 0x37(%rsp), %rdi
callq 0x22c0
movq (%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x2130
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x3666
leaq 0xd3fa(%rip), %rax      # 0x10a25
movq %rax, 0x70(%rsp)
jmp 0x3670
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x365a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x21a0
leaq 0x37(%rsp), %rdi
callq 0x22c0
jmp 0x367a
movq 0x58(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x23f0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x12930(%rip), %rax     # 0x15fd0
movq (%rax), %rdi
leaq 0xcb1d(%rip), %rsi      # 0x101c7
movb $0x0, %al
callq 0x2380
leaq 0x12bb8(%rip), %rdi     # 0x16270
callq 0x4cb0
movq %rax, 0x28(%rsp)
leaq 0x12ba7(%rip), %rdi     # 0x16270
callq 0x4d00
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4ce0
testb $0x1, %al
jne 0x36e8
jmp 0x3755
movq 0x128e1(%rip), %rax     # 0x15fd0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4d30
movq %rax, %rdi
callq 0x2110
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4d30
movq %rax, %rdi
addq $0x20, %rdi
callq 0x2110
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0xca9f(%rip), %rsi      # 0x101d7
movb $0x0, %al
callq 0x2380
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x4d50
movq %rax, 0x18(%rsp)
jmp 0x36c2
movq 0x12874(%rip), %rax     # 0x15fd0
movq (%rax), %rdi
leaq 0xca7d(%rip), %rsi      # 0x101e3
movb $0x0, %al
callq 0x2380
callq 0x6c60
xorl %edi, %edi
callq 0x2310
nopl (%rax)
// File: Infinidat[P]slimfastq/config.cpp
// Function: Config::load_info() const
void Config::load_info() const {

    info_map.clear();
    char line[0x200];
    bool valid;
    FilerLoad filer(42, &valid);
    while (valid) {
        for (int i = 0; i < 0x200; i++) {
            line[i] = filer.get();
            if (not valid or
                line[i] == '\n')
                line[i] = 0;
            if (line[i] == 0)
                break;
        }
        char* pos = index(line, '=');
        if (pos) {
            *pos = 0;
            info_map.insert(info_pair (line, pos+1));
        }
    }
}

// Assembly:
subq $0x42e8, %rsp           # imm = 0x42E8
movq %rdi, 0x42e0(%rsp)
leaq 0x12ada(%rip), %rdi     # 0x16270
callq 0x4d90
leaq 0x98(%rsp), %rdi
movl $0x2a, %esi
leaq 0x40df(%rsp), %rdx
callq 0x74a0
testb $0x1, 0x40df(%rsp)
je 0x392e
movl $0x0, 0x94(%rsp)
cmpl $0x200, 0x94(%rsp) # imm = 0x200
jge 0x387e
leaq 0x98(%rsp), %rdi
callq 0x32c0
movb %al, 0x1f(%rsp)
jmp 0x37f2
movb 0x1f(%rsp), %cl
movslq 0x94(%rsp), %rax
movb %cl, 0x40e0(%rsp,%rax)
testb $0x1, 0x40df(%rsp)
je 0x3824
movslq 0x94(%rsp), %rax
movsbl 0x40e0(%rsp,%rax), %eax
cmpl $0xa, %eax
jne 0x384f
movslq 0x94(%rsp), %rax
movb $0x0, 0x40e0(%rsp,%rax)
jmp 0x384f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x3943
movslq 0x94(%rsp), %rax
movsbl 0x40e0(%rsp,%rax), %eax
cmpl $0x0, %eax
jne 0x3866
jmp 0x387e
jmp 0x3868
movl 0x94(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
jmp 0x37ce
leaq 0x40e0(%rsp), %rdi
movl $0x3d, %esi
callq 0x2190
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0x3929
movq 0x78(%rsp), %rax
movb $0x0, (%rax)
movq 0x78(%rsp), %rax
incq %rax
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x40e0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x4df0
jmp 0x38cf
leaq 0x1299a(%rip), %rdi     # 0x16270
leaq 0x38(%rsp), %rsi
callq 0x4da0
movb %dl, 0xf(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x38eb
movb 0xf(%rsp), %al
movq 0x10(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movb %al, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4ee0
jmp 0x3929
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4ee0
jmp 0x3943
jmp 0x37b5
leaq 0x98(%rsp), %rdi
callq 0x7520
addq $0x42e8, %rsp           # imm = 0x42E8
retq
leaq 0x98(%rsp), %rdi
callq 0x7520
movq 0x88(%rsp), %rdi
callq 0x23f0
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x200, 0x4(%rsp)       # imm = 0x200
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, 0x3(%rsp)
je 0x3c8b
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
setne %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x3c95
jmp 0x3cb5
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movzbl (%rax), %esi
callq 0x3160
jmp 0x3c66
cmpl $0x0, 0x4(%rsp)
jne 0x3cca
leaq 0xc539(%rip), %rdi      # 0x101fc
movb $0x0, %al
callq 0x3450
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rax), %rdi
movq 0x88(%rsp), %rsi
callq 0x3c50
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movl $0x3d, %esi
callq 0x3160
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x80(%rsp), %rsi
callq 0x3c50
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movl $0xa, %esi
callq 0x3160
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x88(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x50c0
movq 0x8(%rsp), %rsi
leaq 0x12500(%rip), %rdi     # 0x16270
callq 0x4da0
movb %dl, 0x17(%rsp)
movq %rax, 0x18(%rsp)
jmp 0x3d80
movb 0x17(%rsp), %al
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movb %al, 0x28(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4ee0
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4ee0
movq 0x38(%rsp), %rdi
callq 0x23f0
nopw %cs:(%rax,%rax)
// File: Infinidat[P]slimfastq/config.cpp
// Function: Config::Config()
Config::Config(){

    version = internal_version;

    quiet = false;
    profiling = false;
    encode = true;
    level = 3;
    m_info_filer = NULL;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x6, (%rax)
movb $0x0, 0xe(%rax)
movb $0x0, 0xd(%rax)
movb $0x1, 0xc(%rax)
movl $0x3, 0x4(%rax)
movq $0x0, 0x18(%rax)
retq
nopl (%rax)
// File: Infinidat[P]slimfastq/config.cpp
// Function: check_fh(_IO_FILE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
static void check_fh(FILE* f, std::string name, bool read=false) {
    if (f) return;
    fprintf(stderr, "Can't %s file '%s': %s\n",
            read?"read":"write", name.c_str(), strerror(errno));
    exit(1);
}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x18(%rsp)
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x4b38
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
movq 0x1148c(%rip), %rax     # 0x15fd0
movq (%rax), %rax
movq %rax, (%rsp)
movb 0x27(%rsp), %dl
leaq 0xc143(%rip), %rax      # 0x10c99
leaq 0xc137(%rip), %rcx      # 0x10c94
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x8(%rsp)
callq 0x2110
movq %rax, 0x10(%rsp)
callq 0x2060
movl (%rax), %edi
callq 0x20e0
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rax, %r8
leaq 0xc0e5(%rip), %rsi      # 0x10c7c
movb $0x0, %al
callq 0x2380
movl $0x1, %edi
callq 0x2310
nopl (%rax,%rax)
// File: Infinidat[P]slimfastq/config.cpp
// Function: range_level(int)
static int range_level(int level) {
    return
        level > 4 ? 4 :
        level < 1 ? 1 :
        level ;
}

// Assembly:
movl %edi, -0x4(%rsp)
cmpl $0x4, -0x4(%rsp)
jle 0x4bc6
movl $0x4, %eax
movl %eax, -0x8(%rsp)
jmp 0x4be8
cmpl $0x1, -0x4(%rsp)
jge 0x4bd8
movl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x4be0
movl -0x4(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rax)
je 0x4c69
callq 0x6c70
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdx
leaq 0xbf9e(%rip), %rsi      # 0x10bc3
callq 0x3dd0
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x4c57
movq 0x8(%rsp), %rdi
callq 0x6ed0
movq 0x8(%rsp), %rdi
movl $0x4040, %esi           # imm = 0x4040
callq 0x2290
callq 0x6c30
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
addq $0x28, %rsp
retq
nop
// File: 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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, 0x4030(%rax)
movl $0x0, 0x4034(%rax)
movb $0x1, 0x8(%rax)
movq $0x0, 0x2020(%rax)
movq $0x0, 0x2018(%rax)
movq $0x0, (%rax)
retq
// File: 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, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
cmpq $0x0, (%rax)
je 0x6cf3
movq -0x10(%rsp), %rcx
movq (%rcx), %rax
subq $0x1, %rax
shlq $0xd, %rax
addq 0x2018(%rcx), %rax
movq %rax, -0x18(%rsp)
jmp 0x6d04
movq -0x10(%rsp), %rax
movq 0x2018(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6c80
leaq 0xf544(%rip), %rdi      # 0x162a8
callq 0x7890
movq 0x8(%rsp), %rcx
movl %eax, 0x4038(%rcx)
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x6e00
movq %rax, %rcx
movl 0x14(%rsp), %eax
movl %eax, %edx
leaq 0xf516(%rip), %rax      # 0x162a8
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl 0x14(%rsp), %eax
movl %eax, %ecx
leaq 0xf4ff(%rip), %rax      # 0x162a8
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movl 0x14(%rsp), %eax
movl %eax, %ecx
leaq 0xf4e3(%rip), %rax      # 0x162a8
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x14(%rax)
leaq 0xf4ce(%rip), %rdi      # 0x162a8
callq 0x7920
movl %eax, %ecx
movl 0x14(%rsp), %eax
movl %eax, %edx
leaq 0xf4ba(%rip), %rax      # 0x162a8
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2130
cmpq $0x8, %rax
ja 0x6e1b
jmp 0x6e3a
leaq 0xa037(%rip), %rdi      # 0x10e59
leaq 0x91e3(%rip), %rsi      # 0x1000c
movl $0x9a, %edx
leaq 0xa035(%rip), %rcx      # 0x10e6a
callq 0x21b0
movq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdi
movl $0x8, %edx
callq 0x2160
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: Infinidat[P]slimfastq/filer.cpp
// Function: FilerSave::~FilerSave()
FilerSave::~FilerSave() {
    save_page(true);
    m_valid = false;
    if (m_node_p)
        save_node(0);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, %esi
callq 0x6f20
jmp 0x6eef
movq 0x8(%rsp), %rax
movb $0x0, 0x8(%rax)
cmpl $0x0, 0x4034(%rax)
je 0x6f11
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x7120
jmp 0x6f0f
jmp 0x6f11
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x2d30
nop
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x8(%rax)
je 0x6f51
movq 0x10(%rsp), %rax
cmpq $0x0, 0x2018(%rax)
jne 0x6f56
jmp 0x7115
movq 0x10(%rsp), %rax
cmpq $0x2000, 0x2018(%rax) # imm = 0x2000
ja 0x6f6a
jmp 0x6f89
leaq 0x9dc5(%rip), %rdi      # 0x10d36
leaq 0x9094(%rip), %rsi      # 0x1000c
movl $0xe0, %edx
leaq 0x9dc6(%rip), %rcx      # 0x10d4a
callq 0x21b0
movq 0x10(%rsp), %rax
cmpl $0x0, 0x4034(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x6fa3
jmp 0x703b
movq 0x10(%rsp), %rax
cmpl $0x0, 0x4030(%rax)
jne 0x6fb3
jmp 0x6fd2
leaq 0x9db0(%rip), %rdi      # 0x10d6a
leaq 0x904b(%rip), %rsi      # 0x1000c
movl $0xe3, %edx
leaq 0x9d7d(%rip), %rcx      # 0x10d4a
callq 0x21b0
movq 0x10(%rsp), %rdx
movl 0x4038(%rdx), %eax
movl %eax, %ecx
leaq 0xf2c2(%rip), %rax      # 0x162a8
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %esi
addq $0x9, %rdx
leaq 0xf2ad(%rip), %rdi      # 0x162a8
callq 0x7940
testb $0x1, 0x1f(%rsp)
jne 0x7039
leaq 0xf29a(%rip), %rdi      # 0x162a8
callq 0x7920
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4034(%rax)
movl 0x4038(%rax), %eax
movl %eax, %edx
leaq 0xf279(%rip), %rax      # 0x162a8
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x14(%rax)
jmp 0x70af
movq 0x10(%rsp), %rdx
movl 0x4030(%rdx), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x4030(%rdx)
movl %eax, %eax
movl 0x2030(%rdx,%rax,4), %esi
addq $0x9, %rdx
leaq 0xf243(%rip), %rdi      # 0x162a8
callq 0x7940
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpl $0x7ff, 0x4030(%rcx)    # imm = 0x7FF
movb %al, 0xf(%rsp)
jne 0x708b
movb 0x1f(%rsp), %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x7095
jmp 0x70ad
leaq 0xf20c(%rip), %rdi      # 0x162a8
callq 0x7920
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x7120
jmp 0x70af
testb $0x1, 0x1f(%rsp)
jne 0x70d6
leaq 0xf1eb(%rip), %rdi      # 0x162a8
callq 0x7920
movl %eax, %edx
movq 0x10(%rsp), %rax
movl 0x4030(%rax), %ecx
movl %edx, 0x2030(%rax,%rcx,4)
movq 0x10(%rsp), %rax
movq 0x2018(%rax), %rdx
movl 0x4038(%rax), %ecx
movl %ecx, %esi
leaq 0xf1b7(%rip), %rcx      # 0x162a8
imulq $0x18, %rsi, %rsi
addq %rsi, %rcx
addq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rcx)
movq $0x0, 0x2018(%rax)
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x7ff, 0x4030(%rax)    # imm = 0x7FF
ja 0x7144
jmp 0x7163
leaq 0x9ba9(%rip), %rdi      # 0x10cf4
leaq 0x8eba(%rip), %rsi      # 0x1000c
movl $0xd3, %edx
leaq 0x9bad(%rip), %rcx      # 0x10d0b
callq 0x21b0
movq (%rsp), %rax
cmpl $0x0, 0x4034(%rax)
je 0x7172
jmp 0x7191
leaq 0x9bb4(%rip), %rdi      # 0x10d2d
leaq 0x8e8c(%rip), %rsi      # 0x1000c
movl $0xd4, %edx
leaq 0x9b7f(%rip), %rcx      # 0x10d0b
callq 0x21b0
movq (%rsp), %rdx
movl 0xc(%rsp), %ecx
movl 0x4030(%rdx), %eax
movl %ecx, 0x2030(%rdx,%rax,4)
movl 0x4034(%rdx), %esi
addq $0x2030, %rdx           # imm = 0x2030
leaq 0xf0ee(%rip), %rdi      # 0x162a8
callq 0x7940
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4034(%rax)
movl $0x0, 0x4030(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6c80
movq 0x18(%rsp), %rdi
callq 0x6e00
movq %rax, %rsi
leaq 0xf092(%rip), %rdi      # 0x162a8
callq 0x79d0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4038(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x2028(%rax)
cmpl $0x0, 0x4038(%rax)
jne 0x7250
movq 0x8(%rsp), %rax
movb $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
jmp 0x7266
movq 0x8(%rsp), %rdi
movb $0x1, 0x8(%rdi)
movq 0x10(%rsp), %rax
movb $0x1, (%rax)
callq 0x7270
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movb 0x8(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x728e
jmp 0x7293
jmp 0x7490
movq 0x10(%rsp), %rdi
callq 0x6d20
movq 0x10(%rsp), %rcx
movl 0x4038(%rcx), %ecx
movl %ecx, %edx
leaq 0xeff7(%rip), %rcx      # 0x162a8
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jb 0x72d6
movq 0x10(%rsp), %rax
movb $0x0, 0x8(%rax)
movq 0x2028(%rax), %rax
movb $0x0, (%rax)
jmp 0x7490
movq 0x10(%rsp), %rax
cmpl $0x0, 0x4034(%rax)
jne 0x73a1
movq 0x10(%rsp), %rax
cmpl $0x0, 0x4030(%rax)
jne 0x72f8
jmp 0x7317
leaq 0x9a6b(%rip), %rdi      # 0x10d6a
leaq 0x8d06(%rip), %rsi      # 0x1000c
movl $0x11b, %edx            # imm = 0x11B
leaq 0x9a88(%rip), %rcx      # 0x10d9a
callq 0x21b0
movq 0x10(%rsp), %rdx
movl 0x4038(%rdx), %eax
movl %eax, %ecx
leaq 0xef7d(%rip), %rax      # 0x162a8
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %esi
addq $0x9, %rdx
leaq 0xef68(%rip), %rdi      # 0x162a8
callq 0x7a70
movq 0x10(%rsp), %rax
movl 0x4038(%rax), %ecx
movl %ecx, %edx
leaq 0xef4f(%rip), %rcx      # 0x162a8
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x4034(%rax)
cmpl $0x0, 0x4034(%rax)
je 0x7390
movq 0x10(%rsp), %rdx
movl 0x4034(%rdx), %esi
addq $0x2030, %rdx           # imm = 0x2030
leaq 0xef1d(%rip), %rdi      # 0x162a8
callq 0x7a70
movq 0x10(%rsp), %rax
movl $0x0, 0x4030(%rax)
jmp 0x741a
movq 0x10(%rsp), %rax
cmpl $0x7ff, 0x4030(%rax)    # imm = 0x7FF
jne 0x73eb
movq 0x10(%rsp), %rdx
movl 0x402c(%rdx), %eax
movl %eax, 0x4034(%rdx)
movl 0x4034(%rdx), %esi
addq $0x2030, %rdx           # imm = 0x2030
leaq 0xeed1(%rip), %rdi      # 0x162a8
callq 0x7a70
movq 0x10(%rsp), %rax
movl $0x0, 0x4030(%rax)
movq 0x10(%rsp), %rdx
movl 0x4030(%rdx), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x4030(%rdx)
movl %eax, %eax
movl 0x2030(%rdx,%rax,4), %esi
addq $0x9, %rdx
leaq 0xee93(%rip), %rdi      # 0x162a8
callq 0x7a70
movq 0x10(%rsp), %rcx
movq $0x0, 0x2018(%rcx)
movl 0x4038(%rcx), %eax
movl %eax, %edx
leaq 0xee6f(%rip), %rax      # 0x162a8
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
shrq $0xd, %rax
cmpq (%rcx), %rax
jne 0x7469
movq 0x18(%rsp), %rax
andq $0x1fff, %rax           # imm = 0x1FFF
movq %rax, 0x8(%rsp)
jmp 0x7475
movl $0x2000, %eax           # imm = 0x2000
movq %rax, 0x8(%rsp)
jmp 0x7475
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x2020(%rax)
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6c80
cmpl $0x2a, 0x1c(%rsp)
jne 0x74ca
jmp 0x74e9
leaq 0x97f9(%rip), %rdi      # 0x10cca
leaq 0x8b34(%rip), %rsi      # 0x1000c
movl $0x103, %edx            # imm = 0x103
leaq 0x9894(%rip), %rcx      # 0x10d78
callq 0x21b0
movq 0x8(%rsp), %rdi
movl $0x0, 0x4038(%rdi)
movq 0x10(%rsp), %rax
movq %rax, 0x2028(%rdi)
movb $0x1, 0x8(%rdi)
movq 0x10(%rsp), %rax
movb $0x1, (%rax)
callq 0x7270
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: Infinidat[P]slimfastq/filer.cpp
// Function: OneFile::init_write(_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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq $0x1, 0x2010(%rax)
movq $0x0, 0x2028(%rax)
movq -0x10(%rsp), %rcx
movq %rcx, 0x2020(%rax)
movq $0x0, (%rax)
movl $0x0, 0x10(%rax)
movq $0x2, 0x2018(%rax)
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x2020(%rax)
je 0x76fa
movq 0x8(%rsp), %rdx
movq 0x2010(%rdx), %rax
movl %eax, 0x10(%rdx)
movl $0x1, %esi
movq %rdx, %rdi
callq 0x7940
movq 0x8(%rsp), %rax
movq 0x2020(%rax), %rdi
callq 0x2270
movq 0x8(%rsp), %rax
movq $0x0, 0x2020(%rax)
addq $0x18, %rsp
retq
nop
// File: Infinidat[P]slimfastq/filer.cpp
// Function: OneFile::init_read(_IO_FILE*)
void init_read(FILE* in) {
        next_findex = 1;
        m_in  = in;
        m_out = NULL;

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

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

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xe856(%rip), %rax      # 0x15fd0
movq (%rax), %rdi
leaq 0x9632(%rip), %rsi      # 0x10db6
movb $0x0, %al
callq 0x2380
movl $0x0, 0x3c(%rsp)
movq 0x28(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpq 0x2010(%rcx), %rax
jae 0x7866
movq 0x28(%rsp), %rsi
leaq 0x32(%rsp), %rdi
movl 0x3c(%rsp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rsi
movl $0x8, %edx
callq 0x2160
movq 0xe801(%rip), %rax      # 0x15fd0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0x77f2
leaq 0x32(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x7800
leaq 0x960b(%rip), %rax      # 0x10e04
movq %rax, 0x10(%rsp)
jmp 0x7800
movl 0x24(%rsp), %edx
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0x3c(%rsp), %esi
imulq $0x18, %rsi, %r8
movq %rax, %rsi
addq %r8, %rsi
movq 0x8(%rsi), %r8
movl 0x3c(%rsp), %esi
imulq $0x18, %rsi, %r9
movq %rax, %rsi
addq %r9, %rsi
movl 0x10(%rsi), %r9d
movl 0x3c(%rsp), %esi
imulq $0x18, %rsi, %rsi
addq %rsi, %rax
movl 0x14(%rax), %eax
leaq 0x9599(%rip), %rsi      # 0x10de5
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2380
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x7793
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x2020(%rax)
je 0x78af
jmp 0x78ce
leaq 0x9555(%rip), %rdi      # 0x10e0b
leaq 0x874f(%rip), %rsi      # 0x1000c
movl $0x3f, %edx
leaq 0x9548(%rip), %rcx      # 0x10e11
callq 0x21b0
movq 0x8(%rsp), %rax
cmpq $0x155, 0x2010(%rax) # imm = 0x155
jb 0x78f8
movq 0x8(%rsp), %rax
movq 0x2010(%rax), %rsi
leaq 0x953b(%rip), %rdi      # 0x10e2e
callq 0x7560
movq 0x8(%rsp), %rcx
movq 0x2010(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x2010(%rcx)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %ecx
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rcx
shlq $0xd, %rcx
movq %rcx, 0x18(%rsp)
movq 0x2020(%rax), %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x22f0
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rdi
movq 0x2020(%rax), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x2420
movl %eax, 0x14(%rsp)
cmpl $0x2000, 0x14(%rsp)     # imm = 0x2000
je 0x79c6
movl 0x2c(%rsp), %eax
movl %eax, %esi
leaq 0x94c5(%rip), %rdi      # 0x10e86
callq 0x7560
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x2028(%rax)
je 0x79f3
jmp 0x7a12
leaq 0x94ad(%rip), %rdi      # 0x10ea7
leaq 0x860b(%rip), %rsi      # 0x1000c
movl $0x45, %edx
leaq 0x949f(%rip), %rcx      # 0x10eac
callq 0x21b0
movl $0x1, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpq 0x2010(%rcx), %rax
jae 0x7a5d
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x7a4e
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x7a65
jmp 0x7a50
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x7a1a
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %ecx
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rcx
shlq $0xd, %rcx
movq %rcx, 0x18(%rsp)
movq 0x2028(%rax), %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x22f0
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rdi
movq 0x2028(%rax), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x23a0
movl %eax, 0x14(%rsp)
cmpl $0x2000, 0x14(%rsp)     # imm = 0x2000
je 0x7af6
movl 0x2c(%rsp), %eax
movl %eax, %esi
leaq 0x93de(%rip), %rdi      # 0x10ecf
callq 0x7560
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: Infinidat[P]slimfastq/gens.cpp
// Function: GenBase::ranger_cnt()
size_t GenBase::ranger_cnt() {
    switch(conf.level) {
    case 1: return BRANGER_SIZE_1;
    default:
    case 2: return BRANGER_SIZE_2;
    case 3: return BRANGER_SIZE_3;
    case 4: return BRANGER_SIZE_4;
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
leaq 0x108d4(%rip), %rax     # 0x183e0
movl 0x4(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0x3, %eax
ja 0x7b3d
movq -0x18(%rsp), %rax
leaq 0x93c7(%rip), %rcx      # 0x10ef0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x40000, -0x8(%rsp)    # imm = 0x40000
jmp 0x7b5e
jmp 0x7b3f
movq $0x400000, -0x8(%rsp)   # imm = 0x400000
jmp 0x7b5e
movq $0x1000000, -0x8(%rsp)  # imm = 0x1000000
jmp 0x7b5e
movq $0x4000000, -0x8(%rsp)  # imm = 0x4000000
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x8, %rdi
callq 0x2d40
jmp 0x7e6e
leaq 0x1056b(%rip), %rax     # 0x183e0
testb $0x1, 0xe(%rax)
jne 0x7e7d
jmp 0x7e7d
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x7e9a
movq 0x20(%rsp), %rdi
callq 0x2340
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x7ec7
movq 0x18(%rsp), %rdi
callq 0x6ed0
movq 0x18(%rsp), %rdi
movl $0x4040, %esi           # imm = 0x4040
callq 0x2290
jmp 0x7ec9
movq 0x28(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x7f04
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x7f02
movq 0x10(%rsp), %rdi
callq 0xf700
movq 0x10(%rsp), %rdi
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
jmp 0x7f04
movq 0x28(%rsp), %rax
movq $0x0, 0x50(%rax)
jmp 0x7f13
jmp 0x7f15
movq 0x28(%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0x7f50
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x7f4e
movq 0x8(%rsp), %rdi
callq 0xf700
movq 0x8(%rsp), %rdi
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
jmp 0x7f50
movq 0x28(%rsp), %rax
movq $0x0, 0x58(%rax)
jmp 0x7f5f
movq 0x28(%rsp), %rdi
callq 0x89e0
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x2d30
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movb %r8b, %al
movq %rdi, 0x10(%rsp)
movb %sil, 0xf(%rsp)
movb %dl, 0xe(%rsp)
andb $0x1, %cl
movb %cl, 0xd(%rsp)
andb $0x1, %al
movb %al, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0xd(%rsp)
jne 0x7fe4
movq (%rsp), %rax
movq 0x58(%rax), %rdi
leaq 0xe2a7(%rip), %rcx      # 0x16268
movq (%rcx), %rsi
subq 0x38(%rax), %rsi
callq 0xf7a0
movq (%rsp), %rax
leaq 0xe290(%rip), %rcx      # 0x16268
movq (%rcx), %rcx
movq %rcx, 0x38(%rax)
jmp 0x8084
movq (%rsp), %rax
cmpb $0x0, 0x45(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7ff7
jmp 0x802c
movq (%rsp), %rax
movb 0xf(%rsp), %cl
movb %cl, 0x45(%rax)
movzbl 0xf(%rsp), %ecx
movl $0x4e, %eax
cmpl %ecx, %eax
je 0x802a
movzbl 0xf(%rsp), %eax
movl %eax, %edx
leaq 0x103c2(%rip), %rdi     # 0x183e0
leaq 0x8f05(%rip), %rsi      # 0x10f2a
callq 0x3dd0
jmp 0x802c
movq (%rsp), %rcx
movzbl 0xf(%rsp), %eax
movzbl 0x45(%rcx), %ecx
cmpl %ecx, %eax
je 0x8050
movzbl 0xf(%rsp), %esi
leaq 0x8eec(%rip), %rdi      # 0x10f35
movb $0x0, %al
callq 0x3450
testb $0x1, 0xc(%rsp)
jne 0x8084
movq (%rsp), %rax
movq 0x50(%rax), %rdi
leaq 0xe202(%rip), %rcx      # 0x16268
movq (%rcx), %rsi
subq 0x30(%rax), %rsi
callq 0xf7a0
movq (%rsp), %rax
leaq 0xe1eb(%rip), %rcx      # 0x16268
movq (%rcx), %rcx
movq %rcx, 0x30(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x7616c7, 0x2c(%rsp)   # imm = 0x7616C7
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x48(%rsp), %rcx
addq 0x38(%rsp), %rcx
cmpq %rcx, %rax
jae 0x8180
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movb (%rax), %cl
movq 0x18(%rsp), %rax
movzbl %cl, %esi
movzbl (%rax), %edx
callq 0x8a00
movq 0x8(%rsp), %rsi
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rcx
movl 0x2c(%rsp), %eax
andq %rcx, %rax
movl %eax, 0x2c(%rsp)
movq (%rsi), %rax
movl 0x2c(%rsp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
prefetcht0 (%rax)
movq (%rsi), %rdi
movl 0x2c(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
addq $0x8, %rsi
movzbl 0x17(%rsp), %edx
callq 0x8af0
movl 0x2c(%rsp), %eax
shll $0x2, %eax
movzbl 0x17(%rsp), %ecx
orl %ecx, %eax
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x80d3
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x7616c7, 0x24(%rsp)   # imm = 0x7616C7
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpq 0x38(%rsp), %rax
jae 0x8294
movq 0x48(%rsp), %rax
movl 0x20(%rsp), %ecx
movb (%rax,%rcx), %al
movb %al, 0xf(%rsp)
movl 0x20(%rsp), %eax
cmpq 0x30(%rsp), %rax
jae 0x8209
movq 0x40(%rsp), %rax
movl 0x20(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x8(%rsp)
jmp 0x8214
movl $0x28, %eax
movl %eax, 0x8(%rsp)
jmp 0x8214
movq 0x10(%rsp), %rdi
movb 0xf(%rsp), %cl
movl 0x8(%rsp), %eax
movzbl %cl, %esi
movzbl %al, %edx
callq 0x8a00
movq 0x10(%rsp), %rsi
movb %al, 0x1f(%rsp)
movq 0x28(%rsp), %rcx
movl 0x24(%rsp), %eax
andq %rcx, %rax
movl %eax, 0x24(%rsp)
movq (%rsi), %rax
movl 0x24(%rsp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
prefetcht0 (%rax)
movq (%rsi), %rdi
movl 0x24(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
addq $0x8, %rsi
movzbl 0x1f(%rsp), %edx
callq 0x8af0
movl 0x24(%rsp), %eax
shll $0x2, %eax
movzbl 0x1f(%rsp), %ecx
orl %ecx, %eax
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x81cc
addq $0x58, %rsp
retq
nopl (%rax)
// File: Infinidat[P]slimfastq/gens.cpp
// Function: GenLoad::~GenLoad()
GenLoad::~GenLoad() {
    rcoder.done();
    delete []ranger;
    delete   filer;
    DELETE(x_Ns);
    DELETE(x_Nn);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x8, %rdi
callq 0x2d40
jmp 0x862e
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x864b
movq 0x20(%rsp), %rdi
callq 0x2340
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x8678
movq 0x18(%rsp), %rdi
callq 0x7520
movq 0x18(%rsp), %rdi
movl $0x4040, %esi           # imm = 0x4040
callq 0x2290
jmp 0x867a
movq 0x28(%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0x86b5
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x86b3
movq 0x10(%rsp), %rdi
callq 0xf840
movq 0x10(%rsp), %rdi
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
jmp 0x86b5
movq 0x28(%rsp), %rax
movq $0x0, 0x58(%rax)
jmp 0x86c4
jmp 0x86c6
movq 0x28(%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x8701
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x86ff
movq 0x8(%rsp), %rdi
callq 0xf840
movq 0x8(%rsp), %rdi
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
jmp 0x8701
movq 0x28(%rsp), %rax
movq $0x0, 0x60(%rax)
jmp 0x8710
movq 0x28(%rsp), %rdi
callq 0x89e0
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x2d30
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x7616c7, 0x2c(%rsp)   # imm = 0x7616C7
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x48(%rsp), %rcx
addq 0x38(%rsp), %rcx
cmpq %rcx, %rax
jae 0x8829
movq 0x8(%rsp), %rsi
movq 0x30(%rsp), %rcx
movl 0x2c(%rsp), %eax
andq %rcx, %rax
movl %eax, 0x2c(%rsp)
movq (%rsi), %rax
movl 0x2c(%rsp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
prefetcht0 (%rax)
movq (%rsi), %rdi
movl 0x2c(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
addq $0x8, %rsi
callq 0x8bc0
movq 0x8(%rsp), %rdi
movb %al, 0x17(%rsp)
movq 0x48(%rdi), %rax
movzbl 0x17(%rsp), %ecx
movb (%rax,%rcx), %cl
movq 0x20(%rsp), %rax
movb %cl, (%rax)
movl 0x2c(%rsp), %eax
shll $0x2, %eax
movzbl 0x17(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
movzbl (%rax), %edx
callq 0x8cb0
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x8773
movq 0x8(%rsp), %rax
testb $0x1, 0x44(%rax)
je 0x883f
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
jmp 0x8847
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x8847
movq (%rsp), %rax
addq $0x58, %rsp
retq
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x7616c7, 0x34(%rsp)   # imm = 0x7616C7
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpq 0x48(%rsp), %rax
jae 0x896d
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %eax
andq %rcx, %rax
movl %eax, 0x34(%rsp)
movq (%rsi), %rax
movl 0x34(%rsp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
prefetcht0 (%rax)
movq (%rsi), %rdi
movl 0x34(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
addq $0x8, %rsi
callq 0x8bc0
movb %al, %cl
movq 0x20(%rsp), %rax
movb %cl, 0x2f(%rsp)
movq 0x48(%rax), %rax
movzbl 0x2f(%rsp), %ecx
movb (%rax,%rcx), %dl
movq 0x58(%rsp), %rax
movl 0x30(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0x34(%rsp), %eax
shll $0x2, %eax
movzbl 0x2f(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x34(%rsp)
movq 0x58(%rsp), %rax
movl 0x30(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0x30(%rsp), %eax
cmpq 0x40(%rsp), %rax
jae 0x893c
movq 0x50(%rsp), %rax
movl 0x30(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x14(%rsp)
jmp 0x8947
movl $0x28, %eax
movl %eax, 0x14(%rsp)
jmp 0x8947
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %eax
movzbl %al, %edx
callq 0x8cb0
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x888c
movq 0x20(%rsp), %rax
testb $0x1, 0x44(%rax)
je 0x8984
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x898d
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x898d
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: Infinidat[P]slimfastq/gens.cpp
// Function: GenSave::normalize_gen(unsigned char, unsigned char)
inline UCHAR GenSave::normalize_gen(UCHAR gen, UCHAR qlt) {

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

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

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, 0x20(%rsp)
movb %cl, 0x1f(%rsp)
movb %al, 0x1e(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movzbl 0x1e(%rsp), %eax
cmpl $0x21, %eax
sete %al
andb $0x1, %al
movb %al, 0x1c(%rsp)
movzbl 0x1f(%rsp), %eax
movl %eax, %ecx
leaq 0xf8a1(%rip), %rax      # 0x182e0
movb (%rax,%rcx), %al
movb %al, 0x1b(%rsp)
movzbl 0x1b(%rsp), %eax
cmpl $0x3, %eax
jg 0x8a57
movb $0x0, 0x1d(%rsp)
jmp 0x8a7e
movzbl 0x1b(%rsp), %eax
cmpl $0x4, %eax
jle 0x8a74
movzbl 0x1f(%rsp), %esi
leaq 0x8508(%rip), %rdi      # 0x10f75
movb $0x0, %al
callq 0x3450
movb $0x1, 0x1d(%rsp)
movb $0x0, 0x1b(%rsp)
leaq 0xd7e3(%rip), %rax      # 0x16268
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0xd7d5(%rip), %rax      # 0x16268
movq %rcx, (%rax)
movb $0x1, %al
testb $0x1, 0x1d(%rsp)
movb %al, 0xf(%rsp)
jne 0x8aab
movb 0x1c(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x8ab5
jmp 0x8ae3
movq 0x10(%rsp), %rdi
movb 0x1f(%rsp), %sil
movb 0x1e(%rsp), %dl
movb 0x1d(%rsp), %cl
movb 0x1c(%rsp), %al
andb $0x1, %cl
andb $0x1, %al
movzbl %sil, %esi
movzbl %dl, %edx
movzbl %cl, %ecx
movzbl %al, %r8d
callq 0x7f80
movb 0x1b(%rsp), %al
addq $0x28, %rsp
retq
nopl (%rax)