LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: readmapping[P]alfalfa/src/main.cpp
// Function: readBatch(int, std::vector<read_t, std::allocator<read_t>>&)
int readBatch(int bpCount, vector<read_t> & reads){
    int curCount = 0;
    bool hasRead = true;
    while(curCount < bpCount && hasRead){
        read_t read;
        hasRead = queryReader->nextRead(read.qname, read.sequence, read.qual);
        if(hasRead){
            curCount += read.sequence.length();
            reads.push_back(read);
        }
    }
    return reads.size();
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movl %edi, 0x104(%rsp)
movq %rsi, 0xf8(%rsp)
movl $0x0, 0xf4(%rsp)
movb $0x1, 0xf3(%rsp)
movl 0xf4(%rsp), %ecx
xorl %eax, %eax
cmpl 0x104(%rsp), %ecx
movb %al, 0x13(%rsp)
jge 0x8d6a
movb 0xf3(%rsp), %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x8d77
jmp 0x8e1a
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xb970
movq 0x8(%rsp), %rsi
movq 0x8e73e(%rip), %rdi     # 0x974d0
leaq 0x40(%rsp), %rdx
leaq 0x60(%rsp), %rcx
callq 0x30710
movb %al, 0x12(%rsp)
jmp 0x8da7
movb 0x12(%rsp), %al
andb $0x1, %al
movb %al, 0xf3(%rsp)
testb $0x1, 0xf3(%rsp)
je 0x8e0b
leaq 0x40(%rsp), %rdi
callq 0x8630
movq %rax, %rcx
movl 0xf4(%rsp), %eax
addl %ecx, %eax
movl %eax, 0xf4(%rsp)
movq 0xf8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xbc10
jmp 0x8def
jmp 0x8e0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xbc90
jmp 0x8e2f
leaq 0x20(%rsp), %rdi
callq 0xbc90
jmp 0x8d49
movq 0xf8(%rsp), %rdi
callq 0xbdd0
addq $0x108, %rsp            # imm = 0x108
retq
movq 0x18(%rsp), %rdi
callq 0x8730
nopl (%rax)
// File: readmapping[P]alfalfa/src/main.cpp
// Function: map_unpaired(void*, int, int)
static void map_unpaired(void * unpairedData, int i, int threadid)
{
    unpaired_data * data = (unpaired_data*) unpairedData;
    read_t & read = data->reads->at(i);
    if (read.qname.length() > 2 && read.qname[read.qname.length() - 2] == '/')
        read.qname.erase(read.qname.length() - 2);
    read.init(data->opt->nucleotidesOnly);
    if (data->opt->alnOptions.print >= 3) cerr << "match " << read.qname << " with length " << read.sequence.length() << endl;
    if (data->opt->alnOptions.print >= 2) cerr << "#READ" << endl;
#ifndef NDEBUG
    if (data->opt->alnOptions.debugFile != NULL && data->opt->query_threads == 1) {
        fprintf(data->opt->alnOptions.debugFile, ">%s\n", read.qname.c_str());
        fprintf(data->opt->alnOptions.debugFile, "%lu\n", read.sequence.size());
    }
#endif
    unpairedMatch(*data->ssa, read, data->opt->alnOptions);
    read.postprocess(*data->ssa, data->opt->alnOptions, false);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xded0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8630
cmpq $0x2, %rax
jbe 0x941c
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8630
movq 0x10(%rsp), %rdi
movq %rax, %rsi
subq $0x2, %rsi
callq 0x8830
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x941c
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8630
movq 0x8(%rsp), %rdi
movq %rax, %rsi
subq $0x2, %rsi
movq $-0x1, %rdx
callq 0x80f0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movb 0xf8(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xdf10
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpl $0x3, 0x178(%rax)
jl 0x94a6
movq 0x8db9f(%rip), %rdi     # 0x96ff0
leaq 0x6ff97(%rip), %rsi     # 0x793ef
callq 0x8360
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x8330
movq %rax, %rdi
leaq 0x6ff82(%rip), %rsi     # 0x793f6
callq 0x8360
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x8630
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x8100
movq %rax, %rdi
movq 0x8db0f(%rip), %rsi     # 0x96fb0
callq 0x83b0
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpl $0x2, 0x178(%rax)
jl 0x94d9
movq 0x8db32(%rip), %rdi     # 0x96ff0
leaq 0x6ff3f(%rip), %rsi     # 0x79404
callq 0x8360
movq %rax, %rdi
movq 0x8dadc(%rip), %rsi     # 0x96fb0
callq 0x83b0
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
addq $0x100, %rdx            # imm = 0x100
callq 0x42e50
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
addq $0x100, %rdx            # imm = 0x100
xorl %ecx, %ecx
callq 0x3c830
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/main.cpp
// Function: readBatchPaired(int, std::vector<read_t, std::allocator<read_t>>&, std::vector<read_t, std::allocator<read_t>>&)
int readBatchPaired(int bpCount, vector<read_t> & mates1, vector<read_t> & mates2){
    int curCount = 0;
    bool hasRead = true;
    while(curCount < bpCount && hasRead){
        read_t mate1;
        read_t mate2;
        hasRead = mate1Reader->nextRead(mate1.qname, mate1.sequence, mate1.qual);
        hasRead = mate2Reader->nextRead(mate2.qname, mate2.sequence, mate2.qual);
        if(hasRead){
            curCount += mate1.sequence.length();
            mates1.push_back(mate1);
            mates2.push_back(mate2);
        }
    }
    return mates1.size();
}

// Assembly:
subq $0x1d8, %rsp            # imm = 0x1D8
movl %edi, 0x1d4(%rsp)
movq %rsi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movl $0x0, 0x1bc(%rsp)
movb $0x1, 0x1bb(%rsp)
movl 0x1bc(%rsp), %ecx
xorl %eax, %eax
cmpl 0x1d4(%rsp), %ecx
movb %al, 0xb(%rsp)
jge 0x9582
movb 0x1bb(%rsp), %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x958f
jmp 0x96b9
leaq 0xe8(%rsp), %rdi
callq 0xb970
leaq 0x18(%rsp), %rdi
callq 0xb970
jmp 0x95a8
movq 0x8df39(%rip), %rdi     # 0x974e8
leaq 0x108(%rsp), %rdx
leaq 0x128(%rsp), %rcx
leaq 0xe8(%rsp), %rsi
callq 0x30710
movb %al, 0xa(%rsp)
jmp 0x95d2
movb 0xa(%rsp), %al
andb $0x1, %al
movb %al, 0x1bb(%rsp)
movq 0x8df0a(%rip), %rdi     # 0x974f0
leaq 0x38(%rsp), %rdx
leaq 0x58(%rsp), %rcx
leaq 0x18(%rsp), %rsi
callq 0x30710
movb %al, 0x9(%rsp)
jmp 0x9600
movb 0x9(%rsp), %al
andb $0x1, %al
movb %al, 0x1bb(%rsp)
testb $0x1, 0x1bb(%rsp)
je 0x968e
leaq 0x108(%rsp), %rdi
callq 0x8630
movq %rax, %rcx
movl 0x1bc(%rsp), %eax
addl %ecx, %eax
movl %eax, 0x1bc(%rsp)
movq 0x1c8(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0xbc10
jmp 0x964e
movq 0x1c0(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xbc10
jmp 0x9662
jmp 0x968e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0x96aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xbc90
jmp 0x96aa
leaq 0x18(%rsp), %rdi
callq 0xbc90
leaq 0xe8(%rsp), %rdi
callq 0xbc90
jmp 0x9561
leaq 0xe8(%rsp), %rdi
callq 0xbc90
jmp 0x96ce
movq 0x1c8(%rsp), %rdi
callq 0xbdd0
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x10(%rsp), %rdi
callq 0x8730
nopl (%rax,%rax)
// File: readmapping[P]alfalfa/src/mapper.h
// Function: read_t::~read_t()
~read_t() {
        if(readP != NULL){
            std::free(readP); readP = NULL;
            std::free(rcReadP); rcReadP = NULL;
        }
        for(size_t i=0; i < alignments.size(); i++){
            delete alignments[i];
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0xa0(%rax)
je 0xbcea
movq 0x10(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x8470
movq 0x10(%rsp), %rax
movq $0x0, 0xa0(%rax)
movq 0xa8(%rax), %rdi
callq 0x8470
movq 0x10(%rsp), %rax
movq $0x0, 0xa8(%rax)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0xb0, %rdi
callq 0xdac0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xbd67
movq 0x10(%rsp), %rdi
addq $0xb0, %rdi
movq 0x18(%rsp), %rsi
callq 0xdae0
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xbd55
movq (%rsp), %rdi
callq 0xdb00
movq (%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x8390
jmp 0xbd57
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xbcf3
movq 0x10(%rsp), %rdi
addq $0xb0, %rdi
callq 0xdb60
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
callq 0x8858
movq 0x10(%rsp), %rdi
addq $0x60, %rdi
callq 0x8858
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
callq 0x8858
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x8858
movq 0x10(%rsp), %rdi
callq 0x8858
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: readmapping[P]alfalfa/src/mapper.h
// Function: read_t::emptyAlingment[abi:cxx11](bool, bool, bool)
std::string emptyAlingment(bool paired, bool mateFailed, bool upstream){
        std::stringstream ss;
        int flag = 4;
        if(paired) flag += 1;
        if(mateFailed) flag += 8;
        if(paired && upstream) flag += 64;
        if(paired && !upstream) flag += 128;
        ss << qname << "\t" << flag << "\t*\t0\t0\t*\t*\t0\t0\t" << sequence << "\t" << qual << std::endl;
        return ss.str();
    }

// Assembly:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x38(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x40(%rsp)
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
andb $0x1, %dl
movb %dl, 0x1f7(%rsp)
andb $0x1, %cl
movb %cl, 0x1f6(%rsp)
andb $0x1, %al
movb %al, 0x1f5(%rsp)
movq 0x1f8(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x8260
movl $0x4, 0x64(%rsp)
testb $0x1, 0x1f7(%rsp)
je 0xbf28
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
testb $0x1, 0x1f6(%rsp)
je 0xbf3d
movl 0x64(%rsp), %eax
addl $0x8, %eax
movl %eax, 0x64(%rsp)
testb $0x1, 0x1f7(%rsp)
je 0xbf5c
testb $0x1, 0x1f5(%rsp)
je 0xbf5c
movl 0x64(%rsp), %eax
addl $0x40, %eax
movl %eax, 0x64(%rsp)
testb $0x1, 0x1f7(%rsp)
je 0xbf7d
testb $0x1, 0x1f5(%rsp)
jne 0xbf7d
movl 0x64(%rsp), %eax
addl $0x80, %eax
movl %eax, 0x64(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x8330
movq %rax, 0x30(%rsp)
jmp 0xbf93
movq 0x30(%rsp), %rdi
leaq 0x6dabe(%rip), %rsi     # 0x79a5d
callq 0x8360
movq %rax, 0x28(%rsp)
jmp 0xbfab
movq 0x28(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x8710
movq %rax, 0x20(%rsp)
jmp 0xbfc0
movq 0x20(%rsp), %rdi
leaq 0x6d488(%rip), %rsi     # 0x79454
callq 0x8360
movq %rax, 0x18(%rsp)
jmp 0xbfd8
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
addq $0x20, %rsi
callq 0x8330
movq %rax, 0x10(%rsp)
jmp 0xbff2
movq 0x10(%rsp), %rdi
leaq 0x6da5f(%rip), %rsi     # 0x79a5d
callq 0x8360
movq %rax, 0x8(%rsp)
jmp 0xc00a
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
addq $0x40, %rsi
callq 0x8330
movq %rax, (%rsp)
jmp 0xc023
movq (%rsp), %rdi
movq 0x8af82(%rip), %rsi     # 0x96fb0
callq 0x83b0
jmp 0xc035
movq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x8350
jmp 0xc046
leaq 0x68(%rsp), %rdi
callq 0x8290
movq 0x40(%rsp), %rax
addq $0x208, %rsp            # imm = 0x208
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x8290
movq 0x58(%rsp), %rdi
callq 0x8730
nop
// File: readmapping[P]alfalfa/src/performanceUtils.h
// Function: samCheckOptions_t::initOptions()
void initOptions(){
        subcommand = SUMMARY;
        outputFile = "";
        oracleSam = "";
        refString = "";
        paired = false;
        querySam = "";
        qtag = "NM";
        otag = "XE";
        numReads=0;
        print = false;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, (%rdi)
addq $0x8, %rdi
leaq 0x6cb8a(%rip), %rsi     # 0x79a5e
callq 0x8570
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
leaq 0x6cb75(%rip), %rsi     # 0x79a5e
callq 0x8570
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
leaq 0x6cb60(%rip), %rsi     # 0x79a5e
callq 0x8570
movq 0x8(%rsp), %rdi
movb $0x0, 0x68(%rdi)
addq $0x70, %rdi
leaq 0x6cb47(%rip), %rsi     # 0x79a5e
callq 0x8570
movq 0x8(%rsp), %rdi
addq $0xd8, %rdi
leaq 0x6c7de(%rip), %rsi     # 0x7970d
callq 0x8570
movq 0x8(%rsp), %rdi
addq $0xf8, %rdi
leaq 0x6c7c9(%rip), %rsi     # 0x79710
callq 0x8570
movq 0x8(%rsp), %rax
movq $0x0, 0x118(%rax)
movb $0x0, 0x69(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: readmapping[P]alfalfa/src/mapper.h
// Function: read_t::init(bool)
void init(bool nucleotidesOnly){
        rcSequence = sequence;//copy
        Utils::reverse_complement(rcSequence, nucleotidesOnly);
        rQual = qual;
        std::reverse(rQual.begin(),rQual.end());
        readP = (uint8_t *)std::malloc(sequence.length());
        rcReadP = (uint8_t *)std::malloc(sequence.length());
        for (size_t i = 0; i < sequence.length(); ++i){ // convert to the nt4 encoding
            readP[i] = Utils::ORDVALUE[(size_t)sequence[i]];
            rcReadP[i] = Utils::ORDVALUE[(size_t)rcSequence[i]];
        }
    }

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rdi, %rsi
addq $0x20, %rsi
addq $0x60, %rdi
callq 0x8060
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
movb 0x2f(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x39d10
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
addq $0x80, %rdi
callq 0x8060
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x8310
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x80, %rdi
callq 0x81e0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xe110
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x8630
movq %rax, %rdi
callq 0x8560
movq 0x8(%rsp), %rdi
movq %rax, 0xa0(%rdi)
addq $0x20, %rdi
callq 0x8630
movq %rax, %rdi
callq 0x8560
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0xa8(%rax)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
addq $0x20, %rdi
callq 0x8630
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xe08f
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x10(%rsp), %rsi
callq 0x8830
movq 0x8(%rsp), %rdi
movsbq (%rax), %rcx
leaq 0x6b729(%rip), %rax     # 0x79760
movb (%rax,%rcx), %dl
movq 0xa0(%rdi), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
addq $0x60, %rdi
movq 0x10(%rsp), %rsi
callq 0x8830
movq %rax, %rcx
movq 0x8(%rsp), %rax
movsbq (%rcx), %rdx
leaq 0x6b6f6(%rip), %rcx     # 0x79760
movb (%rcx,%rdx), %dl
movq 0xa8(%rax), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xdff1
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: readmapping[P]alfalfa/src/mapper.h
// Function: alignment_t::setUnPaired(bool)
void setUnPaired(bool upstream){
    flag.set(0,true);
    flag.set(6,upstream);
    flag.set(7,!upstream);
    flag.set(3,true);
  }

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0xe640
movq (%rsp), %rdi
addq $0x40, %rdi
movb 0xf(%rsp), %al
movl $0x6, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xe640
movq (%rsp), %rdi
addq $0x40, %rdi
movb 0xf(%rsp), %al
xorb $-0x1, %al
movzbl %al, %edx
andl $0x1, %edx
movl $0x7, %esi
callq 0xe640
movq (%rsp), %rdi
addq $0x40, %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0xe640
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: readmapping[P]alfalfa/src/options.cpp
// Function: align_opt::fill_m()
void align_opt::fill_m() {
    int i, j, k;
    for (i = k = 0; i < 4; ++i) {
        for (j = 0; j < 4; ++j)
            mat[k++] = i == j ? match : mismatch;
        mat[k++] = -1; // ambiguous base
    }
    for (j = 0; j < 5; ++j) mat[k++] = -1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x4, -0xc(%rsp)
jge 0x12632
movl $0x0, -0x10(%rsp)
cmpl $0x4, -0x10(%rsp)
jge 0x12608
movl -0xc(%rsp), %eax
cmpl -0x10(%rsp), %eax
jne 0x125d0
movq -0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rsp)
jmp 0x125dc
movq -0x20(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rsp)
movq -0x20(%rsp), %rax
movl -0x24(%rsp), %ecx
movb %cl, %dl
movl -0x14(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rsp)
movslq %ecx, %rcx
movb %dl, 0x10(%rax,%rcx)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x125b2
movq -0x20(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rsp)
movslq %ecx, %rcx
movb $-0x1, 0x10(%rax,%rcx)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x1259f
movl $0x0, -0x10(%rsp)
cmpl $0x5, -0x10(%rsp)
jge 0x12668
movq -0x20(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rsp)
movslq %ecx, %rcx
movb $-0x1, 0x10(%rax,%rcx)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x1263a
retq
nopl (%rax)
// File: readmapping[P]alfalfa/src/options.cpp
// Function: parseSeedType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
mum_t parseSeedType(string type) {
    if (type.compare("MEM") == 0)
        return MEM;
    else if (type.compare("MAM") == 0)
        return MAM;
    else if (type.compare("MUM") == 0)
        return MUM;
    else if (type.compare("SMEM") == 0)
        return SMAM;
    else if (type.compare("SMAM") == 0)
        return SMAM;
    else if (type.compare("PSMEM") == 0)
        return SMEM;
    else {
        cerr << "WARNING: unrecognized seed type. SMEMs are used instead." << endl;
        return SMAM;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x66956(%rip), %rsi     # 0x79dfa
callq 0x8130
cmpl $0x0, %eax
jne 0x134bb
movl $0x2, 0x14(%rsp)
jmp 0x13586
movq (%rsp), %rdi
leaq 0x6692e(%rip), %rsi     # 0x79df4
callq 0x8130
cmpl $0x0, %eax
jne 0x134dd
movl $0x1, 0x14(%rsp)
jmp 0x13586
movq (%rsp), %rdi
leaq 0x66907(%rip), %rsi     # 0x79def
callq 0x8130
cmpl $0x0, %eax
jne 0x134ff
movl $0x0, 0x14(%rsp)
jmp 0x13586
movq (%rsp), %rdi
leaq 0x668ef(%rip), %rsi     # 0x79df9
callq 0x8130
cmpl $0x0, %eax
jne 0x1351e
movl $0x4, 0x14(%rsp)
jmp 0x13586
movq (%rsp), %rdi
leaq 0x668ca(%rip), %rsi     # 0x79df3
callq 0x8130
cmpl $0x0, %eax
jne 0x1353d
movl $0x4, 0x14(%rsp)
jmp 0x13586
movq (%rsp), %rdi
leaq 0x668b0(%rip), %rsi     # 0x79df8
callq 0x8130
cmpl $0x0, %eax
jne 0x1355c
movl $0x3, 0x14(%rsp)
jmp 0x13586
movq 0x83a8d(%rip), %rdi     # 0x96ff0
leaq 0x66894(%rip), %rsi     # 0x79dfe
callq 0x8360
movq %rax, %rdi
movq 0x83a37(%rip), %rsi     # 0x96fb0
callq 0x83b0
movl $0x4, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: readmapping[P]alfalfa/src/options.cpp
// Function: parseOrientation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
orientation_t parseOrientation(string type) {
    if (type.compare("fr") == 0)
        return PAIR_FR;
    else if (type.compare("rf") == 0)
        return PAIR_RF;
    else if (type.compare("ff") == 0)
        return PAIR_FF;
    else {
        cerr << "WARNING: unrecognized orientation. fr is used instead." << endl;
        return PAIR_FR;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x66893(%rip), %rsi     # 0x79e37
callq 0x8130
cmpl $0x0, %eax
jne 0x135b8
movl $0x0, 0x14(%rsp)
jmp 0x13620
movq (%rsp), %rdi
leaq 0x66877(%rip), %rsi     # 0x79e3a
callq 0x8130
cmpl $0x0, %eax
jne 0x135d7
movl $0x1, 0x14(%rsp)
jmp 0x13620
movq (%rsp), %rdi
leaq 0x6685b(%rip), %rsi     # 0x79e3d
callq 0x8130
cmpl $0x0, %eax
jne 0x135f6
movl $0x2, 0x14(%rsp)
jmp 0x13620
movq 0x839f3(%rip), %rdi     # 0x96ff0
leaq 0x6683c(%rip), %rsi     # 0x79e40
callq 0x8360
movq %rax, %rdi
movq 0x8399d(%rip), %rsi     # 0x96fb0
callq 0x83b0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: readmapping[P]alfalfa/src/sparseSA.cpp
// Function: vec_uchar::index_size_in_bytes()
long vec_uchar::index_size_in_bytes(){
    long indexSize = 0L;
    indexSize += sizeof(vec) + vec.capacity()*sizeof(unsigned char);
    indexSize += sizeof(M) + M.capacity()*(sizeof(size_t)+sizeof(int));
    return indexSize;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x1ea10
movq (%rsp), %rdi
shlq $0x0, %rax
addq $0x18, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
callq 0x1ea30
imulq $0xc, %rax, %rax
addq $0x18, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: readmapping[P]alfalfa/src/sparseSA.cpp
// Function: sparseSA::index_size_in_bytes()
long sparseSA::index_size_in_bytes(){
      long indexSize = 0L;
      indexSize += sizeof(sparseMult);
      indexSize += sizeof(hasSufLink);
      indexSize += sizeof(hasChild);
      indexSize += sizeof(K);
      indexSize += sizeof(NKm1);
      indexSize += sizeof(logN);
      indexSize += sizeof(N);
      indexSize += sizeof(maxdescrlen);
      indexSize += sizeof(descr);
      for(size_t i = 0; i < descr.size(); i++){
          indexSize += descr[i].capacity();
      }
      indexSize += sizeof(startpos) + startpos.capacity()*sizeof(long);
      indexSize += S.capacity();
      indexSize += sizeof(SA) + SA.capacity()*sizeof(unsigned int);
      indexSize += sizeof(ISA) + ISA.capacity()*sizeof(int);
      indexSize += sizeof(CHILD) + CHILD.capacity()*sizeof(int);
      indexSize += LCP.index_size_in_bytes();
      indexSize += sizeof(hasKmer);
      indexSize += sizeof(KMR) + KMR.capacity()*sizeof(saTuple_t);
      return indexSize;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0xccb0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x16523
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xccf0
movq %rax, %rdi
callq 0x8040
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x164d3
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x1ea50
movq 0x8(%rsp), %rdi
shlq $0x3, %rax
addq $0x18, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x50, %rdi
callq 0x8040
movq 0x8(%rsp), %rdi
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x70, %rdi
callq 0x1ea70
movq 0x8(%rsp), %rdi
shlq $0x2, %rax
addq $0x18, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x88, %rdi
callq 0x1ea90
movq 0x8(%rsp), %rdi
shlq $0x2, %rax
addq $0x18, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0xd0, %rdi
callq 0x1ea90
movq 0x8(%rsp), %rdi
shlq $0x2, %rax
addq $0x18, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0xa0, %rdi
callq 0x163d0
movq 0x8(%rsp), %rdi
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
addq $0x100, %rdi            # imm = 0x100
callq 0x1eab0
shlq $0x3, %rax
addq $0x18, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: readmapping[P]alfalfa/src/sparseSA.cpp
// Function: sparseSA::computeLCP()
void sparseSA::computeLCP() {
  long h=0;
  for(long i = 0; i < N; i+=K) {
    long m = ISA[i/K];
    if(m==0) LCP.set(m, 0); // LCP[m]=0;
    else {
      long j = SA[m-1];
      while(i+h < N && j+h < N && S[i+h] == S[j+h])  h++;
      LCP.set(m, h); //LCP[m] = h;
    }
    h = max(0L, h - K);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
cmpq 0x38(%rcx), %rax
jge 0x17282
movq 0x8(%rsp), %rcx
movq %rcx, %rdi
addq $0x88, %rdi
movq 0x30(%rsp), %rax
cqto
idivq 0xe8(%rcx)
movq %rax, %rsi
callq 0x1eb90
movslq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x1715b
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
movq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x1ebb0
jmp 0x17231
movq 0x8(%rsp), %rdi
addq $0x70, %rdi
movq 0x28(%rsp), %rsi
subq $0x1, %rsi
callq 0x1ec60
movl (%rax), %eax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rdx
movq 0x30(%rsp), %rcx
addq 0x38(%rsp), %rcx
xorl %eax, %eax
cmpq 0x38(%rdx), %rcx
movb %al, 0x7(%rsp)
jge 0x171f7
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rcx
addq 0x38(%rsp), %rcx
xorl %eax, %eax
cmpq 0x38(%rdx), %rcx
movb %al, 0x7(%rsp)
jge 0x171f7
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
movq 0x30(%rsp), %rsi
addq 0x38(%rsp), %rsi
callq 0x8830
movq 0x8(%rsp), %rdi
movsbl (%rax), %eax
movl %eax, (%rsp)
addq $0x50, %rdi
movq 0x20(%rsp), %rsi
addq 0x38(%rsp), %rsi
callq 0x8830
movq %rax, %rcx
movl (%rsp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x17201
jmp 0x17214
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x17179
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rax
movl %eax, %edx
callq 0x1ebb0
movq 0x8(%rsp), %rcx
movq $0x0, 0x18(%rsp)
movq 0x38(%rsp), %rax
subq 0xe8(%rcx), %rax
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1ec80
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%rsp), %rax
movq 0xe8(%rax), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x170f5
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: readmapping[P]alfalfa/src/sparseSA.cpp
// Function: sparseSA::collectAllSMAMs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, interval_t, std::vector<match_t, std::allocator<match_t>>&, int, int, int) const
void sparseSA::collectAllSMAMs(const string &P, int prefix,
        interval_t xmi, vector<match_t> &matches, int min_len, int maxCount, int maxLeft) const {
  // All of the suffixes in xmi's interval are right maximal.
  if(xmi.size() <= maxCount)
        for(long i = xmi.start; i <= xmi.end; i++) 
            find_LmaximalStrict(P, prefix, SA[i], xmi.depth, matches, min_len, maxLeft);
}

// Assembly:
subq $0x68, %rsp
movq %rcx, 0x20(%rsp)
movq %rdi, %rax
movq 0x20(%rsp), %rdi
movl 0x78(%rsp), %ecx
movl 0x70(%rsp), %ecx
movq %rax, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq %rdi, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movl %r9d, 0x3c(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x1fbb0
movslq 0x70(%rsp), %rcx
cmpq %rcx, %rax
jg 0x1b20e
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
cmpq 0x8(%rcx), %rax
jg 0x1b20c
movq 0x28(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x1c(%rsp)
addq $0x70, %rdi
movq 0x30(%rsp), %rsi
callq 0x1fb90
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq %rax, %rcx
movq 0x20(%rsp), %rax
movl (%rcx), %ecx
movl 0x10(%rax), %r8d
movq 0x40(%rsp), %r9
movl 0x3c(%rsp), %r10d
movl 0x78(%rsp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x1fa80
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1b190
jmp 0x1b20e
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/sparseSA.h
// Function: vec_uchar::set(unsigned long, int)
void set(size_t idx, int v){
    if(v >= std::numeric_limits<unsigned char>::max()) {
        vec.at(idx) = std::numeric_limits<unsigned char>::max();
        M.push_back(item_t(idx, v));
    }
    else { vec.at(idx) = (unsigned char)v; }
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x1c(%rsp)
callq 0x216f0
movb %al, %cl
movl 0x1c(%rsp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jl 0x1ec39
callq 0x216f0
movq 0x10(%rsp), %rdi
movb %al, 0x7(%rsp)
movq 0x38(%rsp), %rsi
callq 0x21700
movb 0x7(%rsp), %dl
movq %rax, %rcx
movq 0x10(%rsp), %rax
movb %dl, (%rcx)
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %edx
leaq 0x20(%rsp), %rdi
callq 0x21770
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x21740
jmp 0x1ec56
movq 0x10(%rsp), %rdi
movl 0x34(%rsp), %eax
movb %al, 0x6(%rsp)
movq 0x38(%rsp), %rsi
callq 0x21700
movb 0x6(%rsp), %cl
movb %cl, (%rax)
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: readmapping[P]alfalfa/src/sparseSA.h
// Function: vec_uchar::operator[](unsigned long) const
int operator[] (size_t idx) const {
    if(vec[idx] == std::numeric_limits<unsigned char>::max())
        return std::lower_bound(M.begin(), M.end(), item_t(idx,0))->val;
    else
        return vec[idx];
  }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x40(%rsp), %rsi
callq 0x22040
movzbl (%rax), %eax
movl %eax, 0x14(%rsp)
callq 0x216f0
movb %al, %cl
movl 0x14(%rsp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x1edbe
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x220c0
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x18, %rdi
callq 0x220f0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
callq 0x21770
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x22060
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x22120
movl 0x8(%rax), %eax
movl %eax, 0x54(%rsp)
jmp 0x1edd4
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x22040
movzbl (%rax), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: readmapping[P]alfalfa/src/sparseSA.cpp
// Function: sparseSA::find_LmaximalStrict(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, long, int, std::vector<match_t, std::allocator<match_t>>&, int, int) const
void sparseSA::find_LmaximalStrict(const string &P, int prefix, long i,
        int len, vector<match_t> &matches, int min_len, int border) const {
  // Advance to the left up to K steps.
  for(int k = 0; k < border; k++) {
    // If we reach the end and the match is long enough, print.
    if(prefix == 0 || i == 0 || P[prefix-1] != S[i-1]) {
        if(len >= min_len){
            matches.push_back(match_t(i, prefix, len));
        }
        return; // Reached mismatch, done.
    }
    prefix--; i--; len++; // Continue matching.
  }
}

// Assembly:
subq $0x68, %rsp
movl 0x78(%rsp), %eax
movl 0x70(%rsp), %eax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movq %r9, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x78(%rsp), %eax
jge 0x1fb88
cmpl $0x0, 0x54(%rsp)
je 0x1fb18
cmpq $0x0, 0x48(%rsp)
je 0x1fb18
movq 0x58(%rsp), %rdi
movl 0x54(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8410
movq 0x18(%rsp), %rdi
movsbl (%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x50, %rdi
movq 0x48(%rsp), %rsi
subq $0x1, %rsi
callq 0x8410
movq %rax, %rcx
movl 0x14(%rsp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x1fb54
movl 0x44(%rsp), %eax
cmpl 0x70(%rsp), %eax
jl 0x1fb52
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
movl 0x54(%rsp), %edx
movl 0x44(%rsp), %ecx
leaq 0x20(%rsp), %rdi
callq 0x22d00
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x22cd0
jmp 0x1fb88
movl 0x54(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x54(%rsp)
movq 0x48(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x48(%rsp)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x1fabb
addq $0x68, %rsp
retq
nopl (%rax)
// File: readmapping[P]alfalfa/src/sparseSA.cpp
// Function: sparseSA::suffixlink(interval_t&) const
bool sparseSA::suffixlink(interval_t &m) const {
  m.depth -= K;
  if( m.depth <= 0) return false;
  m.start = ISA[SA[m.start] / K + 1];
  m.end = ISA[SA[m.end] / K + 1];
  return expand_link(m);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xe8(%rax), %rdx
movq 0x20(%rsp), %rax
movslq 0x10(%rax), %rcx
subq %rdx, %rcx
movl %ecx, 0x10(%rax)
movq 0x20(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jg 0x208a3
movb $0x0, 0x37(%rsp)
jmp 0x2095a
movq 0x18(%rsp), %rdi
movq %rdi, %rax
addq $0x88, %rax
movq %rax, 0x8(%rsp)
addq $0x70, %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
callq 0x1fb90
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movl (%rax), %eax
cqto
idivq 0xe8(%rcx)
movq %rax, %rsi
addq $0x1, %rsi
callq 0x237b0
movq 0x18(%rsp), %rdi
movslq (%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq %rdi, %rax
addq $0x88, %rax
movq %rax, 0x10(%rsp)
addq $0x70, %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x1fb90
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
movl (%rax), %eax
cqto
idivq 0xe8(%rcx)
movq %rax, %rsi
addq $0x1, %rsi
callq 0x237b0
movq 0x18(%rsp), %rdi
movslq (%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rsi
callq 0x23a50
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: readmapping[P]alfalfa/src/sparseSA.h
// Function: sparseSA::expand_link(interval_t&) const
inline bool expand_link(interval_t &link) const {
    long thresh = 2 * link.depth * logN, exp = 0; // Threshold link expansion.
    long start = link.start;
    long end = link.end;
    while(LCP[start] >= link.depth) {
      exp++;
      if(exp >= thresh) return false;
      start--;
    }
    while(end < NKm1 && LCP[end+1] >= link.depth) {
      exp++;
      if(exp >= thresh) return false;
      end++;
    }
    link.start = start; link.end = end;
    return true;
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x30(%rsp), %rax
movl 0x10(%rax), %eax
shll %eax
cltq
imulq 0x40(%rcx), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
movq 0x18(%rsp), %rsi
callq 0x1ed20
movq 0x30(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jl 0x23af6
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
jl 0x23ae6
movb $0x0, 0x47(%rsp)
jmp 0x23b92
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x23aa2
jmp 0x23af8
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x48(%rdx), %rcx
movb %al, 0x7(%rsp)
jge 0x23b37
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x1ed20
movq 0x30(%rsp), %rcx
cmpl 0x10(%rcx), %eax
setge %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x23b41
jmp 0x23b72
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
jl 0x23b62
movb $0x0, 0x47(%rsp)
jmp 0x23b92
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x23af8
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: readmapping[P]alfalfa/src/fasta.cpp
// Function: trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, long&, long&)
void trim(string &line, long &start, long &end) {
  // Trim leading spaces.
  for(long i = start; i < (int)line.length(); i++) {
    if(line[i] != ' ') { start = i; break; }
  }
  // Trim trailing spaces.
  for(long i = line.length() - 1; i >= 0; i--) {
    if(line[i] != ' ') { end = i; break; }
    if(i == 0) break;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8630
movq %rax, %rcx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x2fcbc
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x8830
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x2fcaa
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x2fcbc
jmp 0x2fcac
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2fc60
movq 0x30(%rsp), %rdi
callq 0x8630
subq $0x1, %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jl 0x2fd19
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8830
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x2fcfd
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
jmp 0x2fd19
cmpq $0x0, 0x10(%rsp)
jne 0x2fd07
jmp 0x2fd19
jmp 0x2fd09
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2fccf
addq $0x38, %rsp
retq
nop
// File: readmapping[P]alfalfa/src/fasta.cpp
// Function: fastqInputReader::fastqInputReader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
fastqInputReader::fastqInputReader(const string& fName, bool nucOnly): 
        nucleotidesOnly(nucOnly), filename(fName) {
    pthread_mutex_init(&readLock_, NULL);
    fp = gzopen(fName.c_str(),"r");
    if(fp == NULL){
        fprintf(stderr, "ERROR: file %s could not be read.", fName.c_str());
        exit(1);
    }
    seq = kseq_init(fp);
}

// Assembly:
subq $0x58, %rsp
movb %dl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
movb %al, 0x14(%rdi)
addq $0x18, %rdi
movq %rdi, 0x18(%rsp)
movq 0x48(%rsp), %rsi
callq 0x8180
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8620
movq 0x48(%rsp), %rdi
callq 0x8170
movq %rax, %rdi
leaq 0x4a2a9(%rip), %rsi     # 0x7a74b
callq 0x8600
movq %rax, 0x28(%rsp)
jmp 0x304ae
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x30514
movq 0x66b08(%rip), %rax     # 0x96fd0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x8170
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0x4d365(%rip), %rsi     # 0x7d84e
movb $0x0, %al
callq 0x85c0
movl $0x1, %edi
callq 0x84a0
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x8858
jmp 0x3053b
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x30550
movq %rax, 0x8(%rsp)
jmp 0x30528
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x8730
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/fasta.cpp
// Function: fastqInputReader::open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void fastqInputReader::open(const string& fileName, bool nucOnly){
    nucleotidesOnly = nucOnly;
    filename = fileName;
    fp = gzopen(fileName.c_str(),"r");
    if(fp == NULL){
        fprintf(stderr, "ERROR: file %s could not be read.", fileName.c_str());
        exit(1);
    }
    seq = kseq_init(fp);
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x14(%rdi)
movq 0x18(%rsp), %rsi
addq $0x18, %rdi
callq 0x8060
movq 0x18(%rsp), %rdi
callq 0x8170
movq %rax, %rdi
leaq 0x4a170(%rip), %rsi     # 0x7a74b
callq 0x8600
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x30628
movq 0x669d8(%rip), %rax     # 0x96fd0
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x8170
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x4d237(%rip), %rsi     # 0x7d84e
movb $0x0, %al
callq 0x85c0
movl $0x1, %edi
callq 0x84a0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x30550
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/fasta.cpp
// Function: fastqInputReader::nextRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool fastqInputReader::nextRead(string& meta, string& sequence, string& qualities){
    l = kseq_read(seq);
    if(l < 0)
        return false;
    else{
        meta = seq->name.s;
        sequence = seq->seq.s;
        for(size_t i = 0; i <= sequence.length(); i++) {
            char c = std::tolower(sequence[i]);
            if(nucleotidesOnly) {
                switch(c) {
                    case 'a': case 't': case 'g': case 'c': break;
                    default:
                        c = '~';
                }
            }
            sequence[i] = c;
        }
        
        if (seq->qual.l)
            qualities = seq->qual.s;
        
        return true;
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rax), %rdi
callq 0x30880
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jge 0x30755
movb $0x0, 0x57(%rsp)
jmp 0x3086f
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
movq 0x40(%rsp), %rdi
callq 0x8570
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x40(%rax), %rsi
movq 0x38(%rsp), %rdi
callq 0x8570
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x8630
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
ja 0x30843
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x8830
movsbl (%rax), %edi
callq 0x85d0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movb %cl, 0x27(%rsp)
testb $0x1, 0x14(%rax)
je 0x30813
movsbl 0x27(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x61, %eax
je 0x3080a
jmp 0x307e9
movl 0xc(%rsp), %eax
subl $0x63, %eax
je 0x3080a
jmp 0x307f4
movl 0xc(%rsp), %eax
subl $0x67, %eax
je 0x3080a
jmp 0x307ff
movl 0xc(%rsp), %eax
subl $0x74, %eax
jne 0x3080c
jmp 0x3080a
jmp 0x30811
movb $0x7e, 0x27(%rsp)
jmp 0x30813
movb 0x27(%rsp), %al
movb %al, 0xb(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x8830
movb 0xb(%rsp), %cl
movb %cl, (%rax)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x3078c
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x48(%rax)
je 0x3086a
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x58(%rax), %rsi
movq 0x30(%rsp), %rdi
callq 0x8570
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: readmapping[P]alfalfa/src/dp.cpp
// Function: dp_scores::updateScoreMatrixDna()
void dp_scores::updateScoreMatrixDna(){//presumes match/mismatch has been added correctly
    for(int i = 0; i < 127; i++)
        for(int j = 0; j < 127; j++)
            //set to value that is small enough to be used with large reads and not cause overflow with current score
            scoreMatrix[i][j] = -200000;
    for(int i = 'A'; i <= 'Z'; i++)
        for(int j = 'A'; j <= 'Z'; j++)
            scoreMatrix[i][j] = i==j ? match : mismatch;
    for(int i = 'a'; i <= 'z'; i++)
        for(int j = 'a'; j <= 'z'; j++)
            scoreMatrix[i][j] = i==j ? match : mismatch;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x7f, -0xc(%rsp)
jge 0x3145d
movl $0x0, -0x10(%rsp)
cmpl $0x7f, -0x10(%rsp)
jge 0x3144e
movq -0x28(%rsp), %rax
addq $0x10, %rax
movslq -0xc(%rsp), %rcx
imulq $0x1fc, %rcx, %rcx      # imm = 0x1FC
addq %rcx, %rax
movslq -0x10(%rsp), %rcx
movl $0xfffcf2c0, (%rax,%rcx,4) # imm = 0xFFFCF2C0
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x31416
jmp 0x31450
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x31407
movl $0x41, -0x14(%rsp)
cmpl $0x5a, -0x14(%rsp)
jg 0x314de
movl $0x41, -0x18(%rsp)
cmpl $0x5a, -0x18(%rsp)
jg 0x314cf
movl -0x14(%rsp), %eax
cmpl -0x18(%rsp), %eax
jne 0x31492
movq -0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rsp)
jmp 0x3149e
movq -0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rsp)
movq -0x28(%rsp), %rax
movl -0x2c(%rsp), %edx
addq $0x10, %rax
movslq -0x14(%rsp), %rcx
imulq $0x1fc, %rcx, %rcx      # imm = 0x1FC
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x31474
jmp 0x314d1
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x31465
movl $0x61, -0x1c(%rsp)
cmpl $0x7a, -0x1c(%rsp)
jg 0x3155f
movl $0x61, -0x20(%rsp)
cmpl $0x7a, -0x20(%rsp)
jg 0x31550
movl -0x1c(%rsp), %eax
cmpl -0x20(%rsp), %eax
jne 0x31513
movq -0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rsp)
jmp 0x3151f
movq -0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x30(%rsp)
movq -0x28(%rsp), %rax
movl -0x30(%rsp), %edx
addq $0x10, %rax
movslq -0x1c(%rsp), %rcx
imulq $0x1fc, %rcx, %rcx      # imm = 0x1FC
addq %rcx, %rax
movslq -0x20(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x314f5
jmp 0x31552
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x314e6
retq
// File: readmapping[P]alfalfa/src/dp.cpp
// Function: dynProg::initDPMatrix(int, int, bool)
void dynProg::initDPMatrix(int dimensionL2, int dimensionL1, bool affine){
    DP_L2 = dimensionL2;
    DP_L1 = dimensionL1;
    M = new int * [DP_L2];
    for(int i = 0; i < DP_L2; i++){
        M[i] = new int[DP_L1];
    }
    if(affine){
        UP = new int * [DP_L1];
        LEFT = new int * [DP_L1];
        for(int i = 0; i < DP_L2; i++){
            UP[i] = new int[DP_L1];
            LEFT[i] = new int[DP_L1];
        }
    }
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x18(%rax)
movl 0x18(%rsp), %ecx
movl %ecx, 0x1c(%rax)
movslq 0x18(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x10(%rsp)
movq (%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x18(%rcx), %eax
jge 0x3161d
movq (%rsp), %rax
movslq 0x1c(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, %rdx
movq (%rsp), %rax
movq (%rax), %rax
movslq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x315c7
testb $0x1, 0x17(%rsp)
je 0x3172d
movq (%rsp), %rax
movslq 0x1c(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movslq 0x1c(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x18(%rcx), %eax
jge 0x3172b
movq (%rsp), %rax
movslq 0x1c(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, %rsi
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movslq 0xc(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movslq 0x1c(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, %rdx
movq (%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x31694
jmp 0x3172d
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)