LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Infinidat[P]slimfastq/./base2_ranger.hpp
// Function: Base2Ranger::put(RCoder*, unsigned char)
inline void put(RCoder *rc, UCHAR sym) {
        UINT16 total = getsum();
        UINT16 offs = 0;
        switch(sym) {
        case 3: offs += freq[2];
        case 2: offs += freq[1];
        case 1: offs += freq[0];
        }
        rc->Encode( offs, freq[sym], total);
        update_freq(sym, total);
    }

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x8d80
movw %ax, 0x14(%rsp)
movw $0x0, 0x12(%rsp)
movzbl 0x17(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x8b6c
jmp 0x8b2e
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x8b58
jmp 0x8b39
movl 0xc(%rsp), %eax
subl $0x3, %eax
jne 0x8b7f
jmp 0x8b44
movq (%rsp), %rax
movzbl 0x2(%rax), %ecx
movzwl 0x12(%rsp), %eax
addl %ecx, %eax
movw %ax, 0x12(%rsp)
movq (%rsp), %rax
movzbl 0x1(%rax), %ecx
movzwl 0x12(%rsp), %eax
addl %ecx, %eax
movw %ax, 0x12(%rsp)
movq (%rsp), %rax
movzbl (%rax), %ecx
movzwl 0x12(%rsp), %eax
addl %ecx, %eax
movw %ax, 0x12(%rsp)
movq (%rsp), %rax
movq 0x18(%rsp), %rdi
movzwl 0x12(%rsp), %esi
movzbl 0x17(%rsp), %ecx
movzbl (%rax,%rcx), %edx
movzwl 0x14(%rsp), %ecx
callq 0x2f50
movq (%rsp), %rdi
movzbl 0x17(%rsp), %esi
movzwl 0x14(%rsp), %edx
callq 0x8da0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Infinidat[P]slimfastq/./base2_ranger.hpp
// Function: Base2Ranger::get(RCoder*)
inline UCHAR get(RCoder *rc) {

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

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

        update_freq(i, total);
        return i;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x8d80
movw %ax, 0x16(%rsp)
movq 0x18(%rsp), %rdi
movzwl 0x16(%rsp), %esi
callq 0x3330
movl %eax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
cmpl $0x4, 0x8(%rsp)
jge 0x8c4c
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
movslq 0x8(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
cmpl 0x10(%rsp), %eax
ja 0x8c3b
movq (%rsp), %rax
movslq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x8c3d
jmp 0x8c4c
jmp 0x8c3f
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x8c04
cmpl $0x4, 0x8(%rsp)
jge 0x8c55
jmp 0x8c74
leaq 0x8334(%rip), %rdi      # 0x10f90
leaq 0x8331(%rip), %rsi      # 0x10f94
movl $0x63, %edx
leaq 0x8338(%rip), %rcx      # 0x10fa7
callq 0x21b0
movq (%rsp), %rax
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
movslq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %edx
movzwl 0x16(%rsp), %ecx
callq 0x3360
movq (%rsp), %rdi
movl 0x8(%rsp), %esi
movzwl 0x16(%rsp), %edx
callq 0x8da0
movl 0x8(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: Infinidat[P]slimfastq/gens.cpp
// Function: GenLoad::normalize_gen(unsigned char&, unsigned char)
void GenLoad::normalize_gen(UCHAR & gen, UCHAR qlt) {
    g_genofs_count ++ ;

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

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

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

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xd593(%rip), %rcx      # 0x16268
movq (%rcx), %rdx
addq $0x1, %rdx
leaq 0xd585(%rip), %rcx      # 0x16268
movq %rdx, (%rcx)
movq 0x38(%rax), %rax
leaq 0xd577(%rip), %rcx      # 0x16268
cmpq (%rcx), %rax
jne 0x8d16
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0xfb60
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
jmp 0x8d72
movzbl 0x17(%rsp), %eax
cmpl $0x21, %eax
jne 0x8d31
movq 0x8(%rsp), %rax
movb 0x45(%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
jmp 0x8d70
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
leaq 0xd527(%rip), %rcx      # 0x16268
cmpq (%rcx), %rax
jne 0x8d6e
movq 0x8(%rsp), %rax
movb 0x45(%rax), %dl
movq 0x18(%rsp), %rcx
movb %dl, (%rcx)
movq 0x58(%rax), %rdi
callq 0xfb60
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
jmp 0x8d70
jmp 0x8d72
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: Infinidat[P]slimfastq/./base2_ranger.hpp
// Function: Base2Ranger::update_freq(int, unsigned short)
inline void update_freq(int sym , UINT16 total) {
        rarely_if(freq[sym] > (MAX_FREQ))
            normalize();

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

// Assembly:
subq $0x18, %rsp
movw %dx, %ax
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movw %ax, 0xa(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movslq 0xc(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xfe, %eax
jle 0x8dd7
movq (%rsp), %rdi
callq 0x8df0
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
movb (%rax,%rcx), %dl
addb $0x1, %dl
movb %dl, (%rax,%rcx)
addq $0x18, %rsp
retq
nop
// File: Infinidat[P]slimfastq/./base2_ranger.hpp
// Function: Base2Ranger::normalize()
void normalize() {
        freq_val =
            ((freq_val & ~M_ONES) >> 1 ) |
             (freq_val &  M_ONES);
        // (freq_val & ~M_ONES) >> 1 ;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %ecx
andl $0xfefefefe, %ecx       # imm = 0xFEFEFEFE
shrl %ecx
movl (%rax), %edx
andl $0x1010101, %edx        # imm = 0x1010101
orl %edx, %ecx
movl %ecx, (%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x16c1d8, %rsp         # imm = 0x16C1D8
movl $0x0, 0x16c1d4(%rsp)
movl %edi, 0x16c1d0(%rsp)
movq %rsi, 0x16c1c8(%rsp)
movl 0x16c1d0(%rsp), %esi
movq 0x16c1c8(%rsp), %rdx
leaq 0xf589(%rip), %rdi      # 0x183e0
callq 0x3e70
movb 0xf58a(%rip), %al       # 0x183ec
movb $0x0, 0x240ef(%rsp)
movb $0x0, 0x1f(%rsp)
testb $0x1, %al
je 0x8ea7
leaq 0x240f0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xc8c0
movq 0x10(%rsp), %rdi
movb $0x1, 0x240ef(%rsp)
callq 0xe0b0
movl %eax, 0x18(%rsp)
jmp 0x8e9d
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x8ed2
leaq 0x20(%rsp), %rdi
callq 0xe2c0
jmp 0x8eb3
movb $0x1, 0x1f(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xee80
movl %eax, 0x8(%rsp)
jmp 0x8ec8
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x8ed2
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0x8ee3
jmp 0x8eed
leaq 0x20(%rsp), %rdi
callq 0xe780
testb $0x1, 0x240ef(%rsp)
jne 0x8ef9
jmp 0x8f06
leaq 0x240f0(%rsp), %rdi
callq 0xd1b0
movl 0x4(%rsp), %eax
movl %eax, 0x16c1c4(%rsp)
leaq 0xf4c8(%rip), %rdi      # 0x183e0
callq 0x4bf0
movl 0x16c1c4(%rsp), %eax
addq $0x16c1d8, %rsp         # imm = 0x16C1D8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240e0(%rsp)
movl %eax, 0x240dc(%rsp)
jmp 0x8f6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240e0(%rsp)
movl %eax, 0x240dc(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0x8f5f
jmp 0x8f69
leaq 0x20(%rsp), %rdi
callq 0xe780
jmp 0x8f6b
testb $0x1, 0x240ef(%rsp)
jne 0x8f77
jmp 0x8f84
leaq 0x240f0(%rsp), %rdi
callq 0xd1b0
jmp 0x8f86
movq 0x240e0(%rsp), %rdi
callq 0x23f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x9ce0
movl $0x4040, %edi           # imm = 0x4040
callq 0x2280
movq %rax, 0x38(%rsp)
jmp 0x8ff9
movq 0x38(%rsp), %rdi
leaq 0x82c3(%rip), %rsi      # 0x112c8
callq 0x6d40
jmp 0x900c
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x340(%rdi)
callq 0x8fa0
movq %rax, %rcx
movq %rcx, 0x18(%rsp)
movl $0xc7, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
movq %rdi, 0x20(%rsp)
callq 0x2040
movq %rax, 0x28(%rsp)
jmp 0x9051
movq 0x18(%rsp), %rax
cmpq $0x0, %rax
je 0x90a6
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
imulq $0xc7, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x9d20
jmp 0x908d
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
addq $0xc7, %rax
cmpq %rcx, %rax
movq %rax, 0x10(%rsp)
jne 0x907d
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x340(%rax)
je 0x90bf
jmp 0x9132
leaq 0x6f67(%rip), %rdi      # 0x1002d
leaq 0x7efb(%rip), %rsi      # 0x10fc8
movl $0x30, %edx
leaq 0x7ef8(%rip), %rcx      # 0x10fd1
callq 0x21b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x9198
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x4040, %esi           # imm = 0x4040
callq 0x2290
jmp 0x9198
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x2430
jmp 0x9198
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
je 0x913f
jmp 0x915e
leaq 0x6ebe(%rip), %rdi      # 0x10004
leaq 0x7e7b(%rip), %rsi      # 0x10fc8
movl $0x31, %edx
leaq 0x7e78(%rip), %rcx      # 0x10fd1
callq 0x21b0
movq 0x30(%rsp), %rax
movq %rax, %rdi
addq $0x310, %rdi            # imm = 0x310
movq 0x340(%rax), %rsi
callq 0x2bf0
jmp 0x917b
movq 0x30(%rsp), %rdi
addq $0x348, %rdi            # imm = 0x348
xorl %esi, %esi
movl $0x4, %edx
callq 0x2170
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x9d40
movq 0x48(%rsp), %rdi
callq 0x23f0
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x310, %rdi            # imm = 0x310
callq 0x2d40
jmp 0x91d1
leaq 0xf208(%rip), %rax      # 0x183e0
testb $0x1, 0xe(%rax)
jne 0x9212
movq 0x18(%rsp), %rax
cmpl $0x0, 0x348(%rax)
je 0x9210
movq 0x18(%rsp), %rax
movl 0x348(%rax), %eax
movl %eax, %edx
leaq 0xf1e0(%rip), %rdi      # 0x183e0
leaq 0x7ddd(%rip), %rsi      # 0x10fe4
callq 0x3dd0
jmp 0x920e
jmp 0x9210
jmp 0x9212
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x922f
movq 0x10(%rsp), %rdi
callq 0x2340
movq 0x18(%rsp), %rax
movq 0x340(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x925f
movq 0x8(%rsp), %rdi
callq 0x6ed0
movq 0x8(%rsp), %rdi
movl $0x4040, %esi           # imm = 0x4040
callq 0x2290
movq 0x18(%rsp), %rdi
callq 0x9d40
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x2d30
nopw %cs:(%rax,%rax)
// File: Infinidat[P]slimfastq/qlts.cpp
// Function: QltSave::is_valid()
bool QltSave::is_valid() {
    return
        m_valid and
        filer and
        filer->is_valid();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
xorl %eax, %eax
testb $0x1, 0x338(%rcx)
movb %al, 0xf(%rsp)
je 0x92c9
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x340(%rcx)
movb %al, 0xf(%rsp)
je 0x92c9
movq (%rsp), %rax
movq 0x340(%rax), %rdi
callq 0x6d30
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
addq 0x20(%rsp), %rcx
cmpq %rcx, %rax
jae 0x93f9
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movzbl (%rcx), %ecx
subl $0x21, %ecx
movb %cl, 0xf(%rsp)
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
imulq $0xc7, %rcx, %rcx
addq %rcx, %rax
prefetcht0 (%rax)
movzbl 0xf(%rsp), %eax
cmpl $0x3f, %eax
jge 0x937f
movq (%rsp), %rsi
movq (%rsi), %rdi
movl 0x1c(%rsp), %eax
imulq $0xc7, %rax, %rax
addq %rax, %rdi
addq $0x310, %rsi            # imm = 0x310
movzbl 0xf(%rsp), %edx
callq 0x9d60
jmp 0x93d4
movq (%rsp), %rsi
movq (%rsi), %rdi
movl 0x1c(%rsp), %eax
imulq $0xc7, %rax, %rax
addq %rax, %rdi
addq $0x310, %rsi            # imm = 0x310
movl $0x3f, %edx
callq 0x9d60
movq (%rsp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x310, %rsi            # imm = 0x310
movzbl 0xf(%rsp), %edx
callq 0x2c20
movq (%rsp), %rax
movl 0x348(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x348(%rax)
movl 0x1c(%rsp), %edi
movzbl 0xf(%rsp), %esi
callq 0x9ea0
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x930e
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
addq 0x20(%rsp), %rcx
cmpq %rcx, %rax
jae 0x9519
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movzbl (%rcx), %ecx
subl $0x21, %ecx
movb %cl, 0xf(%rsp)
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
imulq $0xc7, %rcx, %rcx
addq %rcx, %rax
prefetcht0 (%rax)
movzbl 0xf(%rsp), %eax
cmpl $0x3f, %eax
jge 0x949f
movq (%rsp), %rsi
movq (%rsi), %rdi
movl 0x1c(%rsp), %eax
imulq $0xc7, %rax, %rax
addq %rax, %rdi
addq $0x310, %rsi            # imm = 0x310
movzbl 0xf(%rsp), %edx
callq 0x9d60
jmp 0x94f4
movq (%rsp), %rsi
movq (%rsi), %rdi
movl 0x1c(%rsp), %eax
imulq $0xc7, %rax, %rax
addq %rax, %rdi
addq $0x310, %rsi            # imm = 0x310
movl $0x3f, %edx
callq 0x9d60
movq (%rsp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x310, %rsi            # imm = 0x310
movzbl 0xf(%rsp), %edx
callq 0x2c20
movq (%rsp), %rax
movl 0x348(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x348(%rax)
movl 0x1c(%rsp), %edi
movzbl 0xf(%rsp), %esi
callq 0x9ec0
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x942e
addq $0x38, %rsp
retq
nop
// File: Infinidat[P]slimfastq/qlts.cpp
// Function: QltSave::save_3(unsigned char const*, unsigned long)
void QltSave::save_3(const UCHAR* buf, size_t size) {
    UINT32 last = 0;
    UINT32 delta = 5;
    UCHAR q1 = 0, q2 = 0;
    UINT32 di = 0;

    for (const UCHAR* p = buf ; p < buf + size; p++) {
        UCHAR b = UCHAR(*p-'!');

        PREFETCH(ranger + last);
        likely_if(b < LAST_QLT)
            ranger[last].put(&rcoder, b);
        else {
            // croak("This qlt rate makes no sence: '%c' (record %d, pos %d)", *p, g_record_count, p-buf);
            ranger[last].put(&rcoder, LAST_QLT);
            exranger.put(&rcoder, b);
            m_last.extra_hi_qlt ++ ;
        }

        if (++ di & 1) {
            last = calc_last_delta(delta, b, q1, q2);
            q2 = b;
        }
        else {
            last = calc_last_delta(delta, b, q2, q1);
            q1 = b;
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x2c(%rsp)
movl $0x5, 0x28(%rsp)
movb $0x0, 0x27(%rsp)
movb $0x0, 0x26(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x38(%rsp), %rcx
addq 0x30(%rsp), %rcx
cmpq %rcx, %rax
jae 0x96b0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl (%rcx), %ecx
subl $0x21, %ecx
movb %cl, 0x17(%rsp)
movq (%rax), %rax
movl 0x2c(%rsp), %ecx
imulq $0xc7, %rcx, %rcx
addq %rcx, %rax
prefetcht0 (%rax)
movzbl 0x17(%rsp), %eax
cmpl $0x3f, %eax
jge 0x95dc
movq 0x8(%rsp), %rsi
movq (%rsi), %rdi
movl 0x2c(%rsp), %eax
imulq $0xc7, %rax, %rax
addq %rax, %rdi
addq $0x310, %rsi            # imm = 0x310
movzbl 0x17(%rsp), %edx
callq 0x9d60
jmp 0x9634
movq 0x8(%rsp), %rsi
movq (%rsi), %rdi
movl 0x2c(%rsp), %eax
imulq $0xc7, %rax, %rax
addq %rax, %rdi
addq $0x310, %rsi            # imm = 0x310
movl $0x3f, %edx
callq 0x9d60
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x310, %rsi            # imm = 0x310
movzbl 0x17(%rsp), %edx
callq 0x2c20
movq 0x8(%rsp), %rax
movl 0x348(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x348(%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
andl $0x1, %eax
cmpl $0x0, %eax
je 0x9672
movb 0x17(%rsp), %cl
movb 0x27(%rsp), %al
leaq 0x28(%rsp), %rdi
movzbl %cl, %esi
movzbl %al, %edx
movzbl 0x26(%rsp), %ecx
callq 0x9ee0
movl %eax, 0x2c(%rsp)
movb 0x17(%rsp), %al
movb %al, 0x26(%rsp)
jmp 0x969b
movb 0x17(%rsp), %cl
movb 0x26(%rsp), %al
leaq 0x28(%rsp), %rdi
movzbl %cl, %esi
movzbl %al, %edx
movzbl 0x27(%rsp), %ecx
callq 0x9ee0
movl %eax, 0x2c(%rsp)
movb 0x17(%rsp), %al
movb %al, 0x27(%rsp)
jmp 0x969d
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x9569
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Infinidat[P]slimfastq/qlts.cpp
// Function: QltLoad::QltLoad()
QltLoad::QltLoad() {
    filer = new FilerLoad("qlt", &m_valid);
    ranger = new Log64Ranger[ranger_cnt()];

    rcoder.init(filer);
    // range_init();
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x9ce0
movl $0x4040, %edi           # imm = 0x4040
callq 0x2280
movq %rax, 0x38(%rsp)
jmp 0x96e9
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rdx
addq $0x338, %rdx            # imm = 0x338
leaq 0x7bc7(%rip), %rsi      # 0x112c8
callq 0x71e0
jmp 0x9708
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x340(%rdi)
callq 0x8fa0
movq %rax, %rcx
movq %rcx, 0x18(%rsp)
movl $0xc7, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
movq %rdi, 0x20(%rsp)
callq 0x2040
movq %rax, 0x28(%rsp)
jmp 0x974d
movq 0x18(%rsp), %rax
cmpq $0x0, %rax
je 0x97a2
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
imulq $0xc7, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x9d20
jmp 0x9789
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
addq $0xc7, %rax
cmpq %rcx, %rax
movq %rax, 0x10(%rsp)
jne 0x9779
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq %rax, %rdi
addq $0x310, %rdi            # imm = 0x310
movq 0x340(%rax), %rsi
callq 0x2db0
jmp 0x97c7
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x9818
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x4040, %esi           # imm = 0x4040
callq 0x2290
jmp 0x9818
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x2430
movq 0x30(%rsp), %rdi
callq 0x9d40
movq 0x48(%rsp), %rdi
callq 0x23f0
nopl (%rax)
// File: Infinidat[P]slimfastq/qlts.cpp
// Function: QltLoad::is_valid()
bool QltLoad::is_valid() {
    return
        m_valid and
        filer and
        filer->is_valid();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
xorl %eax, %eax
testb $0x1, 0x338(%rcx)
movb %al, 0xf(%rsp)
je 0x9909
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x340(%rcx)
movb %al, 0xf(%rsp)
je 0x9909
movq (%rsp), %rax
movq 0x340(%rax), %rdi
callq 0x7550
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Infinidat[P]slimfastq/qlts.cpp
// Function: QltLoad::load_1(unsigned char*, unsigned long)
UINT32 QltLoad::load_1(UCHAR* buf, const size_t size) {

    UINT32 last = 0 ;

    for (UCHAR* p = buf; p < buf + size ; p++) {
        UCHAR b = ranger[last].get(&rcoder);

        rarely_if(b == LAST_QLT)
            b = exranger.get(&rcoder);

        *p = UCHAR('!' + b);

        last = calc_last_1(last, b);
    }
    buf[size] = '\n';
    return m_valid ? size : 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
addq 0x30(%rsp), %rcx
cmpq %rcx, %rax
jae 0x99e9
movq 0x10(%rsp), %rsi
movq (%rsi), %rdi
movl 0x2c(%rsp), %eax
imulq $0xc7, %rax, %rax
addq %rax, %rdi
addq $0x310, %rsi            # imm = 0x310
callq 0x9fc0
movb %al, 0x1f(%rsp)
movzbl 0x1f(%rsp), %eax
cmpl $0x3f, %eax
jne 0x99b3
movq 0x10(%rsp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x310, %rsi            # imm = 0x310
callq 0x2e40
movb %al, 0x1f(%rsp)
movzbl 0x1f(%rsp), %eax
addl $0x21, %eax
movb %al, %cl
movq 0x20(%rsp), %rax
movb %cl, (%rax)
movl 0x2c(%rsp), %edi
movzbl 0x1f(%rsp), %esi
callq 0x9ea0
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x994f
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rdx
movb $0xa, (%rcx,%rdx)
testb $0x1, 0x338(%rax)
je 0x9a11
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x9a1a
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x9a1a
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Infinidat[P]slimfastq/qlts.cpp
// Function: QltLoad::load_2(unsigned char*, unsigned long)
UINT32 QltLoad::load_2(UCHAR* buf, const size_t size) {

    UINT32 last = 0 ;
    for (UCHAR* p = buf; p < buf + size ; p++) {
        PREFETCH(ranger + last);
        UCHAR b = ranger[last].get(&rcoder);

        rarely_if(b == LAST_QLT)
            b = exranger.get(&rcoder);

        *p = UCHAR('!' + b);

        last = calc_last_2(last, b);
    }
    buf[size] = '\n';
    return m_valid ? size : 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
addq 0x30(%rsp), %rcx
cmpq %rcx, %rax
jae 0x9b0d
movq 0x10(%rsp), %rsi
movq (%rsi), %rax
movl 0x2c(%rsp), %ecx
imulq $0xc7, %rcx, %rcx
addq %rcx, %rax
prefetcht0 (%rax)
movq (%rsi), %rdi
movl 0x2c(%rsp), %eax
imulq $0xc7, %rax, %rax
addq %rax, %rdi
addq $0x310, %rsi            # imm = 0x310
callq 0x9fc0
movb %al, 0x1f(%rsp)
movzbl 0x1f(%rsp), %eax
cmpl $0x3f, %eax
jne 0x9ad7
movq 0x10(%rsp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x310, %rsi            # imm = 0x310
callq 0x2e40
movb %al, 0x1f(%rsp)
movzbl 0x1f(%rsp), %eax
addl $0x21, %eax
movb %al, %cl
movq 0x20(%rsp), %rax
movb %cl, (%rax)
movl 0x2c(%rsp), %edi
movzbl 0x1f(%rsp), %esi
callq 0x9ec0
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x9a5f
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rdx
movb $0xa, (%rcx,%rdx)
testb $0x1, 0x338(%rax)
je 0x9b35
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x9b3e
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x9b3e
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: Infinidat[P]slimfastq/qlts.cpp
// Function: QltLoad::load_3(unsigned char*, unsigned long)
UINT32 QltLoad::load_3(UCHAR* buf, const size_t size) {

    UINT32 last = 0 ;
    UINT32 delta = 5;
    UCHAR  q1 = 0, q2 = 0;
    UINT32 di = 0;

    for (UCHAR* p = buf; p < buf + size ; p++) {
        PREFETCH(ranger + last);
        UCHAR b = ranger[last].get(&rcoder);

        rarely_if(b == LAST_QLT)
            // croak("extra high qlt. Record %d, pos %d", g_record_count, p-buf);
            b = exranger.get(&rcoder);
        // likely_if(b < LAST_QLT)
        //     *p = UCHAR('!' + b);
        // else {
        //     b = exranger.get(&rcoder);
        //     *p = UCHAR('!' + b);
        // }
        *p = UCHAR('!' + b);

        if (++di & 1) {
            last = calc_last_delta(delta, b, q1, q2);
            q2 = b;
        }
        else {
            last = calc_last_delta(delta, b, q2, q1);
            q1 = b;
        }
    }
    buf[size] = '\n';
    // buf[size+1] = 0;
    // printf("%llu: %s", g_record_count, buf);
    return m_valid ? size : 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x2c(%rsp)
movl $0x5, 0x28(%rsp)
movb $0x0, 0x27(%rsp)
movb $0x0, 0x26(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x38(%rsp), %rcx
addq 0x30(%rsp), %rcx
cmpq %rcx, %rax
jae 0x9c9e
movq 0x8(%rsp), %rsi
movq (%rsi), %rax
movl 0x2c(%rsp), %ecx
imulq $0xc7, %rcx, %rcx
addq %rcx, %rax
prefetcht0 (%rax)
movq (%rsi), %rdi
movl 0x2c(%rsp), %eax
imulq $0xc7, %rax, %rax
addq %rax, %rdi
addq $0x310, %rsi            # imm = 0x310
callq 0x9fc0
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x3f, %eax
jne 0x9c11
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x310, %rsi            # imm = 0x310
callq 0x2e40
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
addl $0x21, %eax
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
andl $0x1, %eax
cmpl $0x0, %eax
je 0x9c60
movb 0x17(%rsp), %cl
movb 0x27(%rsp), %al
leaq 0x28(%rsp), %rdi
movzbl %cl, %esi
movzbl %al, %edx
movzbl 0x26(%rsp), %ecx
callq 0x9ee0
movl %eax, 0x2c(%rsp)
movb 0x17(%rsp), %al
movb %al, 0x26(%rsp)
jmp 0x9c89
movb 0x17(%rsp), %cl
movb 0x26(%rsp), %al
leaq 0x28(%rsp), %rdi
movzbl %cl, %esi
movzbl %al, %edx
movzbl 0x27(%rsp), %ecx
callq 0x9ee0
movl %eax, 0x2c(%rsp)
movb 0x17(%rsp), %al
movb %al, 0x27(%rsp)
jmp 0x9c8b
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x9b99
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rdx
movb $0xa, (%rcx,%rdx)
testb $0x1, 0x338(%rax)
je 0x9cc5
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
jmp 0x9ccd
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x9ccd
movq (%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Infinidat[P]slimfastq/./qlts.hpp
// Function: QltBase::calc_last_delta(unsigned int&, unsigned char, unsigned char, unsigned char)
inline static UINT32 calc_last_delta(UINT32 &delta, UCHAR q, UCHAR q1, UCHAR q2) {

        // This brilliant code could only be of James Bonfield
        if (q1>q)
            delta += (q1-q);

        return
            ( q
              | ((q1 < q2        ? q2         : q1) <<  6)
              | ((q1 == q2                        ) << 12)
              | ((7 > (delta>>3) ? (delta>>3) : 7 ) << 13)
              ) & RANGER_MASK_2 ;
    }

// Assembly:
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rsp)
movb %dl, -0x9(%rsp)
movb %cl, -0xa(%rsp)
movb %al, -0xb(%rsp)
movzbl -0xa(%rsp), %eax
movzbl -0x9(%rsp), %ecx
cmpl %ecx, %eax
jle 0x9f1b
movzbl -0xa(%rsp), %ecx
movzbl -0x9(%rsp), %eax
subl %eax, %ecx
movq -0x8(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movzbl -0x9(%rsp), %eax
movl %eax, -0x10(%rsp)
movzbl -0xa(%rsp), %eax
movzbl -0xb(%rsp), %ecx
cmpl %ecx, %eax
jge 0x9f3c
movb -0xb(%rsp), %al
movb %al, -0x11(%rsp)
jmp 0x9f44
movb -0xa(%rsp), %al
movb %al, -0x11(%rsp)
movl -0x10(%rsp), %eax
movb -0x11(%rsp), %cl
movzbl %cl, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movzbl -0xa(%rsp), %ecx
movzbl -0xb(%rsp), %edx
cmpl %edx, %ecx
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll $0xc, %ecx
orl %ecx, %eax
movl %eax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %ecx
shrl $0x3, %ecx
movl $0x7, %eax
cmpl %ecx, %eax
jbe 0x9f95
movq -0x8(%rsp), %rax
movl (%rax), %eax
shrl $0x3, %eax
movl %eax, -0x1c(%rsp)
jmp 0x9fa0
movl $0x7, %eax
movl %eax, -0x1c(%rsp)
jmp 0x9fa0
movl -0x18(%rsp), %eax
movl -0x1c(%rsp), %ecx
shll $0xd, %ecx
orl %ecx, %eax
andl $0xffff, %eax           # imm = 0xFFFF
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Infinidat[P]slimfastq/./log64_ranger.hpp
// Function: Log64Ranger::update_freq(int)
inline UCHAR update_freq(int i) {

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

            normalize();
        }

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

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x14(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
cmpl $0xffba, %eax           # imm = 0xFFBA
jle 0xa160
xorl %eax, %eax
cmpl $0x0, 0x14(%rsp)
movb %al, 0x7(%rsp)
jne 0xa132
movq 0x8(%rsp), %rcx
movslq 0x14(%rsp), %rax
movzwl (%rcx,%rax,2), %eax
addl $0x14, %eax
cmpl 0x82(%rcx), %eax
seta %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xa13c
jmp 0xa156
movq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
movb 0x87(%rax,%rcx), %al
movb %al, 0x27(%rsp)
jmp 0xa215
movq 0x8(%rsp), %rdi
callq 0xa220
movq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
movzwl (%rax,%rcx,2), %edx
addl $0x6, %edx
movw %dx, (%rax,%rcx,2)
movl 0x82(%rax), %ecx
addl $0x6, %ecx
movl %ecx, 0x82(%rax)
movb $0x1, %al
cmpl $0x0, 0x14(%rsp)
movb %al, 0x6(%rsp)
je 0xa1da
movq 0x8(%rsp), %rcx
movb 0x86(%rcx), %al
addb $0x1, %al
movb %al, 0x86(%rcx)
movzbl %al, %ecx
andl $0xf, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0x6(%rsp)
jne 0xa1da
movq 0x8(%rsp), %rcx
movslq 0x14(%rsp), %rax
movzwl (%rcx,%rax,2), %eax
movl 0x14(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
setle %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0xa1e4
jmp 0xa1fb
movq 0x8(%rsp), %rax
movslq 0x14(%rsp), %rcx
movb 0x87(%rax,%rcx), %al
movb %al, 0x5(%rsp)
jmp 0xa20d
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xa2a0
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nop
// File: Infinidat[P]slimfastq/./log64_ranger.hpp
// Function: Log64Ranger::down_level(int)
inline UCHAR down_level(int i) {

        UCHAR c = syms[i  ];
        syms[i] = syms[i-1];
        syms[i-1] = c;

        UINT16 f = freq[i];
        freq[i]  = freq[i-1];
        freq[i-1] = f;

        return c;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movb 0x87(%rax,%rcx), %cl
movb %cl, -0xd(%rsp)
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb 0x87(%rax,%rcx), %dl
movslq -0xc(%rsp), %rcx
movb %dl, 0x87(%rax,%rcx)
movb -0xd(%rsp), %dl
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, 0x87(%rax,%rcx)
movslq -0xc(%rsp), %rcx
movw (%rax,%rcx,2), %cx
movw %cx, -0x10(%rsp)
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %dx
movslq -0xc(%rsp), %rcx
movw %dx, (%rax,%rcx,2)
movw -0x10(%rsp), %dx
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movw %dx, (%rax,%rcx,2)
movb -0xd(%rsp), %al
retq
nopl (%rax)
// File: Infinidat[P]slimfastq/recs.cpp
// Function: RecSave::RecSave()
RecSave::RecSave() {

    m_valid = true;

    BZERO(m_last);
    BZERO(stats);
    // range_init();

    filer = new FilerSave("rec");
    assert(filer);
    rcoder.init(filer);

    x_file = new XFileSave("rec.x");

    smap[0].len = smap[1].len = 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xc410
movq 0x10(%rsp), %rax
movb $0x1, 0xc7d2c(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0xc7d08(%rax)
movups %xmm0, 0xc7d18(%rax)
movl $0x0, 0xc7d28(%rax)
movl $0x4040, %edi           # imm = 0x4040
callq 0x2280
movq %rax, 0x18(%rsp)
jmp 0xa380
movq 0x18(%rsp), %rdi
leaq 0x6f45(%rip), %rsi      # 0x112d1
callq 0x6d40
jmp 0xa393
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0xc8668(%rax)
cmpq $0x0, 0xc8668(%rax)
je 0xa3b0
jmp 0xa404
leaq 0x5c76(%rip), %rdi      # 0x1002d
leaq 0x6cae(%rip), %rsi      # 0x1106c
movl $0x2b, %edx
leaq 0x6cab(%rip), %rcx      # 0x11075
callq 0x21b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xa486
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x4040, %esi           # imm = 0x4040
callq 0x2290
jmp 0xa486
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0xc7ce0, %rdi          # imm = 0xC7CE0
movq 0xc8668(%rax), %rsi
callq 0x2bf0
jmp 0xa421
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x2280
movq %rax, 0x8(%rsp)
jmp 0xa432
movq 0x8(%rsp), %rdi
leaq 0x6c4a(%rip), %rsi      # 0x11088
callq 0xf6c0
jmp 0xa445
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0xc8670(%rax)
movb $0x0, 0xc81c5(%rax)
movb $0x0, 0xc7f79(%rax)
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
movq 0x10(%rsp), %rdi
callq 0xc480
movq 0x28(%rsp), %rdi
callq 0x23f0
nopw (%rax,%rax)
// File: Infinidat[P]slimfastq/recs.cpp
// Function: RecSave::~RecSave()
RecSave::~RecSave() {
    rcoder.done();
    if (not conf.quiet) {
    }

    DELETE(filer);
    DELETE(x_file);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0xc7ce0, %rdi          # imm = 0xC7CE0
callq 0x2d40
jmp 0xa4c1
leaq 0xdf18(%rip), %rax      # 0x183e0
testb $0x1, 0xe(%rax)
jne 0xa4d0
jmp 0xa4d0
jmp 0xa4d2
movq 0x18(%rsp), %rax
cmpq $0x0, 0xc8668(%rax)
je 0xa513
movq 0x18(%rsp), %rax
movq 0xc8668(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xa511
movq 0x10(%rsp), %rdi
callq 0x6ed0
movq 0x10(%rsp), %rdi
movl $0x4040, %esi           # imm = 0x4040
callq 0x2290
jmp 0xa513
movq 0x18(%rsp), %rax
movq $0x0, 0xc8668(%rax)
jmp 0xa525
jmp 0xa527
movq 0x18(%rsp), %rax
cmpq $0x0, 0xc8670(%rax)
je 0xa568
movq 0x18(%rsp), %rax
movq 0xc8670(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xa566
movq 0x8(%rsp), %rdi
callq 0xf700
movq 0x8(%rsp), %rdi
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
jmp 0xa568
movq 0x18(%rsp), %rax
movq $0x0, 0xc8670(%rax)
jmp 0xa57a
movq 0x18(%rsp), %rdi
callq 0xc480
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x2d30
nopw %cs:(%rax,%rax)
// File: Infinidat[P]slimfastq/recs.cpp
// Function: sncpy(unsigned char*, unsigned char const*, int)
UCHAR* sncpy(UCHAR* target, const UCHAR* source, int n) {
    int  i;
    for (i = 0 ; i < n and source[i]; i++)
        target[i] = source[i];
    target[i] = 0;
    return target + i;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %ecx
xorl %eax, %eax
cmpl -0x14(%rsp), %ecx
movb %al, -0x19(%rsp)
jge 0xa5db
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
setne %al
movb %al, -0x19(%rsp)
movb -0x19(%rsp), %al
testb $0x1, %al
jne 0xa5e5
jmp 0xa60c
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0xa5b6
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
addq %rcx, %rax
retq
nopl (%rax,%rax)
// File: Infinidat[P]slimfastq/recs.cpp
// Function: RecSave::save_first_line(unsigned char const*, unsigned char const*)
void RecSave::save_first_line(const UCHAR* buf, const UCHAR* end) {
    UCHAR first[MAX_LLINE];
    sncpy(first, buf, end-buf);
    conf.set_info("rec.first", (const char*)first);
    // conf.save_info();

    m_last.initilized = true;
}

// Assembly:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x1b0(%rsp)
movq %rsi, 0x1a8(%rsp)
movq %rdx, 0x1a0(%rsp)
movq 0x1b0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x1a8(%rsp), %rsi
movq 0x1a0(%rsp), %rax
movq 0x1a8(%rsp), %rcx
subq %rcx, %rax
movl %eax, %edx
callq 0xa5a0
leaq 0x10(%rsp), %rdx
leaq 0xdd51(%rip), %rdi      # 0x183e0
leaq 0x69f8(%rip), %rsi      # 0x1108e
callq 0x3cd0
movq 0x8(%rsp), %rax
movb $0x1, 0xc7d08(%rax)
addq $0x1b8, %rsp            # imm = 0x1B8
retq
nop
// File: Infinidat[P]slimfastq/recs.cpp
// Function: RecLoad::RecLoad()
RecLoad::RecLoad() {
    m_valid = true;
    // range_init();

    filer = new FilerLoad("rec", &m_valid);
    assert(filer);
    rcoder.init(filer);

    BZERO(m_last);

    x_file = new XFileLoad("rec.x");
    m_last.index = x_file->get();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xc410
movq 0x10(%rsp), %rax
movb $0x1, 0xc7d2c(%rax)
movl $0x4040, %edi           # imm = 0x4040
callq 0x2280
movq %rax, 0x18(%rsp)
jmp 0xa855
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
addq $0xc7d2c, %rdx          # imm = 0xC7D2C
leaq 0x6a64(%rip), %rsi      # 0x112d1
callq 0x71e0
jmp 0xa874
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0xc8668(%rax)
cmpq $0x0, 0xc8668(%rax)
je 0xa891
jmp 0xa8e5
leaq 0x5795(%rip), %rdi      # 0x1002d
leaq 0x67cd(%rip), %rsi      # 0x1106c
movl $0x62, %edx
leaq 0x67ed(%rip), %rcx      # 0x11098
callq 0x21b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0xa98a
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x4040, %esi           # imm = 0x4040
callq 0x2290
jmp 0xa98a
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0xc7ce0, %rdi          # imm = 0xC7CE0
movq 0xc8668(%rax), %rsi
callq 0x2db0
jmp 0xa902
movq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xc7d08(%rax)
movl $0x2db0, %edi           # imm = 0x2DB0
callq 0x2280
movq %rax, 0x8(%rsp)
jmp 0xa922
movq 0x8(%rsp), %rdi
leaq 0x675a(%rip), %rsi      # 0x11088
callq 0xf800
jmp 0xa935
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0xc8670(%rax)
movq 0xc8670(%rax), %rdi
callq 0xfb60
movq %rax, (%rsp)
jmp 0xa958
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0xc7d10(%rax)
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x2db0, %esi           # imm = 0x2DB0
callq 0x2290
movq 0x10(%rsp), %rdi
callq 0xc480
movq 0x28(%rsp), %rdi
callq 0x23f0
nop
// File: Infinidat[P]slimfastq/recs.cpp
// Function: RecLoad::load_first_line(unsigned char*)
size_t RecLoad::load_first_line(UCHAR* buf) {

    m_last.initilized = true;

    const char *first = conf.get_info("rec.first");
    strcpy((char*)buf, first);
    return strlen(first);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movb $0x1, 0xc7d08(%rax)
leaq 0xd98f(%rip), %rdi      # 0x183e0
leaq 0x6636(%rip), %rsi      # 0x1108e
callq 0x3590
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x2260
movq (%rsp), %rdi
callq 0x2130
addq $0x18, %rsp
retq
nopl (%rax)
// File: Infinidat[P]slimfastq/recs.cpp
// Function: RecLoad::get_str(unsigned char, unsigned char*)
UCHAR* RecLoad::get_str(UCHAR i, UCHAR* p) {
    UINT32 len = ranger[i].num.get_u(&rcoder);
    for (UINT32 j = 0; j < len; j++)
        p[j] = ranger[i].str.get(&rcoder);
    return p + len;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, (%rsp)
movzbl 0x1f(%rsp), %eax
imulq $0x3070, %rax, %rax     # imm = 0x3070
movq %rsi, %rdi
addq %rax, %rdi
addq $0x60e, %rdi            # imm = 0x60E
addq $0xc7ce0, %rsi          # imm = 0xC7CE0
callq 0xc6a0
movl %eax, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jae 0xab9d
movq (%rsp), %rsi
movzbl 0x1f(%rsp), %eax
imulq $0x3070, %rax, %rax     # imm = 0x3070
movq %rsi, %rdi
addq %rax, %rdi
addq $0x307, %rdi            # imm = 0x307
addq $0xc7ce0, %rsi          # imm = 0xC7CE0
callq 0x2e40
movb %al, %dl
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xab4f
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
addq %rcx, %rax
addq $0x28, %rsp
retq
nop
// File: Infinidat[P]slimfastq/recs.cpp
// Function: is_number(unsigned char const*, int, long long&)
static bool is_number(const UCHAR* p, int len, long long &num) {
    rarely_if (*p == '0')
        return false;
    num = 0;
    for (int i = 0 ; i < len; i ++)
        if (isdigit(p[i]))
            num = (num<<3) + (num<<1) + (p[i]) - '0';
        else
            return false;
    return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jne 0xc379
movb $0x0, 0x27(%rsp)
jmp 0xc403
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0xc3fe
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x2250
cmpl $0x0, %eax
je 0xc3e8
movq 0x8(%rsp), %rax
movq (%rax), %rcx
shlq $0x3, %rcx
movq 0x8(%rsp), %rax
movq (%rax), %rax
shlq %rax
addq %rax, %rcx
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rdx
movzbl (%rax,%rdx), %eax
addq %rax, %rcx
subq $0x30, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0xc3ef
movb $0x0, 0x27(%rsp)
jmp 0xc403
jmp 0xc3f1
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xc38d
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: Infinidat[P]slimfastq/./power_ranger.hpp
// Function: PowerRangerU::put_u(RCoder*, unsigned long long)
bool put_u(RCoder *rc, UINT64 num) {

    likely_if(num <= 0x7f) {
        p[0].put(rc, 0xff & num);
        return false;
    }
    likely_if (num < 0x7ffe) {
        p[0].put(rc, 0xff & (0x80 | (num>>8)));
        p[1].put(rc, 0xff & num);
        return false;
    }
    p[0].put(rc, 0xff);
    if (num < 1ULL<<32) {
        p[1].put(rc, 0xfe);
        for (int shift=0, i=2; shift < 32; shift+=8, i++)
            p[i].put(rc, 0xff & (num>>shift));
        return true;
    }
    {
        p[1].put(rc, 0xff);
        for (int shift=0, i=6; shift < 64; shift+=8, i++)
            p[i].put(rc, 0xff & (num>>shift));
        return true;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x7f, 0x18(%rsp)
ja 0xc50a
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
andq $0xff, %rax
movzbl %al, %edx
callq 0x2c20
movb $0x0, 0x37(%rsp)
jmp 0xc695
cmpq $0x7ffe, 0x18(%rsp)     # imm = 0x7FFE
jae 0xc568
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
shrq $0x8, %rax
orq $0x80, %rax
andq $0xff, %rax
movzbl %al, %edx
callq 0x2c20
movq (%rsp), %rdi
addq $0x307, %rdi            # imm = 0x307
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
andq $0xff, %rax
movzbl %al, %edx
callq 0x2c20
movb $0x0, 0x37(%rsp)
jmp 0xc695
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0xff, %edx
callq 0x2c20
movabsq $0x100000000, %rax      # imm = 0x100000000
cmpq %rax, 0x18(%rsp)
jae 0xc615
movq (%rsp), %rdi
addq $0x307, %rdi            # imm = 0x307
movq 0x20(%rsp), %rsi
movl $0xfe, %edx
callq 0x2c20
movl $0x0, 0x14(%rsp)
movl $0x2, 0x10(%rsp)
cmpl $0x20, 0x14(%rsp)
jge 0xc60b
movq (%rsp), %rdi
movslq 0x10(%rsp), %rax
imulq $0x307, %rax, %rax      # imm = 0x307
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
shrq %cl, %rax
andq $0xff, %rax
movzbl %al, %edx
callq 0x2c20
movl 0x14(%rsp), %eax
addl $0x8, %eax
movl %eax, 0x14(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xc5ba
movb $0x1, 0x37(%rsp)
jmp 0xc695
movq (%rsp), %rdi
addq $0x307, %rdi            # imm = 0x307
movq 0x20(%rsp), %rsi
movl $0xff, %edx
callq 0x2c20
movl $0x0, 0xc(%rsp)
movl $0x6, 0x8(%rsp)
cmpl $0x40, 0xc(%rsp)
jge 0xc690
movq (%rsp), %rdi
movslq 0x8(%rsp), %rax
imulq $0x307, %rax, %rax      # imm = 0x307
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
shrq %cl, %rax
andq $0xff, %rax
movzbl %al, %edx
callq 0x2c20
movl 0xc(%rsp), %eax
addl $0x8, %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xc63f
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
// File: Infinidat[P]slimfastq/./power_ranger.hpp
// Function: PowerRangerU::get_u(RCoder*)
UINT64 get_u(RCoder *rc) {

    UINT64 num = p[0].get(rc);
    rarely_if(num > 0x7f) {

        num <<= 8;
        num  |= p[1].get(rc);
        likely_if(num < 0xfffe)
            num &= 0x7fff;

        else likely_if (num == 0xfffe) {
            num = 0;
            for (int shift=0, i = 2; shift < 32; shift+=8, i++) {
                UINT64 c = p[i].get(rc);
                num  |= (c<<shift);
            }
        }
        else {
            num = 0;
            for (int shift=0, i=6; shift < 64; shift+=8, i++) {
                UINT64 c = p[i].get(rc);
                num  |= (c<<shift);
            }
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0x2e40
movzwl %ax, %eax
movq %rax, 0x30(%rsp)
cmpq $0x7f, 0x30(%rsp)
jbe 0xc822
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
shlq $0x8, %rax
movq %rax, 0x30(%rsp)
addq $0x307, %rdi            # imm = 0x307
movq 0x38(%rsp), %rsi
callq 0x2e40
movzwl %ax, %eax
orq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0xfffe, 0x30(%rsp)     # imm = 0xFFFE
jae 0xc727
movq 0x30(%rsp), %rax
andq $0x7fff, %rax           # imm = 0x7FFF
movq %rax, 0x30(%rsp)
jmp 0xc820
cmpq $0xfffe, 0x30(%rsp)     # imm = 0xFFFE
jne 0xc7a8
movq $0x0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl $0x2, 0x28(%rsp)
cmpl $0x20, 0x2c(%rsp)
jge 0xc7a6
movq 0x8(%rsp), %rdi
movslq 0x28(%rsp), %rax
imulq $0x307, %rax, %rax      # imm = 0x307
addq %rax, %rdi
movq 0x38(%rsp), %rsi
callq 0x2e40
movzwl %ax, %eax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x2c(%rsp), %ecx
shlq %cl, %rax
orq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x8, %eax
movl %eax, 0x2c(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0xc74b
jmp 0xc81e
movq $0x0, 0x30(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x6, 0x18(%rsp)
cmpl $0x40, 0x1c(%rsp)
jge 0xc81c
movq 0x8(%rsp), %rdi
movslq 0x18(%rsp), %rax
imulq $0x307, %rax, %rax      # imm = 0x307
addq %rax, %rdi
movq 0x38(%rsp), %rsi
callq 0x2e40
movzwl %ax, %eax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x1c(%rsp), %ecx
shlq %cl, %rax
orq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x1c(%rsp), %eax
addl $0x8, %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xc7c1
jmp 0xc81e
jmp 0xc820
jmp 0xc822
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)