LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: readmapping[P]alfalfa/src/dp.cpp
// Function: dynProg::deleteDPMatrix(bool)
void dynProg::deleteDPMatrix(bool affine){
    for(int i = 0; i < DP_L2; i++)
        delete[] M[ i ];
    delete[] M;
    if(affine){
        for(int i = 0; i < DP_L2; i++){
            delete[] UP[ i ];
            delete[] LEFT[ i ];
        }
        delete[] UP;
        delete[] LEFT;
    }
}

// Assembly:
subq $0x58, %rsp
movb %sil, %al
movq %rdi, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x48(%rsp)
movq 0x38(%rsp), %rcx
movl 0x48(%rsp), %eax
cmpl 0x18(%rcx), %eax
jge 0x317d7
movq 0x38(%rsp), %rax
movq (%rax), %rax
movslq 0x48(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x317c8
movq 0x30(%rsp), %rdi
callq 0x8520
jmp 0x317ca
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x31794
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x317f4
movq 0x28(%rsp), %rdi
callq 0x8520
testb $0x1, 0x4f(%rsp)
je 0x318b0
movl $0x0, 0x44(%rsp)
movq 0x38(%rsp), %rcx
movl 0x44(%rsp), %eax
cmpl 0x18(%rcx), %eax
jge 0x31872
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x44(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x3183c
movq 0x20(%rsp), %rdi
callq 0x8520
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x44(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x31863
movq 0x18(%rsp), %rdi
callq 0x8520
jmp 0x31865
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x31807
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x31890
movq 0x10(%rsp), %rdi
callq 0x8520
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x318ae
movq 0x8(%rsp), %rdi
callq 0x8520
jmp 0x318b0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/utils.cpp
// Function: Utils::contains(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long, long, char)
bool contains(const std::string & str,const long begin,const long end, const char c){
        bool contains = false;
        long i = begin;
        assert(begin >= 0 && end < (long)str.length());
        while(!contains && i <= end){
            contains = str[i] == c;
            i++;
        }
        return contains;
    }

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movb $0x0, 0x1e(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
testb $0x1, 0x1e(%rsp)
movb %al, 0xf(%rsp)
jne 0x39cc6
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
setle %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x39cd0
jmp 0x39d02
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8410
movsbl (%rax), %eax
movsbl 0x1f(%rsp), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, 0x1e(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x39ca8
movb 0x1e(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: readmapping[P]alfalfa/src/utils.cpp
// Function: Utils::reverse_complement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool)
void reverse_complement(std::string &seq_rc, bool nucleotides_only) {//TODO optimize this for char arrays
        // Reverse in-place.
        std::reverse(seq_rc.begin(), seq_rc.end());
        for(size_t i = 0; i < seq_rc.length(); i++) {
            // Adapted from Kurtz code in MUMmer v3.
            seq_rc[i] = RC_TABLE[(int)seq_rc[i]];
        }
    }

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8310
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x81e0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xe110
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8630
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x39dc1
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8830
movsbl (%rax), %eax
movslq %eax, %rcx
leaq 0x43cab(%rip), %rax     # 0x7da40
movb (%rax,%rcx), %al
movb %al, 0x7(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8830
movb 0x7(%rsp), %cl
movb %cl, (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x39d58
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/mapper.cpp
// Function: bandSizeEstimate(int, int, int, int, int, int, int)
int bandSizeEstimate(int fixedBandSize, int qLen, int refLen, int matchScore, int gapOpen, int gapExtend, int alignmentScore){
    int minBandSize = max(qLen-refLen,refLen-qLen)+3;
    int scoreBandSize = (min(qLen,refLen)*matchScore - alignmentScore + gapOpen)/(-1*gapExtend) + 1;
    int maxGapBandSize = minBandSize-3 + ((qLen>>1)*matchScore+gapOpen)/(-1*gapExtend) + 1;
    int band = min(maxGapBandSize,scoreBandSize);
    band = min(fixedBandSize,band);
    band = max(minBandSize,band);
    return band;
}

// Assembly:
subq $0x38, %rsp
movl 0x40(%rsp), %eax
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movl %ecx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movl %r9d, 0x20(%rsp)
movl 0x30(%rsp), %eax
subl 0x2c(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x2c(%rsp), %eax
subl 0x30(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x14d40
movl (%rax), %eax
addl $0x3, %eax
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0xc080
movl (%rax), %eax
imull 0x28(%rsp), %eax
subl 0x40(%rsp), %eax
addl 0x24(%rsp), %eax
imull $0xffffffff, 0x20(%rsp), %ecx # imm = 0xFFFFFFFF
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
subl $0x3, %eax
movl %eax, 0x4(%rsp)
movl 0x30(%rsp), %eax
sarl %eax
imull 0x28(%rsp), %eax
addl 0x24(%rsp), %eax
imull $0xffffffff, 0x20(%rsp), %ecx # imm = 0xFFFFFFFF
cltd
idivl %ecx
movl %eax, %ecx
movl 0x4(%rsp), %eax
addl %ecx, %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
leaq 0xc(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc080
movl (%rax), %eax
movl %eax, 0x8(%rsp)
leaq 0x34(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc080
movl (%rax), %eax
movl %eax, 0x8(%rsp)
leaq 0x1c(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x14d40
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: readmapping[P]alfalfa/src/mapper.cpp
// Function: recoverCIGAR3from4(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string recoverCIGAR3from4(string cigar4){
    stringstream ss(cigar4);
    stringstream cigar3;
    int i;
    char symbol;
    int matchLength = 0;
    while (ss >> i){
        ss.get(symbol);
        if(symbol == 'X' || symbol == '=')
            matchLength += i;
        else{
            //finish previous series of match/mismatch
            if(matchLength > 0){
                cigar3 << matchLength << 'M';
                matchLength = 0;
            }
            cigar3 << i << symbol;
        }
    }
    //finish possible last series of matches
    if(matchLength > 0)
        cigar3 << matchLength << 'M';
    return cigar3.str();
}

// Assembly:
subq $0x378, %rsp            # imm = 0x378
movq %rsi, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x370(%rsp)
movq %rsi, 0x368(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x4c1e0
movq 0x38(%rsp), %rsi
movl %eax, %edx
leaq 0x1e0(%rsp), %rdi
callq 0x8690
leaq 0x58(%rsp), %rdi
callq 0x8260
jmp 0x39f28
movl $0x0, 0x40(%rsp)
leaq 0x1e0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x8200
movq %rax, 0x20(%rsp)
jmp 0x39f49
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x84f0
movb %al, 0x1f(%rsp)
jmp 0x39f63
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x39f70
jmp 0x3a03b
leaq 0x1e0(%rsp), %rdi
leaq 0x47(%rsp), %rsi
callq 0x8580
jmp 0x39f84
movsbl 0x47(%rsp), %eax
cmpl $0x58, %eax
je 0x39f98
movsbl 0x47(%rsp), %eax
cmpl $0x3d, %eax
jne 0x39fd9
movl 0x48(%rsp), %eax
addl 0x40(%rsp), %eax
movl %eax, 0x40(%rsp)
jmp 0x3a036
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3a09d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x8290
jmp 0x3a09d
cmpl $0x0, 0x40(%rsp)
jle 0x3a00e
leaq 0x68(%rsp), %rdi
movl 0x40(%rsp), %esi
callq 0x8710
movq %rax, 0x10(%rsp)
jmp 0x39ff5
movq 0x10(%rsp), %rdi
movl $0x4d, %esi
callq 0x8440
jmp 0x3a006
movl $0x0, 0x40(%rsp)
leaq 0x68(%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0x8710
movq %rax, 0x8(%rsp)
jmp 0x3a023
movq 0x8(%rsp), %rdi
movsbl 0x47(%rsp), %esi
callq 0x8440
jmp 0x3a034
jmp 0x3a036
jmp 0x39f30
cmpl $0x0, 0x40(%rsp)
jle 0x3a068
leaq 0x68(%rsp), %rdi
movl 0x40(%rsp), %esi
callq 0x8710
movq %rax, (%rsp)
jmp 0x3a056
movq (%rsp), %rdi
movl $0x4d, %esi
callq 0x8440
jmp 0x3a066
jmp 0x3a068
movq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x8350
jmp 0x3a079
leaq 0x58(%rsp), %rdi
callq 0x8290
leaq 0x1e0(%rsp), %rdi
callq 0x8290
movq 0x30(%rsp), %rax
addq $0x378, %rsp            # imm = 0x378
retq
leaq 0x1e0(%rsp), %rdi
callq 0x8290
movq 0x50(%rsp), %rdi
callq 0x8730
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/mapper.cpp
// Function: coveredBases(lis_t&)
int coveredBases(lis_t& interval){
    //sort this candidate region by query position
    interval.sortByReadPos();
    vector<match_t> & seeds = interval.matches;
    int trueCover = seeds[0].len;
    int prevEnd = seeds[0].query + seeds[0].len-1;
    for(size_t i = 1; i < seeds.size(); i++ ){
        int start = max(seeds[i].query,prevEnd+1);
        int stop = max(prevEnd,seeds[i].query + seeds[i].len -1);
        prevEnd = stop;
        trueCover += max(0,stop-start+1);
    }
    return trueCover;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x4c8a0
movq 0x50(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4c200
movl 0xc(%rax), %eax
movl %eax, 0x44(%rsp)
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4c200
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4c200
movq %rax, %rcx
movl 0x1c(%rsp), %eax
addl 0xc(%rcx), %eax
subl $0x1, %eax
movl %eax, 0x40(%rsp)
movq $0x1, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x23440
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x3ed7f
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x4c200
movq %rax, %rdi
addq $0x8, %rdi
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x14d40
movl (%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x4c200
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x4c200
movq %rax, %rcx
movl 0xc(%rsp), %eax
addl 0xc(%rcx), %eax
subl $0x1, %eax
movl %eax, 0x28(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x14d40
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x40(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x2c(%rsp), %eax
subl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
leaq 0x24(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x14d40
movl (%rax), %eax
addl 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x3ec93
movl 0x44(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: readmapping[P]alfalfa/src/mapper.cpp
// Function: hasUnique(lis_t const&, kbtree_qCov_t*)
bool hasUnique(const lis_t & lis, kbtree_t(qCov) *tree){
    const vector<match_t> & seeds = lis.matches;
    bool unique = false;
    for(size_t i = 0; i < seeds.size(); i++){
        q_cov_t seed;
        seed.q = seeds[i].query;
        seed.l = seeds[i].len;
        if (kb_size(tree)) {
            q_cov_t *lower, *upper;
            kb_interval(qCov, tree, seed, &lower, &upper); // find the closest read pos that is already covered
            if(!lower || lower->q+lower->l < seed.q+seed.l){
                if(lower && lower->q == seed.q) kb_del(qCov, tree, *lower);
                kb_put(qCov, tree, seed);
                unique = true;
            }
        }
        else{
            kb_put(qCov, tree, seed);
            unique = true;
        }
    }
    return unique;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x90(%rsp)
movb $0x0, 0x8f(%rsp)
movq $0x0, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x90(%rsp), %rdi
callq 0x23440
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x4197a
movq 0x90(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x4c8f0
movslq 0x8(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x90(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x4c8f0
movslq 0xc(%rax), %rax
movq %rax, 0x78(%rsp)
movq 0x98(%rsp), %rax
cmpl $0x0, 0x20(%rax)
je 0x4192c
movq 0x98(%rsp), %rdi
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
leaq 0x68(%rsp), %rcx
leaq 0x60(%rsp), %r8
callq 0x41990
cmpq $0x0, 0x68(%rsp)
je 0x418a9
movq 0x68(%rsp), %rax
movq (%rax), %rax
movq 0x68(%rsp), %rcx
addq 0x8(%rcx), %rax
movq 0x70(%rsp), %rcx
addq 0x78(%rsp), %rcx
cmpq %rcx, %rax
jge 0x4192a
cmpq $0x0, 0x68(%rsp)
je 0x418f7
movq 0x68(%rsp), %rax
movq (%rax), %rax
cmpq 0x70(%rsp), %rax
jne 0x418f7
movq 0x98(%rsp), %rdi
movq 0x68(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x40(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x419d0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x98(%rsp), %rdi
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x41a10
movb $0x1, 0x8f(%rsp)
jmp 0x4195f
movq 0x98(%rsp), %rdi
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x41a10
movb $0x1, 0x8f(%rsp)
jmp 0x41961
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0x417cf
movb 0x8f(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopl (%rax,%rax)
// File: readmapping[P]alfalfa/src/mapper.cpp
// Function: filterLISwithAlignments(read_t&, std::vector<lis_t, std::allocator<lis_t>>&)
void filterLISwithAlignments(read_t & read, vector<lis_t> & lisIntervals){
    for(size_t i = 0; i < read.alignments.size(); i++){
        alignment_t * a = read.alignments[i];
        vector< lis_t >::iterator it = lisIntervals.begin();
        while(it != lisIntervals.end()) {
            //If alignment overlaps with LIS
            if(a->flag.test(4) != it->fw && a->refE >= it->refBegin && a->refB <= it->refEnd) 
                it = lisIntervals.erase(it);
            else 
                ++it;
        }
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rdi
addq $0xb0, %rdi
callq 0xdac0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x429bb
movq 0x60(%rsp), %rdi
addq $0xb0, %rdi
movq 0x50(%rsp), %rsi
callq 0xdae0
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rdi
callq 0x4e290
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
callq 0x4e300
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4e2c0
testb $0x1, %al
jne 0x428d7
jmp 0x429a6
movq 0x48(%rsp), %rdi
addq $0x40, %rdi
movl $0x4, %esi
callq 0xe340
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x1c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4e330
movq %rax, %rcx
movl 0x1c(%rsp), %eax
movb 0x4(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x42997
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4e330
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq 0x8(%rcx), %rax
jl 0x42997
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4e330
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq 0x10(%rcx), %rax
jg 0x42997
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x4e3b0
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x4e340
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x429a1
leaq 0x40(%rsp), %rdi
callq 0x4e3f0
jmp 0x428b0
jmp 0x429a8
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x42857
addq $0x68, %rsp
retq
// File: readmapping[P]alfalfa/src/mapper.cpp
// Function: unpairedCopy(alignment_t const*)
alignment_t * unpairedCopy(const alignment_t * a){
  alignment_t * newAln = new alignment_t();
  newAln->refB = a->refB;
  newAln->refE = a->refE;
  newAln->qB = a->qB;
  newAln->qE = a->qE;
  newAln->pos = a->pos;
  newAln->rname = a->rname;
  newAln->refLength = a->refLength;
  newAln->alignmentScore = a->alignmentScore;
  newAln->flag.set(4, a->flag.test(4));
  for(size_t i = 0; i < a->chain.size(); i++)
      newAln->chain.push_back(a->chain[i]);
  return newAln;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl $0x100, %edi            # imm = 0x100
callq 0x8380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x4dd90
jmp 0x43955
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x40(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x40(%rsp), %rax
movl 0x14(%rax), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x40(%rsp), %rsi
addq $0x48, %rsi
movq 0x38(%rsp), %rdi
addq $0x48, %rdi
callq 0x8060
movq 0x40(%rsp), %rax
movl 0x98(%rax), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x98(%rax)
movq 0x40(%rsp), %rax
movl 0x70(%rax), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x70(%rax)
movq 0x38(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
addq $0x40, %rdi
movl $0x4, %esi
callq 0xe340
movq 0x10(%rsp), %rdi
movzbl %al, %edx
andl $0x1, %edx
movl $0x4, %esi
callq 0xe640
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
addq $0xe8, %rdi
callq 0x23440
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x43ab7
movq 0x38(%rsp), %rax
addq $0xe8, %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
addq $0xe8, %rdi
movq 0x20(%rsp), %rsi
callq 0x4c8f0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x4c670
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x43a2f
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x100, %esi            # imm = 0x100
callq 0x8390
jmp 0x43ac1
movq 0x38(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x8730
nopl (%rax,%rax)
// File: readmapping[P]alfalfa/src/mapper.cpp
// Function: setPaired(alignment_t*, alignment_t*, bool)
void setPaired(alignment_t* mate1, alignment_t* mate2, bool concordant){
    assert(!mate1->flag.test(0));
    assert(!mate2->flag.test(0));
    mate1->flag.set(0, true);
    mate2->flag.set(0, true);
    mate1->setMate(mate2, concordant, true);
    mate2->setMate(mate1, concordant, false);
}

// Assembly:
subq $0x18, %rsp
movb %dl, %al
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
andb $0x1, %al
movb %al, 0x7(%rsp)
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0xe640
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0xe640
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movb 0x7(%rsp), %al
movl $0x1, %ecx
andb $0x1, %al
movzbl %al, %edx
callq 0x3c270
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movb 0x7(%rsp), %al
xorl %ecx, %ecx
andb $0x1, %al
movzbl %al, %edx
callq 0x3c270
addq $0x18, %rsp
retq
// File: readmapping[P]alfalfa/src/mapper.cpp
// Function: setPaired(sparseSA const&, read_t&, read_t&, int, int, bool)
void setPaired(const sparseSA& sa, read_t & mate1, read_t & mate2, int i, int j, bool concordant){
    mate1.alignments[i]->setLocalPos(sa);
    mate2.alignments[j]->setLocalPos(sa);
    int mate1index = i;
    int mate2index = j;
    if(mate1.alignments[mate1index]->paired()){
        alignment_t * newAln = unpairedCopy(mate1.alignments[mate1index]);
        mate1.alignments.push_back(newAln);
        mate1index = mate1.alignments.size()-1;
    }
    if(mate2.alignments[mate2index]->paired()){
        alignment_t * newAln = unpairedCopy(mate2.alignments[mate2index]);
        mate2.alignments.push_back(newAln);
        mate2index = mate2.alignments.size()-1;
    }
    mate1.pairedAlignmentCount++;
    mate2.pairedAlignmentCount++;
    setPaired(mate1.alignments[mate1index], mate2.alignments[mate2index], concordant);
}

// Assembly:
subq $0x48, %rsp
movb %r9b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movl %r8d, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x38(%rsp), %rdi
addq $0xb0, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xdae0
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
callq 0x4c2d0
movq 0x30(%rsp), %rdi
addq $0xb0, %rdi
movslq 0x28(%rsp), %rsi
callq 0xdae0
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
callq 0x4c2d0
movl 0x2c(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
addq $0xb0, %rdi
movslq 0x20(%rsp), %rsi
callq 0xdae0
movq (%rax), %rdi
callq 0xe470
testb $0x1, %al
jne 0x43bef
jmp 0x43c41
movq 0x38(%rsp), %rdi
addq $0xb0, %rdi
movslq 0x20(%rsp), %rsi
callq 0xdae0
movq (%rax), %rdi
callq 0x43930
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
addq $0xb0, %rdi
leaq 0x10(%rsp), %rsi
callq 0x4dfc0
movq 0x38(%rsp), %rdi
addq $0xb0, %rdi
callq 0xdac0
subq $0x1, %rax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
addq $0xb0, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xdae0
movq (%rax), %rdi
callq 0xe470
testb $0x1, %al
jne 0x43c65
jmp 0x43cb7
movq 0x30(%rsp), %rdi
addq $0xb0, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xdae0
movq (%rax), %rdi
callq 0x43930
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
addq $0xb0, %rdi
leaq 0x8(%rsp), %rsi
callq 0x4dfc0
movq 0x30(%rsp), %rdi
addq $0xb0, %rdi
callq 0xdac0
subq $0x1, %rax
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rax
movl 0xc8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc8(%rax)
movq 0x30(%rsp), %rax
movl 0xc8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc8(%rax)
movq 0x38(%rsp), %rdi
addq $0xb0, %rdi
movslq 0x20(%rsp), %rsi
callq 0xdae0
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
addq $0xb0, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xdae0
movq (%rsp), %rdi
movq (%rax), %rsi
movb 0x27(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x43ad0
addq $0x48, %rsp
retq
nopl (%rax)
// File: readmapping[P]alfalfa/src/mapper.cpp
// Function: bestAlignmentInWindow(read_t const&, std::vector<alnScoreInfo_t, std::allocator<alnScoreInfo_t>> const&, bool, long, long, bool)
int bestAlignmentInWindow(const read_t & mate, const vector<alnScoreInfo_t> & mateAlns, 
        bool firstMate, long refB, long refE, bool fw){
    int bestAln = -1;
    int bestAlnScore = -1*mate.sequence.size();
    for(size_t i = 0; i < mateAlns.size(); i++){
        if(firstMate != mateAlns[i].firstMate){
            alignment_t * mateAln = mate.alignments[mateAlns[i].position];
            if(mateAln->refB >= refB && mateAln->refE <= refE && mateAln->flag.test(4) != fw && mateAln->alignmentScore > bestAlnScore){
                bestAln = mateAlns[i].position;
                bestAlnScore = mateAln->alignmentScore;
            }
        }
    }
    return bestAln;
}

// Assembly:
subq $0x68, %rsp
movb %r9b, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
andb $0x1, %dl
movb %dl, 0x57(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
andb $0x1, %al
movb %al, 0x3f(%rsp)
movl $0xffffffff, 0x38(%rsp) # imm = 0xFFFFFFFF
movq 0x60(%rsp), %rdi
addq $0x20, %rdi
callq 0x8250
imulq $-0x1, %rax, %rax
movl %eax, 0x34(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
callq 0x4e5b0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x44358
movb 0x57(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x4e5d0
movq %rax, %rcx
movl 0x14(%rsp), %eax
movb (%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x44343
movq 0x60(%rsp), %rax
addq $0xb0, %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x4e5d0
movq 0x8(%rsp), %rdi
movslq 0x4(%rax), %rsi
callq 0x4e5f0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpq 0x48(%rsp), %rax
jl 0x44341
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x40(%rsp), %rax
jg 0x44341
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
movl $0x4, %esi
callq 0xe340
andb $0x1, %al
movzbl %al, %eax
movb 0x3f(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x44341
movq 0x20(%rsp), %rax
movl 0x70(%rax), %eax
cmpl 0x34(%rsp), %eax
jle 0x44341
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x4e5d0
movl 0x4(%rax), %eax
movl %eax, 0x38(%rsp)
movq 0x20(%rsp), %rax
movl 0x70(%rax), %eax
movl %eax, 0x34(%rsp)
jmp 0x44343
jmp 0x44345
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x4423f
movl 0x38(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/mapper.cpp
// Function: pairedMatch(sparseSA const&, read_t&, read_t&, align_opt const&, paired_opt const&)
void pairedMatch(const sparseSA& sa, read_t & mate1, read_t & mate2, const align_opt & alnOptions, const paired_opt & pairedOpt){
    if(pairedOpt.mode==1){
        pairedMatch1(sa, mate1, mate2, alnOptions, pairedOpt);
    }
    else if(pairedOpt.mode==2){
        pairedMatch2(sa, mate1, mate2, alnOptions, pairedOpt);
    }
    else if(pairedOpt.mode==3){
        pairedMatch3(sa, mate1, mate2, alnOptions, pairedOpt);
    }
    else if(pairedOpt.mode==4){
        pairedMatch4(sa, mate1, mate2, alnOptions, pairedOpt);
    }
    else if(pairedOpt.mode==5){
        pairedMatch5(sa, mate1, mate2, alnOptions, pairedOpt);
    }
    else if(pairedOpt.mode==6){
        pairedMatch6(sa, mate1, mate2, alnOptions, pairedOpt);
    }
    else{
        pairedMatch1(sa, mate1, mate2, alnOptions, pairedOpt);
    }      
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movq (%rsp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x4a878
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq 0x45380
jmp 0x4a972
movq (%rsp), %rax
cmpl $0x2, 0x10(%rax)
jne 0x4a8a4
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq 0x49d10
jmp 0x4a970
movq (%rsp), %rax
cmpl $0x3, 0x10(%rax)
jne 0x4a8d0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq 0x46210
jmp 0x4a96e
movq (%rsp), %rax
cmpl $0x4, 0x10(%rax)
jne 0x4a8f9
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq 0x47d40
jmp 0x4a96c
movq (%rsp), %rax
cmpl $0x5, 0x10(%rax)
jne 0x4a922
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq 0x48ee0
jmp 0x4a96a
movq (%rsp), %rax
cmpl $0x6, 0x10(%rax)
jne 0x4a94b
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq 0x47370
jmp 0x4a968
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
callq 0x45380
jmp 0x4a96a
jmp 0x4a96c
jmp 0x4a96e
jmp 0x4a970
jmp 0x4a972
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: readmapping[P]alfalfa/src/mapper.h
// Function: alignment_t::setLocalPos(sparseSA const&)
void setLocalPos(const sparseSA& sa){
    if(rname.empty() || rname == "*"){
        long descIndex;
        refB++;
        sa.from_set(refB, descIndex, pos);
        refB--;
        rname = sa.descr[descIndex];
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x48, %rdi
callq 0x86e0
testb $0x1, %al
jne 0x4c310
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
leaq 0x2cd4d(%rip), %rsi     # 0x79052
callq 0x51d10
testb $0x1, %al
jne 0x4c310
jmp 0x4c364
movq 0x8(%rsp), %rcx
movq (%rcx), %rax
addq $0x1, %rax
movq %rax, (%rcx)
movq 0x18(%rsp), %rdi
movq (%rcx), %rsi
addq $0x18, %rcx
leaq 0x10(%rsp), %rdx
callq 0x51d40
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x51e20
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq $0x48, %rdi
callq 0x8060
addq $0x28, %rsp
retq
nopl (%rax)
// File: readmapping[P]alfalfa/src/mapper.cpp
// Function: executeSeedType(sparseSA const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, mum_t, int, int, std::vector<match_t, std::allocator<match_t>>&, int)
inline void executeSeedType(const sparseSA& sa, const string& P, int min_len, mum_t memType, int maxBranchWidth, int sparseSkip, vector<match_t>& matches, int maxSmemMemStart){
    if(memType == SMAM)
        sa.SMAM(P, matches, min_len, maxBranchWidth, sparseSkip);
    else if(memType == SMEM)
        sa.SMEM(P, matches, min_len, maxBranchWidth, sparseSkip, maxSmemMemStart);
    else if(memType == MEM)
        sa.MEM(P, matches, min_len, maxBranchWidth, sparseSkip);
    else if(memType == SMEMP)
        sa.SMEMP(P, matches, min_len, maxBranchWidth, sparseSkip, maxSmemMemStart);
}

// Assembly:
subq $0x28, %rsp
movl 0x38(%rsp), %eax
movq 0x30(%rsp), %rax
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movl %r9d, 0x8(%rsp)
cmpl $0x4, 0x10(%rsp)
jne 0x4c417
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
callq 0x1cd80
jmp 0x4c4aa
cmpl $0x3, 0x10(%rsp)
jne 0x4c449
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
movl 0x38(%rsp), %eax
movl %eax, (%rsp)
callq 0x1ce20
jmp 0x4c4a8
cmpl $0x2, 0x10(%rsp)
jne 0x4c474
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
callq 0x1cce0
jmp 0x4c4a6
cmpl $0x5, 0x10(%rsp)
jne 0x4c4a4
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
movl 0x38(%rsp), %eax
movl %eax, (%rsp)
callq 0x1db10
jmp 0x4c4a6
jmp 0x4c4a8
jmp 0x4c4aa
addq $0x28, %rsp
retq
nop
// File: readmapping[P]alfalfa/src/sparseSA.h
// Function: sparseSA::getChromBounds(long, long&, long&) const
void getChromBounds(const long hit, long& chrStart, long& chrEnd) const{
    long seq, seqpos;
    from_set(hit, seq, seqpos);
    chrStart = startpos[seq];
    if(startpos.size() > 1 && seq < (long)(startpos.size() - 1))
        chrEnd = startpos[seq+1] - 1; // Minus one for the separation character
    else
        chrEnd =  N - 1; // Minus one for the separation character
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x51d40
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movq 0x20(%rsp), %rsi
callq 0x52c70
movq 0x10(%rsp), %rdi
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rdi
callq 0x1f490
cmpq $0x1, %rax
jbe 0x4e269
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
callq 0x1f490
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x4e269
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movq 0x20(%rsp), %rsi
addq $0x1, %rsi
callq 0x52c70
movq (%rax), %rcx
subq $0x1, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x4e27e
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rcx
subq $0x1, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: readmapping[P]alfalfa/src/sparseSA.h
// Function: sparseSA::from_set(long, long&, long&) const
void from_set(long hit, long &seq, long &seqpos) const{
    // Use binary search to locate index of sequence and position
    // within sequence.
    std::vector<long>::const_iterator it = std::upper_bound(startpos.begin(), startpos.end(), hit);
    seq = std::distance(startpos.begin(), it) - 1;
    it--;
    seqpos = hit - *it;
  }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
callq 0x51ea0
movq 0x8(%rsp), %rdi
movq %rax, 0x38(%rsp)
addq $0x18, %rdi
callq 0x51ed0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x51e40
movq 0x8(%rsp), %rdi
movq %rax, 0x40(%rsp)
addq $0x18, %rdi
callq 0x51ea0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x51f00
movq %rax, %rcx
subq $0x1, %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x51f40
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x51f80
movq 0x10(%rsp), %rcx
subq (%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: readmapping[P]alfalfa/src/mapper.cpp
// Function: bestLISInWindow(std::vector<lis_t, std::allocator<lis_t>>&, int, long, long, bool)
inline int bestLISInWindow(vector<lis_t> & lisIntervalsWindow, int editDist, long refB, long refE, bool fw){
    int bestAln = -1;
    int bestAlnScore = -10000;//set to INT_MIN
    for(size_t i = 0; i < lisIntervalsWindow.size(); i++){
        if(lisIntervalsWindow[i].refBegin+editDist >= refB && 
                lisIntervalsWindow[i].refEnd-editDist <= refE && 
                lisIntervalsWindow[i].fw == fw && lisIntervalsWindow[i].score > bestAlnScore){
            bestAln = i;
            bestAlnScore = lisIntervalsWindow[i].score;
        }
    }
    return bestAln;
}

// Assembly:
subq $0x48, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
movl $0xffffd8f0, 0x1c(%rsp) # imm = 0xFFFFD8F0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4c4b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x53a71
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4c850
movq 0x8(%rax), %rax
movslq 0x3c(%rsp), %rcx
addq %rcx, %rax
cmpq 0x30(%rsp), %rax
jl 0x53a5c
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4c850
movq 0x10(%rax), %rax
movslq 0x3c(%rsp), %rcx
subq %rcx, %rax
cmpq 0x28(%rsp), %rax
jg 0x53a5c
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4c850
movb 0x4(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x27(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x53a5c
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4c850
movl (%rax), %eax
cmpl 0x1c(%rsp), %eax
jle 0x53a5c
movq 0x10(%rsp), %rax
movl %eax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4c850
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
jmp 0x53a5e
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x53999
movl 0x20(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: readmapping[P]alfalfa/src/performanceUtils.cpp
// Function: oracleLine_t::addAlignment(int)
void oracleLine_t::addAlignment(int score){
    tempReadResult = max(tempReadResult, score);
    alignmentCnt++;
    if(score == 2)
        alnGood++;
    else if(score == 1)
        alnOk++;
    else
        alnBad++;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x38, %rdi
leaq 0xc(%rsp), %rsi
callq 0x14d40
movq %rax, %rcx
movq (%rsp), %rax
movl (%rcx), %ecx
movl %ecx, 0x38(%rax)
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
cmpl $0x2, 0xc(%rsp)
jne 0x63d43
movq (%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x63d6e
cmpl $0x1, 0xc(%rsp)
jne 0x63d5c
movq (%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x63d6c
movq (%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x63d6e
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/performanceUtils.cpp
// Function: oracleLine_t::finishRead()
void oracleLine_t::finishRead(){
    if(tempReadResult==2)
        readGood++;
    else if(tempReadResult ==1)
        readOk++;
    else
        readBad++;
    tempReadResult = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
cmpl $0x2, 0x38(%rax)
jne 0x63da8
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0x63dd9
movq -0x10(%rsp), %rax
cmpl $0x1, 0x38(%rax)
jne 0x63dc6
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x63dd7
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0x63dd9
movq -0x10(%rsp), %rax
movl $0x0, 0x38(%rax)
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/performanceUtils.cpp
// Function: summaryLine_t::addAlignment(int, bool)
void summaryLine_t::addAlignment(int flag, bool mateFound){
    int score = 0;
    //set fields
    tempAlnCount++;
    alignmentCnt++;
    if(!(flag & (1<<2))){
        mappedAln++;
        score++;
        if(mateFound){
            mappedPaired++;
            score++;
            if(flag & (1<<1)){
                mappedPairedCorrect++;
                score++;
            }
        }
        if(flag & (1<<8)){
            secondAln++;
        }
    }
    tempReadResult = max(tempReadResult, score);
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
andb $0x1, %al
movb %al, 0x1b(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x1dc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1dc(%rax)
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
movl 0x1c(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x643bc
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
testb $0x1, 0x1b(%rsp)
je 0x6439b
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x64399
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6439b
movl 0x1c(%rsp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x643ba
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x643bc
movq 0x8(%rsp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
leaq 0x14(%rsp), %rsi
callq 0x14d40
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl (%rcx), %ecx
movl %ecx, 0x1d8(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: readmapping[P]alfalfa/src/performanceUtils.cpp
// Function: summaryLine_t::finishRead()
void summaryLine_t::finishRead(){
    if(tempReadResult==3)
        readPairedCorrect++;
    else if(tempReadResult ==2)
        readPaired++;
    else if(tempReadResult ==1)
        readMapped++;
    tempReadResult = 0;
    alnPerRead[min(tempAlnCount,101)]++;
    tempAlnCount = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x3, 0x1d8(%rax)
jne 0x6441d
movq (%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x6445b
movq (%rsp), %rax
cmpl $0x2, 0x1d8(%rax)
jne 0x6443c
movq (%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x64459
movq (%rsp), %rax
cmpl $0x1, 0x1d8(%rax)
jne 0x64457
movq (%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x64459
jmp 0x6445b
movq (%rsp), %rdi
movl $0x0, 0x1d8(%rdi)
addq $0x1dc, %rdi            # imm = 0x1DC
movl $0x65, 0xc(%rsp)
leaq 0xc(%rsp), %rsi
callq 0xc080
movq %rax, %rcx
movq (%rsp), %rax
movslq (%rcx), %rcx
movl 0x40(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x40(%rax,%rcx,4)
movl $0x0, 0x1dc(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/performanceUtils.cpp
// Function: nextField(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, int&)
string nextField(const string & line, char delimeter, int& beginPos){
    int tabPos = line.find(delimeter,beginPos);
    string substring = line.substr(beginPos, tabPos-beginPos);
    beginPos = tabPos+1;
    return substring;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, (%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movb 0x27(%rsp), %al
movq 0x18(%rsp), %rcx
movslq (%rcx), %rdx
movsbl %al, %esi
callq 0x8540
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rsp)
movb $0x0, 0x13(%rsp)
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rax
movslq (%rax), %rdx
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
subl (%rcx), %eax
movslq %eax, %rcx
callq 0x83a0
movl 0x14(%rsp), %ecx
addl $0x1, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, 0x13(%rsp)
testb $0x1, 0x13(%rsp)
jne 0x66ef0
movq 0x8(%rsp), %rdi
callq 0x8858
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: readmapping[P]alfalfa/src/performanceUtils.cpp
// Function: previousField(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char, int&)
string previousField(string & line, char delimeter, int& endPos){
    int tabPos = line.rfind(delimeter,endPos);
    string substring = line.substr(tabPos+1, endPos-tabPos);
    endPos = tabPos-1;
    return substring;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, (%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movb 0x27(%rsp), %al
movq 0x18(%rsp), %rcx
movslq (%rcx), %rdx
movsbl %al, %esi
callq 0x8810
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rsp)
movb $0x0, 0x13(%rsp)
movq 0x28(%rsp), %rsi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movq 0x18(%rsp), %rax
movl (%rax), %eax
subl 0x14(%rsp), %eax
movslq %eax, %rcx
callq 0x83a0
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, 0x13(%rsp)
testb $0x1, 0x13(%rsp)
jne 0x66f92
movq 0x8(%rsp), %rdi
callq 0x8858
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: readmapping[P]alfalfa/src/performanceUtils.cpp
// Function: getlijn2(std::basic_ifstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void getlijn2(ifstream & input, string & lijn){
    //write windows version of getline
    getline(input, lijn, '\n'); // Load one line at a time.
    if(lijn.length() > 0 && lijn[lijn.length()-1]=='\r')
        lijn.erase(--lijn.end());
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl $0xa, %edx
callq 0x87c0
movq 0x28(%rsp), %rdi
callq 0x8630
cmpq $0x0, %rax
jbe 0x67041
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x8630
movq 0x8(%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x8830
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x67041
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x81e0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xe220
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x31320
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x84c0
movq %rax, 0x10(%rsp)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/performanceUtils.cpp
// Function: unpairedCompareSam(samRecord_t&, samRecord_t&, int)
int unpairedCompareSam(samRecord_t& query, samRecord_t& oracle, int range){
    //correct if within X bases of origin
    if(query.flag.test(2)){
        return 0;//unmapped
    }
    if(query.flag.test(4)==oracle.flag.test(4) && 
            query.rname.compare(oracle.rname)==0 && 
            query.pos >= oracle.pos-range && query.pos <= oracle.pos + range){
        return 2;
    }
    else if(query.edit <= oracle.edit){
        return 1;
    }
    //ok if edit distance is fine
    else{
        return 0;
    }
    //else incorrect
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
movl $0x2, %esi
callq 0xe340
testb $0x1, %al
jne 0x6770b
jmp 0x67718
movl $0x0, 0x24(%rsp)
jmp 0x677e5
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
movl $0x4, %esi
callq 0xe340
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movl $0x4, %esi
callq 0xe340
movb %al, %cl
movl 0x8(%rsp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x677bb
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
callq 0x8050
cmpl $0x0, %eax
jne 0x677bb
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x48(%rcx), %rcx
movslq 0xc(%rsp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jl 0x677bb
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x48(%rcx), %rcx
movslq 0xc(%rsp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jg 0x677bb
movl $0x2, 0x24(%rsp)
jmp 0x677e5
movq 0x18(%rsp), %rax
movl 0x80(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x80(%rcx), %eax
jg 0x677dd
movl $0x1, 0x24(%rsp)
jmp 0x677e5
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: readmapping[P]alfalfa/src/performanceUtils.cpp
// Function: pairedCompareSam(samRecord_t&, samRecord_t&, int)
int pairedCompareSam(samRecord_t& query, samRecord_t& oracle, int range){
    //correct if within X bases of origin
    if(query.flag.test(2)){
        return 0;//unmapped
    }
    if((query.flag.to_ulong() % 128) == (oracle.flag.to_ulong() % 128) &&
            query.rname.compare(oracle.rname)==0 && 
            query.pos >= oracle.pos-range && query.pos <= oracle.pos + range && 
            query.rnext.compare(oracle.rnext) == 0 ){// && query.pnext >= oracle.pnext-range && query.pnext <= oracle.pnext+range
        return 2;
    }
    else if(query.edit <= oracle.edit){
        return 1;
    }
    //ok if edit distance is fine
    else{
        return 0;
    }
    //else incorrect
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
movl $0x2, %esi
callq 0xe340
testb $0x1, %al
jne 0x6781b
jmp 0x67828
movl $0x0, 0x24(%rsp)
jmp 0x6790a
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0xe330
andq $0x7f, %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0xe330
movq %rax, %rcx
movq (%rsp), %rax
andq $0x7f, %rcx
cmpq %rcx, %rax
jne 0x678e0
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
callq 0x8050
cmpl $0x0, %eax
jne 0x678e0
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x48(%rcx), %rcx
movslq 0xc(%rsp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jl 0x678e0
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x48(%rcx), %rcx
movslq 0xc(%rsp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jg 0x678e0
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movq 0x10(%rsp), %rsi
addq $0x58, %rsi
callq 0x8050
cmpl $0x0, %eax
jne 0x678e0
movl $0x2, 0x24(%rsp)
jmp 0x6790a
movq 0x18(%rsp), %rax
movl 0x80(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x80(%rcx), %eax
jg 0x67902
movl $0x1, 0x24(%rsp)
jmp 0x6790a
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)