// File: millanek[P]evo/evo_findDiscordantPairs.cpp
// Function: DiscordPairsMain(int, char**)
int DiscordPairsMain(int argc, char** argv) {
    parseDiscordPairsOptions(argc, argv);
    string line; // for reading the input files
    
    std::istream* hetsFile = createReader(opt::hetsFile.c_str());
    std::ifstream* pairtoolsFile = new std::ifstream(opt::pairtoolsFile.c_str());
    std::ifstream* samFile = new std::ifstream(opt::samFile.c_str());
    
    std::ofstream* phaseSwitchFile = new std::ofstream("switches" + opt::runName + ".txt");
    std::ofstream* goodReadPairsFile = new std::ofstream("goodReadPairs" + opt::runName + ".txt");
    
    std::map<int,PhaseInfo*> positionToPhase;
    std::map<string,std::vector<int>> infoPairNameToPos;
    std::map<string,std::vector<string>> infoPairNameToStrands;
    
    std::map<string,std::vector<RecombRead*>> samNameToReads;
    int numHetPairs = 0;
    std::unordered_map<string, ReadLinkSNPpair*> SNPpairs;
    
    if (opt::hapcutFormat) {
        int blockNum = 0;
        // Parse the Hapcut blocks file
        while (getline(*hetsFile, line)) {
            if (line[0] == '*') {
            
            } else if (line[0] == 'B' && line[1] == 'L') { // New block - should in the future separate the hets by blocks
                blockNum++;
            } else {
                std::vector<string> phasedSNPdetails = split(line, '\t');
                int snpPos = atoi(phasedSNPdetails[4].c_str());
                int H1phase = atoi(phasedSNPdetails[1].c_str());
                int H2phase = atoi(phasedSNPdetails[2].c_str());
                //std::cout << "line: " << line << std::endl;
                // std::cout << "phasedSNPdetails[5]: " << phasedSNPdetails[5] << std::endl;
                assert(phasedSNPdetails[5].length() == 1); assert(phasedSNPdetails[6].length() == 1);
                char refBase = phasedSNPdetails[5][0];
                char altBase = phasedSNPdetails[6][0];
                double phaseQual = stringToDouble(phasedSNPdetails[10].c_str());
                int snpCoverage = atoi(phasedSNPdetails[11].c_str());
                std::vector<char> phasedVars;
                if (H1phase == 0 && H2phase == 1) {
                    phasedVars.push_back(refBase); phasedVars.push_back(altBase);
                } else if (H1phase == 1 && H2phase == 0) {
                    phasedVars.push_back(altBase); phasedVars.push_back(refBase);
                } else{
                    continue;
                }
                PhaseInfo* thisPhase = new PhaseInfo(snpPos,phaseQual,snpCoverage, phasedVars,blockNum);
                positionToPhase[snpPos] = thisPhase;
            }
        }
    } else {
        while (getline(*hetsFile, line)) {
            std::vector<string> phasedSNPdetails = split(line, '\t');
            int snpPos = atoi(phasedSNPdetails[1].c_str());
            assert(phasedSNPdetails[2].length() == 1); assert(phasedSNPdetails[3].length() == 1);
            char refBase = phasedSNPdetails[2][0];
            char altBase = phasedSNPdetails[3][0];
            
            std::vector<char> phasedVars;
            phasedVars.push_back(refBase); phasedVars.push_back(altBase);
            double phaseQual = 0; int snpCoverage = 0;
            PhaseInfo* thisPhase = new PhaseInfo(snpPos,phaseQual,snpCoverage, phasedVars,1);
            positionToPhase[snpPos] = thisPhase;
        }
        numHetPairs = nChoosek((int)positionToPhase.size(),2);
    }
    
    
    
    // Now parse the pairtools file to record the exact readpairs
    while (getline(*pairtoolsFile,line)) {
        // std::cerr << line << std::endl;
        std::vector<string> pairVec = split(line, '\t'); assert(pairVec.size() == 8);
        
        string pairName = pairVec[0];
        int pair1pos = atoi(pairVec[2].c_str());
        int pair2pos = atoi(pairVec[4].c_str());
        std::vector<int> bothPos; bothPos.push_back(pair1pos); bothPos.push_back(pair2pos);
        infoPairNameToPos[pairName] = bothPos;
        
        string pair1strand = pairVec[5];
        string pair2strand = pairVec[6];
        std::vector<string> bothStrands; bothStrands.push_back(pair1strand); bothStrands.push_back(pair1strand);
        infoPairNameToStrands[pairName] = bothStrands;
    }
    
    
    // Now parse the samtools file to find reads that match records from the pairstools file
    // and therefore  can be informative about the phasing and recombination
    while (getline(*samFile,line)) {
        // std::cerr << line << std::endl;
        std::vector<string> samRecVec = split(line, '\t'); //assert(pairVec.size() == 8);
        int flag = atoi(samRecVec[1].c_str());
        if (flag > 2000) continue;
        
        RecombRead* thisRead = new RecombRead(samRecVec);
        
        int CIGARlengthTotal = vector_sum(thisRead->GIGARnumsNoSI);
        //std::cout << "thisRead->CIGAR: " << thisRead->CIGAR << std::endl;
        // print_vector(thisRead->GIGARnums, std::cout);
        //std::cout << "CIGARlengthTotal: " << CIGARlengthTotal << std::endl;
        
        
        int adjusted5pReadPos;
        if (thisRead->readStrand == "-") {
            adjusted5pReadPos = thisRead->readPos + CIGARlengthTotal - 1;
        } else {
            adjusted5pReadPos = thisRead->readPos;
        }
        thisRead->adjustedReadPos = adjusted5pReadPos;
        
        string readSeq; string readQual;
        if(infoPairNameToPos.count(thisRead->readName) != 1) {
            std::cerr << "Not in info pair file: " << thisRead->readName << std::endl;
        } else {
            if (thisRead->MQ > opt::minMQ) {
                std::vector<int> pairPosVec = infoPairNameToPos.at(thisRead->readName);
                if (adjusted5pReadPos == pairPosVec[0] || adjusted5pReadPos == pairPosVec[1]) {
                    samNameToReads[thisRead->readName].push_back(thisRead);
                   // std::cout << "Good" << std::endl;
                } else {
                   /* std::cout << "Bad" << "\t" << adjusted5pReadPos << "\t" << pairPosVec[0] << "\t" << pairPosVec[1] << std::endl;
                    std::cout << "CIGAR: " << thisRead->CIGAR << std::endl;
                    print_vector(thisRead->GIGARnums, std::cout);
                    std::cout << "CIGARlengthTotal: " << CIGARlengthTotal << std::endl;
                    std::cout << "readStrand: " << thisRead->readStrand << std::endl; */
                }
            }
        }
    }
    
    int goodPairs = 0;
    std::vector<RecombReadPair*> goodReadPairs; goodReadPairs.reserve(samNameToReads.size());
    for (std::map<string,std::vector<RecombRead*>>::iterator it = samNameToReads.begin(); it != samNameToReads.end(); it++) {
        if (it->second.size() == 2) {
            goodPairs++;
            RecombReadPair* thisReadPair = new RecombReadPair(it->second[0], it->second[1]);
            goodReadPairs.push_back(thisReadPair);
        } else {
            // std::cout << "it->second.size(): " << it->second.size() << std::endl;
        }
    }
    std::sort(goodReadPairs.begin(), goodReadPairs.end());
    
    
    
    int numConcordant = 0; int numDiscordant = 0;
    int numMatch = 0; int numMismatch = 0;
    std::vector<double> matchBaseScores; std::vector<double> mismatchBaseScores;
    std::vector<double> concordantBaseScores; std::vector<double> discordantBaseScores;
    std::vector<PhaseSwitch*> phaseSwitches;
    
    int numFullLenghtReadPairs = 0;
    int totalUsedLength = 0;
    std::vector<int> numHets;
    int num0het = 0; int num1het = 0; int num2plusHets = 0;
    
    for (int r = 0; r < goodReadPairs.size(); r++) {
        
        goodReadPairs[r]->findAndCombinePairHets(positionToPhase);
        goodReadPairs[r]->filterHetsByQuality(opt::minBQ);
        
        if (goodReadPairs[r]->hetSites.size() == 0) {
            num0het++;
           /* std::cout << "goodReadPairs[r]->hetSites.size(): " << goodReadPairs[r]->hetSites.size() << std::endl;
            std::cout << "goodReadPairs[r]->read1->readPos: " << goodReadPairs[r]->read1->readPos << std::endl;
            std::cout << "goodReadPairs[r]->read1->readStrand: " << goodReadPairs[r]->read1->readStrand << std::endl;
            std::cout << "goodReadPairs[r]->read1->usedLength: " << goodReadPairs[r]->read1->usedLength << std::endl;
            std::cout << "goodReadPairs[r]->read1->adjustedReadPos: " << goodReadPairs[r]->read1->adjustedReadPos << std::endl;
            std::cout << "goodReadPairs[r]->read1->CIGAR: " << goodReadPairs[r]->read1->CIGAR << std::endl;
            std::cout << "goodReadPairs[r]->read2->readPos: " << goodReadPairs[r]->read2->readPos << std::endl;
            std::cout << "goodReadPairs[r]->read2->readStrand: " << goodReadPairs[r]->read2->readStrand << std::endl;
            std::cout << "goodReadPairs[r]->read2->usedLength: " << goodReadPairs[r]->read2->usedLength << std::endl;
            std::cout << "goodReadPairs[r]->read2->adjustedReadPos: " << goodReadPairs[r]->read2->adjustedReadPos << std::endl;
            std::cout << "goodReadPairs[r]->read2->CIGAR: " << goodReadPairs[r]->read2->CIGAR << std::endl;
            std::cout <<  std::endl;
            //std::cout << "goodReadPairs[r]->read2->readStrand: " << goodReadPairs[r]->read1-> << std::endl; */
        } else if (goodReadPairs[r]->hetSites.size() == 1) {
            num1het++;
        } else {
            num2plusHets++;
            if(goodReadPairs[r]->read1->hetSites.size() >= 1 && goodReadPairs[r]->read2->hetSites.size() >= 1) {
                *goodReadPairsFile << goodReadPairs[r]->read1->readPos << "\t" << goodReadPairs[r]->read2->readPos << std::endl;
            }
        }
        
        /* Just debug
         if (goodReadPairs[r]->read1->CIGAR == "151M" && goodReadPairs[r]->read2->CIGAR == "151M") {
            numFullLenghtReadPairs++;
        } */
        
        totalUsedLength = totalUsedLength + goodReadPairs[r]->read1->usedLength;
        totalUsedLength = totalUsedLength + goodReadPairs[r]->read2->usedLength;
        
    }
    
    std::cout << "goodReadPairs.size(): " << goodReadPairs.size() << std::endl;
    std::cout << "num0het: " << num0het << std::endl;
    std::cout << "num1het: " << num1het << std::endl;
    std::cout << "num2plusHets: " << num2plusHets << std::endl;
    
    if (opt::hapcutFormat) {
        
        for (int r = 0; r < goodReadPairs.size(); r++) {
           for (int i = 0; i < goodReadPairs[r]->hetSites.size(); i++) {
                HetInfo* thisHet = goodReadPairs[r]->hetSites[i];
                if (thisHet->readPhaseBaseMismatch) {
                    /*  std::cout << "Bases don't match" << std::endl;
                      std::cout << "sequence: " << thisRead->readSeq << std::endl;
                      std::cout << "readBase: " << thisRead->readSeq[i-1] << "[" << readBase << "]" << thisRead->readSeq[i+1] << std::endl;
                      std::cout << "readQual[i]: " << thisRead->readQual[i] << "; score: " << int(thisRead->readQual[i])-33 << std::endl;
                      std::cout << "readPos: " << thisRead->readPos << std::endl;
                      std::cout << "i: " << i << std::endl;
                      std::cout << "readPos + i: " << thisRead->readPos + i << std::endl;
                      std::cout << "phasedSNPbases[0]: " << phasedSNPbases[0] << std::endl;
                      std::cout << "phasedSNPbases[1]: " << phasedSNPbases[1] << std::endl; */
                    numMismatch++;
                    mismatchBaseScores.push_back(thisHet->thisBaseQuality);
                } else {
                    // std::cout << "Fine: " << std::endl;
                     matchBaseScores.push_back(thisHet->thisBaseQuality);
                     numMatch++;
                }
            }
            
            // Now consider all HiC pairs i that map to the chromosome and cover a het at each end - lets call the physical locations of the hets x_i, y_i ( x < y) and let Z_i = 1 if they are in phase, 0 if out of phase (recombined)
            
            // Prod_i ((1-Z_i)(G(y_i)-G(x_i)) + Z_i*(1 -(G(y_i)-G(x_i))
            
            
            
            if (goodReadPairs[r]->hetSites.size() > 1) {
                int phaseOfPrevious; int posOfPrevious; bool allConcordant = true;
                if (goodReadPairs[r]->hetSites[0]->thisBase == goodReadPairs[r]->hetSites[0]->thisHetPhase0) phaseOfPrevious = 0;
                if (goodReadPairs[r]->hetSites[0]->thisBase == goodReadPairs[r]->hetSites[0]->thisHetPhase1) phaseOfPrevious = 1;
                for (int i = 1; i < goodReadPairs[r]->hetSites.size(); i++) {
                    int phaseThis;
                    if (goodReadPairs[r]->hetSites[i]->thisBase == goodReadPairs[r]->hetSites[i]->thisHetPhase0) phaseThis = 0;
                    if (goodReadPairs[r]->hetSites[i]->thisBase == goodReadPairs[r]->hetSites[i]->thisHetPhase1) phaseThis = 1;
                    
                    if (phaseThis != phaseOfPrevious) {
                        allConcordant = false;
                        PhaseSwitch* thisSwitch = new PhaseSwitch(goodReadPairs[r]->hetSites[i-1]->pos, goodReadPairs[r]->hetSites[i]->pos, goodReadPairs[r]->hetSites[i-1]->thisPhaseQuality, goodReadPairs[r]->hetSites[i]->thisPhaseQuality);
                        phaseSwitches.push_back(thisSwitch);
                    }
                    posOfPrevious = goodReadPairs[r]->hetSites[i]->pos;
                    phaseOfPrevious = phaseThis;
                }
                if (allConcordant == false) numDiscordant++;
                else numConcordant++;
            }
        }
        std::cout << "numConcordant: " << numConcordant << std::endl;
        std::cout << "numDiscordant: " << numDiscordant << std::endl;
        
        std::cout << "numMatch: " << numMatch << std::endl;
        std::cout << "numMismatch: " << numMismatch << std::endl;
        std::cout << "Mean mismatchBaseScores: " << vector_average(mismatchBaseScores) << std::endl;
        std::cout << "Mean matchBaseScores: " << vector_average(matchBaseScores) << std::endl;
        
        for (int i = 0; i != phaseSwitches.size(); i++) {
            *phaseSwitchFile << phaseSwitches[i]->posLeft << "\t" << phaseSwitches[i]->posRight << "\t" << phaseSwitches[i]->dist << "\t" << phaseSwitches[i]->phaseQualLeft << "\t" << phaseSwitches[i]->phaseQualRight << std::endl;
        }
        
    } else {
        for (int r = 0; r < goodReadPairs.size(); r++) {
            if (goodReadPairs[r]->hetSites.size() > 1) {
                for (int i = 0; i < goodReadPairs[r]->hetSites.size() - 1; i++) {
                    for (int j = 1; j < goodReadPairs[r]->hetSites.size(); j++) {
                        char readBase1 = goodReadPairs[r]->hetSites[i]->thisBase;
                        char readBase2 = goodReadPairs[r]->hetSites[j]->thisBase;
                        int pos1 = goodReadPairs[r]->hetSites[i]->pos;
                        int pos2 = goodReadPairs[r]->hetSites[j]->pos;
                        string pairIndex = numToString(pos1)+"_"+numToString(pos2);
                        if (!SNPpairs.count(pairIndex)) {
                            SNPpairs[pairIndex] = new ReadLinkSNPpair(pos1,pos2,readBase1,readBase2);
                        } else {
                            SNPpairs[pairIndex]->base1.push_back(readBase1);
                            SNPpairs[pairIndex]->base1.push_back(readBase2);
                        }
                    }
                }
            }
        }
        std::cout << "SNPpairs.size(): " << SNPpairs.size() << std::endl;
        std::cout << "numFullLenghtReadPairs: " << numFullLenghtReadPairs << std::endl;
        std::cout << "totalUsedLength: " << totalUsedLength << std::endl;
        std::cout << "totalUsedLength/(goodReadPairs.size()*300): " << (double)totalUsedLength/(double)(goodReadPairs.size()*300) << std::endl;
    }
    
    return 0;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa30, %rsp            # imm = 0xA30
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x11c8f0
leaq -0x30(%rbp), %rdi
callq 0xa820
leaq 0x8193a(%rip), %rdi     # 0x19b7d8
callq 0xa220
movq %rax, -0x690(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x688(%rbp)
callq 0xab60
movq -0x690(%rbp), %rsi
movq -0x688(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x2d6c0
jmp 0x119ed3
leaq -0x58(%rbp), %rdi
movl $0x8, %esi
callq 0x80e30
movq %rax, -0x698(%rbp)
jmp 0x119eea
leaq -0x58(%rbp), %rdi
callq 0xac88
leaq -0x59(%rbp), %rdi
callq 0xa640
movq -0x698(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x208, %edi            # imm = 0x208
callq 0xa5d0
movq %rax, -0x6a0(%rbp)
jmp 0x119f1a
leaq 0x818f7(%rip), %rdi     # 0x19b818
callq 0xa220
movq -0x6a0(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0xab90
jmp 0x119f3c
movq -0x6a0(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x208, %edi            # imm = 0x208
callq 0xa5d0
movq %rax, -0x6a8(%rbp)
jmp 0x119f5a
leaq 0x81897(%rip), %rdi     # 0x19b7f8
callq 0xa220
movq -0x6a8(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0xab90
jmp 0x119f7c
movq -0x6a8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x200, %edi            # imm = 0x200
callq 0xa5d0
movq %rax, -0x6b0(%rbp)
jmp 0x119f9a
movb $0x1, -0xc9(%rbp)
leaq 0x3445e(%rip), %rsi     # 0x14e406
leaq 0x81889(%rip), %rdx     # 0x19b838
leaq -0xc8(%rbp), %rdi
callq 0xba820
jmp 0x119fbd
leaq 0x2f5e3(%rip), %rdx     # 0x1495a7
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x3e020
jmp 0x119fd9
movq -0x6b0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
movl $0x10, %edx
callq 0xac00
jmp 0x119ff3
movb $0x0, -0xc9(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xac88
leaq -0xc8(%rbp), %rdi
callq 0xac88
movq -0x6b0(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x200, %edi            # imm = 0x200
callq 0xa5d0
movq %rax, -0x6b8(%rbp)
jmp 0x11a033
movb $0x1, -0x119(%rbp)
leaq 0x343ce(%rip), %rsi     # 0x14e40f
leaq 0x817f0(%rip), %rdx     # 0x19b838
leaq -0x118(%rbp), %rdi
callq 0xba820
jmp 0x11a056
leaq 0x2f54a(%rip), %rdx     # 0x1495a7
leaq -0xf8(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x3e020
jmp 0x11a072
movq -0x6b8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
movl $0x10, %edx
callq 0xac00
jmp 0x11a08c
movb $0x0, -0x119(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0xac88
leaq -0x118(%rbp), %rdi
callq 0xac88
movq -0x6b8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x150(%rbp), %rdi
callq 0x11cc50
leaq -0x180(%rbp), %rdi
callq 0x73cf0
leaq -0x1b0(%rbp), %rdi
callq 0x58920
leaq -0x1e0(%rbp), %rdi
callq 0x11cc70
movl $0x0, -0x1e4(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x11cc90
testb $0x1, 0x81752(%rip)     # 0x19b858
je 0x11a76d
movl $0x0, -0x224(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa0d0
movq %rax, -0x6c0(%rbp)
jmp 0x11a12c
movq -0x6c0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x6c1(%rbp)
jmp 0x11a14a
movb -0x6c1(%rbp), %al
testb $0x1, %al
jne 0x11a159
jmp 0x11a768
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0xac60
movq %rax, -0x6d0(%rbp)
jmp 0x11a16f
movq -0x6d0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x11a2e0
jmp 0x11a763
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11a1aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xac88
leaq -0x59(%rbp), %rdi
callq 0xa640
jmp 0x11c8dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11c8dd
movq -0x6a0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0xa5e0
jmp 0x11c8dd
movq -0x6a8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0xa5e0
jmp 0x11c8dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11a24d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11a241
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xac88
leaq -0xc8(%rbp), %rdi
callq 0xac88
testb $0x1, -0xc9(%rbp)
jne 0x11a258
jmp 0x11a269
movq -0x6b0(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0xa5e0
jmp 0x11c8dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11a2ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11a2a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0xac88
leaq -0x118(%rbp), %rdi
callq 0xac88
testb $0x1, -0x119(%rbp)
jne 0x11a2b9
jmp 0x11a2ca
movq -0x6b8(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0xa5e0
jmp 0x11c8dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11c8a1
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0xac60
movq %rax, -0x6d8(%rbp)
jmp 0x11a2f6
movq -0x6d8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x42, %eax
jne 0x11a33f
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0xac60
movq %rax, -0x6e0(%rbp)
jmp 0x11a31c
movq -0x6e0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4c, %eax
jne 0x11a33f
movl -0x224(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x224(%rbp)
jmp 0x11a761
leaq -0x240(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x9, %edx
callq 0x7bbe0
jmp 0x11a356
leaq -0x240(%rbp), %rdi
movl $0x4, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movl %eax, -0x244(%rbp)
leaq -0x240(%rbp), %rdi
movl $0x1, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movl %eax, -0x248(%rbp)
leaq -0x240(%rbp), %rdi
movl $0x2, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movl %eax, -0x24c(%rbp)
leaq -0x240(%rbp), %rdi
movl $0x5, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa930
cmpq $0x1, %rax
jne 0x11a3ec
jmp 0x11a40b
leaq 0x3402a(%rip), %rdi     # 0x14e41d
leaq 0x34045(%rip), %rsi     # 0x14e43f
movl $0x68, %edx
leaq 0x34055(%rip), %rcx     # 0x14e45b
callq 0xa390
leaq -0x240(%rbp), %rdi
movl $0x6, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa930
cmpq $0x1, %rax
jne 0x11a42c
jmp 0x11a44b
leaq 0x3404b(%rip), %rdi     # 0x14e47e
leaq 0x34005(%rip), %rsi     # 0x14e43f
movl $0x68, %edx
leaq 0x34015(%rip), %rcx     # 0x14e45b
callq 0xa390
leaq -0x240(%rbp), %rdi
movl $0x5, %esi
callq 0x3d940
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xac60
movq %rax, -0x6e8(%rbp)
jmp 0x11a471
movq -0x6e8(%rbp), %rax
movb (%rax), %al
movb %al, -0x24d(%rbp)
leaq -0x240(%rbp), %rdi
movl $0x6, %esi
callq 0x3d940
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xac60
movq %rax, -0x6f0(%rbp)
jmp 0x11a4a6
movq -0x6f0(%rbp), %rax
movb (%rax), %al
movb %al, -0x24e(%rbp)
leaq -0x240(%rbp), %rdi
movl $0xa, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, -0x700(%rbp)
leaq -0x279(%rbp), %rdi
movq %rdi, -0x6f8(%rbp)
callq 0xab60
movq -0x700(%rbp), %rsi
movq -0x6f8(%rbp), %rdx
leaq -0x278(%rbp), %rdi
callq 0x2d6c0
jmp 0x11a504
leaq -0x278(%rbp), %rdi
callq 0x7bab0
movsd %xmm0, -0x708(%rbp)
jmp 0x11a51a
leaq -0x278(%rbp), %rdi
callq 0xac88
leaq -0x279(%rbp), %rdi
callq 0xa640
movsd -0x708(%rbp), %xmm0
movsd %xmm0, -0x258(%rbp)
leaq -0x240(%rbp), %rdi
movl $0xb, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movl %eax, -0x280(%rbp)
leaq -0x298(%rbp), %rdi
callq 0xad970
cmpl $0x0, -0x248(%rbp)
jne 0x11a617
cmpl $0x1, -0x24c(%rbp)
jne 0x11a617
leaq -0x298(%rbp), %rdi
leaq -0x24d(%rbp), %rsi
callq 0xad990
jmp 0x11a5a4
leaq -0x298(%rbp), %rdi
leaq -0x24e(%rbp), %rsi
callq 0xad990
jmp 0x11a5b9
jmp 0x11a666
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11a750
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11a5f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x278(%rbp), %rdi
callq 0xac88
leaq -0x279(%rbp), %rdi
callq 0xa640
jmp 0x11a750
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11a744
cmpl $0x1, -0x248(%rbp)
jne 0x11a655
cmpl $0x0, -0x24c(%rbp)
jne 0x11a655
leaq -0x298(%rbp), %rdi
leaq -0x24e(%rbp), %rsi
callq 0xad990
jmp 0x11a63e
leaq -0x298(%rbp), %rdi
leaq -0x24d(%rbp), %rsi
callq 0xad990
jmp 0x11a653
jmp 0x11a664
movl $0x2, -0x29c(%rbp)
jmp 0x11a6fc
jmp 0x11a666
movl $0x30, %edi
callq 0xa5d0
movq %rax, -0x710(%rbp)
jmp 0x11a679
movq -0x710(%rbp), %rdi
movl -0x244(%rbp), %esi
movsd -0x258(%rbp), %xmm0
movl -0x280(%rbp), %edx
movl -0x224(%rbp), %r8d
leaq -0x298(%rbp), %rcx
callq 0x11ccb0
jmp 0x11a6a9
movq -0x710(%rbp), %rax
movq %rax, -0x2a8(%rbp)
movq -0x2a8(%rbp), %rax
movq %rax, -0x720(%rbp)
leaq -0x150(%rbp), %rdi
leaq -0x244(%rbp), %rsi
callq 0x11cd40
movq %rax, -0x718(%rbp)
jmp 0x11a6e1
movq -0x718(%rbp), %rax
movq -0x720(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x29c(%rbp)
leaq -0x298(%rbp), %rdi
callq 0xae570
leaq -0x240(%rbp), %rdi
callq 0x3dfa0
movl -0x29c(%rbp), %eax
testl %eax, %eax
je 0x11a725
jmp 0x11a720
jmp 0x11a116
jmp 0x11a761
movq -0x710(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x30, %esi
callq 0xa5e0
leaq -0x298(%rbp), %rdi
callq 0xae570
leaq -0x240(%rbp), %rdi
callq 0x3dfa0
jmp 0x11c8a1
jmp 0x11a763
jmp 0x11a116
jmp 0x11aa56
jmp 0x11a76f
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa0d0
movq %rax, -0x728(%rbp)
jmp 0x11a785
movq -0x728(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x729(%rbp)
jmp 0x11a7a3
movb -0x729(%rbp), %al
testb $0x1, %al
jne 0x11a7b2
jmp 0x11aa2a
leaq -0x2c0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x9, %edx
callq 0x7bbe0
jmp 0x11a7c9
leaq -0x2c0(%rbp), %rdi
movl $0x1, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movl %eax, -0x2c4(%rbp)
leaq -0x2c0(%rbp), %rdi
movl $0x2, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa930
cmpq $0x1, %rax
jne 0x11a811
jmp 0x11a830
leaq 0x33c88(%rip), %rdi     # 0x14e4a0
leaq 0x33c20(%rip), %rsi     # 0x14e43f
movl $0x7d, %edx
leaq 0x33c30(%rip), %rcx     # 0x14e45b
callq 0xa390
leaq -0x2c0(%rbp), %rdi
movl $0x3, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa930
cmpq $0x1, %rax
jne 0x11a851
jmp 0x11a870
leaq 0x33c6a(%rip), %rdi     # 0x14e4c2
leaq 0x33be0(%rip), %rsi     # 0x14e43f
movl $0x7d, %edx
leaq 0x33bf0(%rip), %rcx     # 0x14e45b
callq 0xa390
leaq -0x2c0(%rbp), %rdi
movl $0x2, %esi
callq 0x3d940
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xac60
movq %rax, -0x738(%rbp)
jmp 0x11a896
movq -0x738(%rbp), %rax
movb (%rax), %al
movb %al, -0x2c5(%rbp)
leaq -0x2c0(%rbp), %rdi
movl $0x3, %esi
callq 0x3d940
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xac60
movq %rax, -0x740(%rbp)
jmp 0x11a8cb
movq -0x740(%rbp), %rax
movb (%rax), %al
movb %al, -0x2c6(%rbp)
leaq -0x2e0(%rbp), %rdi
movq %rdi, -0x748(%rbp)
callq 0xad970
movq -0x748(%rbp), %rdi
leaq -0x2c5(%rbp), %rsi
callq 0xad990
jmp 0x11a902
leaq -0x2e0(%rbp), %rdi
leaq -0x2c6(%rbp), %rsi
callq 0xad990
jmp 0x11a917
movq $0x0, -0x2e8(%rbp)
movl $0x0, -0x2ec(%rbp)
movl $0x30, %edi
callq 0xa5d0
movq %rax, -0x750(%rbp)
jmp 0x11a93f
movq -0x750(%rbp), %rdi
movl -0x2c4(%rbp), %esi
movsd -0x2e8(%rbp), %xmm0
movl -0x2ec(%rbp), %edx
leaq -0x2e0(%rbp), %rcx
movl $0x1, %r8d
callq 0x11ccb0
jmp 0x11a96e
movq -0x750(%rbp), %rax
movq %rax, -0x2f8(%rbp)
movq -0x2f8(%rbp), %rax
movq %rax, -0x760(%rbp)
leaq -0x150(%rbp), %rdi
leaq -0x2c4(%rbp), %rsi
callq 0x11cd40
movq %rax, -0x758(%rbp)
jmp 0x11a9a6
movq -0x758(%rbp), %rax
movq -0x760(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x2e0(%rbp), %rdi
callq 0xae570
leaq -0x2c0(%rbp), %rdi
callq 0x3dfa0
jmp 0x11a76f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11aa19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11aa0d
movq -0x750(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x30, %esi
callq 0xa5e0
leaq -0x2e0(%rbp), %rdi
callq 0xae570
leaq -0x2c0(%rbp), %rdi
callq 0x3dfa0
jmp 0x11c8a1
leaq -0x150(%rbp), %rdi
callq 0x11ce20
movl %eax, %edi
movl $0x2, %esi
callq 0xf55c0
movl %eax, -0x764(%rbp)
jmp 0x11aa4a
movl -0x764(%rbp), %eax
movl %eax, -0x1e4(%rbp)
jmp 0x11aa58
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa0d0
movq %rax, -0x770(%rbp)
jmp 0x11aa6e
movq -0x770(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x771(%rbp)
jmp 0x11aa8c
movb -0x771(%rbp), %al
testb $0x1, %al
jne 0x11aa9b
jmp 0x11ad4b
leaq -0x310(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x9, %edx
callq 0x7bbe0
jmp 0x11aab2
leaq -0x310(%rbp), %rdi
callq 0x3ffd0
cmpq $0x8, %rax
jne 0x11aac6
jmp 0x11aae5
leaq 0x33717(%rip), %rdi     # 0x14e1e4
leaq 0x3396b(%rip), %rsi     # 0x14e43f
movl $0x8f, %edx
leaq 0x3397b(%rip), %rcx     # 0x14e45b
callq 0xa390
xorl %eax, %eax
movl %eax, %esi
leaq -0x310(%rbp), %rdi
callq 0x3d940
movq %rax, %rsi
leaq -0x330(%rbp), %rdi
callq 0xa250
jmp 0x11ab06
leaq -0x310(%rbp), %rdi
movq %rdi, -0x788(%rbp)
movl $0x2, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movq -0x788(%rbp), %rdi
movl %eax, -0x334(%rbp)
movl $0x4, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movl %eax, -0x338(%rbp)
leaq -0x350(%rbp), %rdi
movq %rdi, -0x780(%rbp)
callq 0x46270
movq -0x780(%rbp), %rdi
leaq -0x334(%rbp), %rsi
callq 0x6b600
jmp 0x11ab83
leaq -0x350(%rbp), %rdi
leaq -0x338(%rbp), %rsi
callq 0x6b600
jmp 0x11ab98
leaq -0x180(%rbp), %rdi
leaq -0x330(%rbp), %rsi
callq 0x6b150
movq %rax, -0x790(%rbp)
jmp 0x11abb4
movq -0x790(%rbp), %rdi
leaq -0x350(%rbp), %rsi
callq 0x46440
jmp 0x11abc9
leaq -0x310(%rbp), %rdi
movl $0x5, %esi
callq 0x3d940
movq %rax, %rsi
leaq -0x370(%rbp), %rdi
callq 0xa250
jmp 0x11abeb
leaq -0x310(%rbp), %rdi
movl $0x6, %esi
callq 0x3d940
movq %rax, %rsi
leaq -0x390(%rbp), %rdi
callq 0xa250
jmp 0x11ac0d
leaq -0x3a8(%rbp), %rdi
movq %rdi, -0x798(%rbp)
callq 0x48da0
movq -0x798(%rbp), %rdi
leaq -0x370(%rbp), %rsi
callq 0x48dc0
jmp 0x11ac35
leaq -0x3a8(%rbp), %rdi
leaq -0x370(%rbp), %rsi
callq 0x48dc0
jmp 0x11ac4a
leaq -0x1b0(%rbp), %rdi
leaq -0x330(%rbp), %rsi
callq 0x6b400
movq %rax, -0x7a0(%rbp)
jmp 0x11ac66
movq -0x7a0(%rbp), %rdi
leaq -0x3a8(%rbp), %rsi
callq 0x43c10
jmp 0x11ac7b
leaq -0x3a8(%rbp), %rdi
callq 0x3dfa0
leaq -0x390(%rbp), %rdi
callq 0xac88
leaq -0x370(%rbp), %rdi
callq 0xac88
leaq -0x350(%rbp), %rdi
callq 0x48290
leaq -0x330(%rbp), %rdi
callq 0xac88
leaq -0x310(%rbp), %rdi
callq 0x3dfa0
jmp 0x11aa58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11ad3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11ad22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11ad16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x3dfa0
leaq -0x390(%rbp), %rdi
callq 0xac88
leaq -0x370(%rbp), %rdi
callq 0xac88
leaq -0x350(%rbp), %rdi
callq 0x48290
leaq -0x330(%rbp), %rdi
callq 0xac88
leaq -0x310(%rbp), %rdi
callq 0x3dfa0
jmp 0x11c8a1
jmp 0x11ad4d
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa0d0
movq %rax, -0x7a8(%rbp)
jmp 0x11ad63
movq -0x7a8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x7a9(%rbp)
jmp 0x11ad81
movb -0x7a9(%rbp), %al
testb $0x1, %al
jne 0x11ad90
jmp 0x11b1a6
leaq -0x3c0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x9, %edx
callq 0x7bbe0
jmp 0x11ada7
leaq -0x3c0(%rbp), %rdi
movl $0x1, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movl %eax, -0x3c4(%rbp)
cmpl $0x7d0, -0x3c4(%rbp)    # imm = 0x7D0
jle 0x11ade9
movl $0x8, -0x29c(%rbp)
jmp 0x11b15b
movl $0x150, %edi            # imm = 0x150
callq 0xa5d0
movq %rax, -0x7b8(%rbp)
jmp 0x11adfc
movb $0x1, -0x3e9(%rbp)
leaq -0x3e8(%rbp), %rdi
leaq -0x3c0(%rbp), %rsi
callq 0x3fee0
jmp 0x11ae18
movq -0x7b8(%rbp), %rdi
leaq -0x3e8(%rbp), %rsi
callq 0x11ce40
jmp 0x11ae2d
movb $0x0, -0x3e9(%rbp)
leaq -0x3e8(%rbp), %rdi
callq 0x3dfa0
movq -0x7b8(%rbp), %rax
movq %rax, -0x3d0(%rbp)
movq -0x3d0(%rbp), %rsi
addq $0xe8, %rsi
leaq -0x408(%rbp), %rdi
callq 0x4cf20
jmp 0x11ae6a
leaq -0x408(%rbp), %rdi
callq 0x4ceb0
movsd %xmm0, -0x7c0(%rbp)
jmp 0x11ae80
movsd -0x7c0(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x7c8(%rbp)
leaq -0x408(%rbp), %rdi
callq 0x48290
movl -0x7c8(%rbp), %eax
movl %eax, -0x3f0(%rbp)
movq -0x3d0(%rbp), %rdi
addq $0x8, %rdi
leaq 0x19c54(%rip), %rsi     # 0x134b10
callq 0x2d770
movb %al, -0x7c1(%rbp)
jmp 0x11aec9
movb -0x7c1(%rbp), %al
testb $0x1, %al
jne 0x11aed8
jmp 0x11af6b
movq -0x3d0(%rbp), %rax
movl 0x48(%rax), %eax
addl -0x3f0(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x40c(%rbp)
jmp 0x11af7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11b195
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11af2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x3e8(%rbp), %rdi
callq 0x3dfa0
testb $0x1, -0x3e9(%rbp)
jne 0x11af38
jmp 0x11af49
movq -0x7b8(%rbp), %rdi
movl $0x150, %esi            # imm = 0x150
callq 0xa5e0
jmp 0x11b195
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x408(%rbp), %rdi
callq 0x48290
jmp 0x11b195
movq -0x3d0(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x40c(%rbp)
movl -0x40c(%rbp), %ecx
movq -0x3d0(%rbp), %rax
movl %ecx, 0x4c(%rax)
leaq -0x430(%rbp), %rdi
callq 0xa820
leaq -0x450(%rbp), %rdi
callq 0xa820
movq -0x3d0(%rbp), %rsi
addq $0x28, %rsi
leaq -0x180(%rbp), %rdi
callq 0x11d0f0
movq %rax, -0x7d0(%rbp)
jmp 0x11afc3
movq -0x7d0(%rbp), %rax
cmpq $0x1, %rax
je 0x11b037
movq 0x7e019(%rip), %rdi     # 0x198ff0
leaq 0x33506(%rip), %rsi     # 0x14e4e4
callq 0xa5c0
movq %rax, -0x7d8(%rbp)
jmp 0x11afec
movq -0x7d8(%rbp), %rdi
movq -0x3d0(%rbp), %rsi
addq $0x28, %rsi
callq 0xa520
movq %rax, -0x7e0(%rbp)
jmp 0x11b00c
movq -0x7e0(%rbp), %rdi
movq 0x7df6e(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11b021
jmp 0x11b139
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11b17d
movq -0x3d0(%rbp), %rax
movl 0x90(%rax), %eax
cmpl 0x7ea56(%rip), %eax     # 0x199aa0
jle 0x11b137
movq -0x3d0(%rbp), %rsi
addq $0x28, %rsi
leaq -0x180(%rbp), %rdi
callq 0x11d150
movq %rax, -0x7e8(%rbp)
jmp 0x11b070
movq -0x7e8(%rbp), %rsi
leaq -0x468(%rbp), %rdi
callq 0x4cf20
jmp 0x11b085
movl -0x40c(%rbp), %eax
movl %eax, -0x7ec(%rbp)
leaq -0x468(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4d100
movq %rax, %rcx
movl -0x7ec(%rbp), %eax
cmpl (%rcx), %eax
je 0x11b0d8
movl -0x40c(%rbp), %eax
movl %eax, -0x7f0(%rbp)
leaq -0x468(%rbp), %rdi
movl $0x1, %esi
callq 0x4d100
movq %rax, %rcx
movl -0x7f0(%rbp), %eax
cmpl (%rcx), %eax
jne 0x11b129
movq -0x3d0(%rbp), %rsi
addq $0x28, %rsi
leaq -0x1e0(%rbp), %rdi
callq 0x11d1f0
movq %rax, -0x7f8(%rbp)
jmp 0x11b0f8
movq -0x7f8(%rbp), %rdi
leaq -0x3d0(%rbp), %rsi
callq 0x11d2d0
jmp 0x11b10d
jmp 0x11b12b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x468(%rbp), %rdi
callq 0x48290
jmp 0x11b17d
jmp 0x11b12b
leaq -0x468(%rbp), %rdi
callq 0x48290
jmp 0x11b139
leaq -0x450(%rbp), %rdi
callq 0xac88
leaq -0x430(%rbp), %rdi
callq 0xac88
movl $0x0, -0x29c(%rbp)
leaq -0x3c0(%rbp), %rdi
callq 0x3dfa0
movl -0x29c(%rbp), %eax
testl %eax, %eax
je 0x11b178
jmp 0x11b173
jmp 0x11ad4d
jmp 0x11ad4d
leaq -0x450(%rbp), %rdi
callq 0xac88
leaq -0x430(%rbp), %rdi
callq 0xac88
leaq -0x3c0(%rbp), %rdi
callq 0x3dfa0
jmp 0x11c8a1
movl $0x0, -0x46c(%rbp)
leaq -0x488(%rbp), %rdi
movq %rdi, -0x800(%rbp)
callq 0x11d340
leaq -0x1e0(%rbp), %rdi
callq 0x11d460
movq -0x800(%rbp), %rdi
movq %rax, %rsi
callq 0x11d360
jmp 0x11b1e0
leaq -0x1e0(%rbp), %rdi
callq 0x11d480
movq %rax, -0x490(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x11d4e0
movq %rax, -0x498(%rbp)
leaq -0x490(%rbp), %rdi
leaq -0x498(%rbp), %rsi
callq 0x11d4b0
testb $0x1, %al
jne 0x11b222
jmp 0x11b33d
leaq -0x490(%rbp), %rdi
callq 0x11d510
movq %rax, %rdi
addq $0x20, %rdi
callq 0x11d530
cmpq $0x2, %rax
jne 0x11b31f
movl -0x46c(%rbp), %eax
incl %eax
movl %eax, -0x46c(%rbp)
movl $0x30, %edi
callq 0xa5d0
movq %rax, -0x808(%rbp)
jmp 0x11b265
leaq -0x490(%rbp), %rdi
movq %rdi, -0x818(%rbp)
callq 0x11d510
movq %rax, %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11d550
movq -0x818(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x810(%rbp)
callq 0x11d510
movq %rax, %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0x11d550
movq -0x808(%rbp), %rdi
movq -0x810(%rbp), %rsi
movq (%rax), %rdx
callq 0x11d570
jmp 0x11b2c7
movq -0x808(%rbp), %rax
movq %rax, -0x4a0(%rbp)
leaq -0x488(%rbp), %rdi
leaq -0x4a0(%rbp), %rsi
callq 0x11d5d0
jmp 0x11b2ea
jmp 0x11b321
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11c895
movq -0x808(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x30, %esi
callq 0xa5e0
jmp 0x11c895
jmp 0x11b321
jmp 0x11b323
leaq -0x490(%rbp), %rdi
xorl %esi, %esi
callq 0x11d640
movq %rax, -0x4a8(%rbp)
jmp 0x11b1f3
leaq -0x488(%rbp), %rdi
movq %rdi, -0x820(%rbp)
callq 0x11d6c0
movq -0x820(%rbp), %rdi
movq %rax, -0x4b0(%rbp)
callq 0x11d6f0
movq %rax, -0x4b8(%rbp)
movq -0x4b0(%rbp), %rdi
movq -0x4b8(%rbp), %rsi
callq 0x11d680
jmp 0x11b37f
movl $0x0, -0x4bc(%rbp)
movl $0x0, -0x4c0(%rbp)
movl $0x0, -0x4c4(%rbp)
movl $0x0, -0x4c8(%rbp)
leaq -0x4e0(%rbp), %rdi
callq 0x48410
leaq -0x4f8(%rbp), %rdi
callq 0x48410
leaq -0x510(%rbp), %rdi
callq 0x48410
leaq -0x528(%rbp), %rdi
callq 0x48410
leaq -0x540(%rbp), %rdi
callq 0x11d720
movl $0x0, -0x544(%rbp)
movl $0x0, -0x548(%rbp)
leaq -0x560(%rbp), %rdi
callq 0x46270
movl $0x0, -0x564(%rbp)
movl $0x0, -0x568(%rbp)
movl $0x0, -0x56c(%rbp)
movl $0x0, -0x570(%rbp)
movslq -0x570(%rbp), %rax
movq %rax, -0x828(%rbp)
leaq -0x488(%rbp), %rdi
callq 0x11d740
movq %rax, %rcx
movq -0x828(%rbp), %rax
cmpq %rcx, %rax
jae 0x11b6c1
movslq -0x570(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
leaq -0x150(%rbp), %rsi
callq 0x126a70
jmp 0x11b47c
movslq -0x570(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
movl 0x7e60c(%rip), %esi     # 0x199aa4
callq 0x126ba0
jmp 0x11b49f
movslq -0x570(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
cmpq $0x0, %rax
jne 0x11b4e9
movl -0x564(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x564(%rbp)
jmp 0x11b638
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11c84d
movslq -0x570(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
cmpq $0x1, %rax
jne 0x11b522
movl -0x568(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x568(%rbp)
jmp 0x11b636
movl -0x56c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x56c(%rbp)
movslq -0x570(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rax
movq (%rax), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x11d780
cmpq $0x1, %rax
jb 0x11b634
movslq -0x570(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rax
movq 0x8(%rax), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x11d780
cmpq $0x1, %rax
jb 0x11b634
movq -0xd8(%rbp), %rax
movq %rax, -0x838(%rbp)
movslq -0x570(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq -0x838(%rbp), %rdi
movq (%rax), %rax
movq (%rax), %rax
movl 0x48(%rax), %esi
callq 0xab20
movq %rax, -0x830(%rbp)
jmp 0x11b5cf
movq -0x830(%rbp), %rdi
leaq 0x1a901(%rip), %rsi     # 0x135ede
callq 0xa5c0
movq %rax, -0x840(%rbp)
jmp 0x11b5eb
movslq -0x570(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq -0x840(%rbp), %rdi
movq (%rax), %rax
movq 0x8(%rax), %rax
movl 0x48(%rax), %esi
callq 0xab20
movq %rax, -0x848(%rbp)
jmp 0x11b61d
movq -0x848(%rbp), %rdi
movq 0x7d95d(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11b632
jmp 0x11b634
jmp 0x11b636
jmp 0x11b638
movl -0x548(%rbp), %eax
movl %eax, -0x850(%rbp)
movslq -0x570(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq %rax, %rcx
movl -0x850(%rbp), %eax
movq (%rcx), %rcx
movq (%rcx), %rcx
addl 0x100(%rcx), %eax
movl %eax, -0x548(%rbp)
movl -0x548(%rbp), %eax
movl %eax, -0x84c(%rbp)
movslq -0x570(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq %rax, %rcx
movl -0x84c(%rbp), %eax
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
addl 0x100(%rcx), %eax
movl %eax, -0x548(%rbp)
movl -0x570(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x570(%rbp)
jmp 0x11b42b
movq 0x7d8f0(%rip), %rdi     # 0x198fb8
leaq 0x32e2d(%rip), %rsi     # 0x14e4fc
callq 0xa5c0
movq %rax, -0x858(%rbp)
jmp 0x11b6dd
leaq -0x488(%rbp), %rdi
callq 0x11d740
movq -0x858(%rbp), %rdi
movq %rax, %rsi
callq 0xa140
movq %rax, -0x860(%rbp)
jmp 0x11b701
movq -0x860(%rbp), %rdi
movq 0x7d879(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11b716
movq 0x7d89b(%rip), %rdi     # 0x198fb8
leaq 0x32def(%rip), %rsi     # 0x14e513
callq 0xa5c0
movq %rax, -0x868(%rbp)
jmp 0x11b732
movq -0x868(%rbp), %rdi
movl -0x564(%rbp), %esi
callq 0xab20
movq %rax, -0x870(%rbp)
jmp 0x11b74d
movq -0x870(%rbp), %rdi
movq 0x7d82d(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11b762
movq 0x7d84f(%rip), %rdi     # 0x198fb8
leaq 0x32dad(%rip), %rsi     # 0x14e51d
callq 0xa5c0
movq %rax, -0x878(%rbp)
jmp 0x11b77e
movq -0x878(%rbp), %rdi
movl -0x568(%rbp), %esi
callq 0xab20
movq %rax, -0x880(%rbp)
jmp 0x11b799
movq -0x880(%rbp), %rdi
movq 0x7d7e1(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11b7ae
movq 0x7d803(%rip), %rdi     # 0x198fb8
leaq 0x32d6b(%rip), %rsi     # 0x14e527
callq 0xa5c0
movq %rax, -0x888(%rbp)
jmp 0x11b7ca
movq -0x888(%rbp), %rdi
movl -0x56c(%rbp), %esi
callq 0xab20
movq %rax, -0x890(%rbp)
jmp 0x11b7e5
movq -0x890(%rbp), %rdi
movq 0x7d795(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11b7fa
testb $0x1, 0x80057(%rip)     # 0x19b858
je 0x11c1db
movl $0x0, -0x574(%rbp)
movslq -0x574(%rbp), %rax
movq %rax, -0x898(%rbp)
leaq -0x488(%rbp), %rdi
callq 0x11d740
movq %rax, %rcx
movq -0x898(%rbp), %rax
cmpq %rcx, %rax
jae 0x11bd99
movl $0x0, -0x578(%rbp)
movslq -0x578(%rbp), %rax
movq %rax, -0x8a0(%rbp)
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
movq %rax, %rcx
movq -0x8a0(%rbp), %rax
cmpq %rcx, %rax
jae 0x11b94c
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x578(%rbp), %rsi
callq 0x11d7a0
movq (%rax), %rax
movq %rax, -0x580(%rbp)
movq -0x580(%rbp), %rax
testb $0x1, 0x24(%rax)
je 0x11b8fe
movl -0x4c8(%rbp), %eax
incl %eax
movl %eax, -0x4c8(%rbp)
movq -0x580(%rbp), %rax
cvtsi2sdl 0xc(%rax), %xmm0
movsd %xmm0, -0x588(%rbp)
leaq -0x4f8(%rbp), %rdi
leaq -0x588(%rbp), %rsi
callq 0x48450
jmp 0x11b8fc
jmp 0x11b936
movq -0x580(%rbp), %rax
cvtsi2sdl 0xc(%rax), %xmm0
movsd %xmm0, -0x590(%rbp)
leaq -0x4e0(%rbp), %rdi
leaq -0x590(%rbp), %rsi
callq 0x48450
jmp 0x11b927
movl -0x4c4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c4(%rbp)
jmp 0x11b938
movl -0x578(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x578(%rbp)
jmp 0x11b848
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
cmpq $0x1, %rax
jbe 0x11bd83
movb $0x1, -0x599(%rbp)
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11d7a0
movq (%rax), %rax
movsbl 0x8(%rax), %eax
movl %eax, -0x8a4(%rbp)
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11d7a0
movq %rax, %rcx
movl -0x8a4(%rbp), %eax
movq (%rcx), %rcx
movsbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jne 0x11b9ed
movl $0x0, -0x594(%rbp)
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11d7a0
movq (%rax), %rax
movsbl 0x8(%rax), %eax
movl %eax, -0x8a8(%rbp)
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11d7a0
movq %rax, %rcx
movl -0x8a8(%rbp), %eax
movq (%rcx), %rcx
movsbl 0x11(%rcx), %ecx
cmpl %ecx, %eax
jne 0x11ba5e
movl $0x1, -0x594(%rbp)
movl $0x1, -0x5a0(%rbp)
movslq -0x5a0(%rbp), %rax
movq %rax, -0x8b0(%rbp)
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
movq %rax, %rcx
movq -0x8b0(%rbp), %rax
cmpq %rcx, %rax
jae 0x11bd51
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x5a0(%rbp), %rsi
callq 0x11d7a0
movq (%rax), %rax
movsbl 0x8(%rax), %eax
movl %eax, -0x8b4(%rbp)
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x5a0(%rbp), %rsi
callq 0x11d7a0
movq %rax, %rcx
movl -0x8b4(%rbp), %eax
movq (%rcx), %rcx
movsbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
jne 0x11bb1f
movl $0x0, -0x5a4(%rbp)
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x5a0(%rbp), %rsi
callq 0x11d7a0
movq (%rax), %rax
movsbl 0x8(%rax), %eax
movl %eax, -0x8b8(%rbp)
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x5a0(%rbp), %rsi
callq 0x11d7a0
movq %rax, %rcx
movl -0x8b8(%rbp), %eax
movq (%rcx), %rcx
movsbl 0x11(%rcx), %ecx
cmpl %ecx, %eax
jne 0x11bb96
movl $0x1, -0x5a4(%rbp)
movl -0x5a4(%rbp), %eax
cmpl -0x594(%rbp), %eax
je 0x11bd00
movb $0x0, -0x599(%rbp)
movl $0x20, %edi
callq 0xa5d0
movq %rax, -0x8c0(%rbp)
jmp 0x11bbc2
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
movq %rdi, -0x8d8(%rbp)
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movl -0x5a0(%rbp), %eax
decl %eax
movslq %eax, %rsi
callq 0x11d7a0
movq -0x8d8(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x8d0(%rbp)
movslq -0x574(%rbp), %rsi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x5a0(%rbp), %rsi
callq 0x11d7a0
movq -0x8d8(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x8cc(%rbp)
movslq -0x574(%rbp), %rsi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movl -0x5a0(%rbp), %eax
decl %eax
movslq %eax, %rsi
callq 0x11d7a0
movq -0x8d8(%rbp), %rdi
movq (%rax), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x8c8(%rbp)
movslq -0x574(%rbp), %rsi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x5a0(%rbp), %rsi
callq 0x11d7a0
movq -0x8c0(%rbp), %rdi
movl -0x8d0(%rbp), %esi
movl -0x8cc(%rbp), %edx
movsd -0x8c8(%rbp), %xmm0
movq (%rax), %rax
movsd 0x18(%rax), %xmm1
callq 0x11d7c0
jmp 0x11bcb9
movq -0x8c0(%rbp), %rax
movq %rax, -0x5b0(%rbp)
leaq -0x540(%rbp), %rdi
leaq -0x5b0(%rbp), %rsi
callq 0x11d810
jmp 0x11bcdc
jmp 0x11bd00
movq -0x8c0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x20, %esi
callq 0xa5e0
jmp 0x11c84d
movslq -0x574(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x5a0(%rbp), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x598(%rbp)
movl -0x5a4(%rbp), %eax
movl %eax, -0x594(%rbp)
movl -0x5a0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5a0(%rbp)
jmp 0x11ba68
movb -0x599(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x11bd72
movl -0x4c0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c0(%rbp)
jmp 0x11bd81
movl -0x4bc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4bc(%rbp)
jmp 0x11bd83
jmp 0x11bd85
movl -0x574(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x574(%rbp)
jmp 0x11b811
movq 0x7d218(%rip), %rdi     # 0x198fb8
leaq 0x3278f(%rip), %rsi     # 0x14e536
callq 0xa5c0
movq %rax, -0x8e0(%rbp)
jmp 0x11bdb5
movq -0x8e0(%rbp), %rdi
movl -0x4bc(%rbp), %esi
callq 0xab20
movq %rax, -0x8e8(%rbp)
jmp 0x11bdd0
movq -0x8e8(%rbp), %rdi
movq 0x7d1aa(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11bde5
movq 0x7d1cc(%rip), %rdi     # 0x198fb8
leaq 0x32753(%rip), %rsi     # 0x14e546
callq 0xa5c0
movq %rax, -0x8f0(%rbp)
jmp 0x11be01
movq -0x8f0(%rbp), %rdi
movl -0x4c0(%rbp), %esi
callq 0xab20
movq %rax, -0x8f8(%rbp)
jmp 0x11be1c
movq -0x8f8(%rbp), %rdi
movq 0x7d15e(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11be31
movq 0x7d180(%rip), %rdi     # 0x198fb8
leaq 0x32717(%rip), %rsi     # 0x14e556
callq 0xa5c0
movq %rax, -0x900(%rbp)
jmp 0x11be4d
movq -0x900(%rbp), %rdi
movl -0x4c4(%rbp), %esi
callq 0xab20
movq %rax, -0x908(%rbp)
jmp 0x11be68
movq -0x908(%rbp), %rdi
movq 0x7d112(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11be7d
movq 0x7d134(%rip), %rdi     # 0x198fb8
leaq 0x326d6(%rip), %rsi     # 0x14e561
callq 0xa5c0
movq %rax, -0x910(%rbp)
jmp 0x11be99
movq -0x910(%rbp), %rdi
movl -0x4c8(%rbp), %esi
callq 0xab20
movq %rax, -0x918(%rbp)
jmp 0x11beb4
movq -0x918(%rbp), %rdi
movq 0x7d0c6(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11bec9
movq 0x7d0e8(%rip), %rdi     # 0x198fb8
leaq 0x32698(%rip), %rsi     # 0x14e56f
callq 0xa5c0
movq %rax, -0x920(%rbp)
jmp 0x11bee5
leaq -0x5c8(%rbp), %rdi
leaq -0x4f8(%rbp), %rsi
callq 0x53120
jmp 0x11befa
leaq -0x5c8(%rbp), %rdi
callq 0x53060
movsd %xmm0, -0x928(%rbp)
jmp 0x11bf10
movsd -0x928(%rbp), %xmm0
movq -0x920(%rbp), %rdi
callq 0xabd0
movq %rax, -0x930(%rbp)
jmp 0x11bf2d
movq -0x930(%rbp), %rdi
movq 0x7d04d(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11bf42
leaq -0x5c8(%rbp), %rdi
callq 0x3ecb0
movq 0x7d063(%rip), %rdi     # 0x198fb8
leaq 0x3262d(%rip), %rsi     # 0x14e589
callq 0xa5c0
movq %rax, -0x938(%rbp)
jmp 0x11bf6a
leaq -0x5e0(%rbp), %rdi
leaq -0x4e0(%rbp), %rsi
callq 0x53120
jmp 0x11bf7f
leaq -0x5e0(%rbp), %rdi
callq 0x53060
movsd %xmm0, -0x940(%rbp)
jmp 0x11bf95
movsd -0x940(%rbp), %xmm0
movq -0x938(%rbp), %rdi
callq 0xabd0
movq %rax, -0x948(%rbp)
jmp 0x11bfb2
movq -0x948(%rbp), %rdi
movq 0x7cfc8(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11bfc7
leaq -0x5e0(%rbp), %rdi
callq 0x3ecb0
movl $0x0, -0x5e4(%rbp)
movslq -0x5e4(%rbp), %rax
movq %rax, -0x950(%rbp)
leaq -0x540(%rbp), %rdi
callq 0x11d880
movq %rax, %rcx
movq -0x950(%rbp), %rax
cmpq %rcx, %rax
je 0x11c1d6
movq -0x88(%rbp), %rax
movq %rax, -0x960(%rbp)
movslq -0x5e4(%rbp), %rsi
leaq -0x540(%rbp), %rdi
callq 0x11d8a0
movq -0x960(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %esi
callq 0xab20
movq %rax, -0x958(%rbp)
jmp 0x11c045
movq -0x958(%rbp), %rdi
leaq 0x19e8b(%rip), %rsi     # 0x135ede
callq 0xa5c0
movq %rax, -0x968(%rbp)
jmp 0x11c061
movslq -0x5e4(%rbp), %rsi
leaq -0x540(%rbp), %rdi
callq 0x11d8a0
movq -0x968(%rbp), %rdi
movq (%rax), %rax
movl 0x4(%rax), %esi
callq 0xab20
movq %rax, -0x970(%rbp)
jmp 0x11c08f
movq -0x970(%rbp), %rdi
leaq 0x19e41(%rip), %rsi     # 0x135ede
callq 0xa5c0
movq %rax, -0x978(%rbp)
jmp 0x11c0ab
movslq -0x5e4(%rbp), %rsi
leaq -0x540(%rbp), %rdi
callq 0x11d8a0
movq -0x978(%rbp), %rdi
movq (%rax), %rax
movl 0x18(%rax), %esi
callq 0xab20
movq %rax, -0x980(%rbp)
jmp 0x11c0d9
movq -0x980(%rbp), %rdi
leaq 0x19df7(%rip), %rsi     # 0x135ede
callq 0xa5c0
movq %rax, -0x988(%rbp)
jmp 0x11c0f5
movslq -0x5e4(%rbp), %rsi
leaq -0x540(%rbp), %rdi
callq 0x11d8a0
movq -0x988(%rbp), %rdi
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
callq 0xabd0
movq %rax, -0x990(%rbp)
jmp 0x11c125
movq -0x990(%rbp), %rdi
leaq 0x19dab(%rip), %rsi     # 0x135ede
callq 0xa5c0
movq %rax, -0x998(%rbp)
jmp 0x11c141
movslq -0x5e4(%rbp), %rsi
leaq -0x540(%rbp), %rdi
callq 0x11d8a0
movq -0x998(%rbp), %rdi
movq (%rax), %rax
movsd 0x10(%rax), %xmm0
callq 0xabd0
movq %rax, -0x9a0(%rbp)
jmp 0x11c171
movq -0x9a0(%rbp), %rdi
movq 0x7ce09(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11c186
jmp 0x11c188
movl -0x5e4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5e4(%rbp)
jmp 0x11bfdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x5c8(%rbp), %rdi
callq 0x3ecb0
jmp 0x11c84d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x5e0(%rbp), %rdi
callq 0x3ecb0
jmp 0x11c84d
jmp 0x11c79f
movl $0x0, -0x5e8(%rbp)
movslq -0x5e8(%rbp), %rax
movq %rax, -0x9a8(%rbp)
leaq -0x488(%rbp), %rdi
callq 0x11d740
movq %rax, %rcx
movq -0x9a8(%rbp), %rax
cmpq %rcx, %rax
jae 0x11c614
movslq -0x5e8(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
cmpq $0x1, %rax
jbe 0x11c5fe
movl $0x0, -0x5ec(%rbp)
movslq -0x5ec(%rbp), %rax
movq %rax, -0x9b0(%rbp)
movslq -0x5e8(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
movq %rax, %rcx
movq -0x9b0(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x11c5fc
movl $0x1, -0x5f0(%rbp)
movslq -0x5f0(%rbp), %rax
movq %rax, -0x9b8(%rbp)
movslq -0x5e8(%rbp), %rsi
leaq -0x488(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
movq %rax, %rcx
movq -0x9b8(%rbp), %rax
cmpq %rcx, %rax
jae 0x11c5e6
movslq -0x5e8(%rbp), %rsi
leaq -0x488(%rbp), %rdi
movq %rdi, -0x9c0(%rbp)
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x5ec(%rbp), %rsi
callq 0x11d7a0
movq -0x9c0(%rbp), %rdi
movq (%rax), %rax
movb 0x8(%rax), %al
movb %al, -0x5f1(%rbp)
movslq -0x5e8(%rbp), %rsi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x5f0(%rbp), %rsi
callq 0x11d7a0
movq -0x9c0(%rbp), %rdi
movq (%rax), %rax
movb 0x8(%rax), %al
movb %al, -0x5f2(%rbp)
movslq -0x5e8(%rbp), %rsi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x5ec(%rbp), %rsi
callq 0x11d7a0
movq -0x9c0(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x5f8(%rbp)
movslq -0x5e8(%rbp), %rsi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x5f0(%rbp), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x5fc(%rbp)
movl -0x5f8(%rbp), %esi
leaq -0x660(%rbp), %rdi
callq 0x3e190
jmp 0x11c3b4
leaq 0x239d5(%rip), %rdx     # 0x13fd90
leaq -0x640(%rbp), %rdi
leaq -0x660(%rbp), %rsi
callq 0x3e020
jmp 0x11c3d0
movl -0x5fc(%rbp), %esi
leaq -0x680(%rbp), %rdi
callq 0x3e190
jmp 0x11c3e4
leaq -0x620(%rbp), %rdi
leaq -0x640(%rbp), %rsi
leaq -0x680(%rbp), %rdx
callq 0x3e070
jmp 0x11c400
leaq -0x680(%rbp), %rdi
callq 0xac88
leaq -0x640(%rbp), %rdi
callq 0xac88
leaq -0x660(%rbp), %rdi
callq 0xac88
leaq -0x220(%rbp), %rdi
leaq -0x620(%rbp), %rsi
callq 0x11d8c0
movq %rax, -0x9c8(%rbp)
jmp 0x11c440
movq -0x9c8(%rbp), %rax
cmpq $0x0, %rax
jne 0x11c543
movl $0x38, %edi
callq 0xa5d0
movq %rax, -0x9d0(%rbp)
jmp 0x11c464
movq -0x9d0(%rbp), %rdi
movl -0x5f8(%rbp), %esi
movl -0x5fc(%rbp), %edx
movsbl -0x5f1(%rbp), %ecx
movsbl -0x5f2(%rbp), %r8d
callq 0x11d8f0
jmp 0x11c48d
leaq -0x220(%rbp), %rdi
leaq -0x620(%rbp), %rsi
callq 0x11d990
movq %rax, -0x9d8(%rbp)
jmp 0x11c4a9
movq -0x9d8(%rbp), %rax
movq -0x9d0(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x11c5b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11c4ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11c4f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x680(%rbp), %rdi
callq 0xac88
leaq -0x640(%rbp), %rdi
callq 0xac88
leaq -0x660(%rbp), %rdi
callq 0xac88
jmp 0x11c84d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x11c5d5
movq -0x9d0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x38, %esi
callq 0xa5e0
jmp 0x11c5d5
leaq -0x220(%rbp), %rdi
leaq -0x620(%rbp), %rsi
callq 0x11d990
movq %rax, -0x9e0(%rbp)
jmp 0x11c55f
movq -0x9e0(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
leaq -0x5f1(%rbp), %rsi
callq 0xad990
jmp 0x11c57b
leaq -0x220(%rbp), %rdi
leaq -0x620(%rbp), %rsi
callq 0x11d990
movq %rax, -0x9e8(%rbp)
jmp 0x11c597
movq -0x9e8(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
leaq -0x5f2(%rbp), %rsi
callq 0xad990
jmp 0x11c5b3
jmp 0x11c5b5
leaq -0x620(%rbp), %rdi
callq 0xac88
movl -0x5f0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5f0(%rbp)
jmp 0x11c293
leaq -0x620(%rbp), %rdi
callq 0xac88
jmp 0x11c84d
jmp 0x11c5e8
movl -0x5ec(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5ec(%rbp)
jmp 0x11c245
jmp 0x11c5fe
jmp 0x11c600
movl -0x5e8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5e8(%rbp)
jmp 0x11c1e5
movq 0x7c99d(%rip), %rdi     # 0x198fb8
leaq 0x31f7e(%rip), %rsi     # 0x14e5a0
callq 0xa5c0
movq %rax, -0x9f0(%rbp)
jmp 0x11c630
leaq -0x220(%rbp), %rdi
callq 0x11d9c0
movq -0x9f0(%rbp), %rdi
movq %rax, %rsi
callq 0xa140
movq %rax, -0x9f8(%rbp)
jmp 0x11c654
movq -0x9f8(%rbp), %rdi
movq 0x7c926(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11c669
movq 0x7c948(%rip), %rdi     # 0x198fb8
leaq 0x31f3b(%rip), %rsi     # 0x14e5b2
callq 0xa5c0
movq %rax, -0xa00(%rbp)
jmp 0x11c685
movq -0xa00(%rbp), %rdi
movl -0x544(%rbp), %esi
callq 0xab20
movq %rax, -0xa08(%rbp)
jmp 0x11c6a0
movq -0xa08(%rbp), %rdi
movq 0x7c8da(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11c6b5
movq 0x7c8fc(%rip), %rdi     # 0x198fb8
leaq 0x31f08(%rip), %rsi     # 0x14e5cb
callq 0xa5c0
movq %rax, -0xa10(%rbp)
jmp 0x11c6d1
movq -0xa10(%rbp), %rdi
movl -0x548(%rbp), %esi
callq 0xab20
movq %rax, -0xa18(%rbp)
jmp 0x11c6ec
movq -0xa18(%rbp), %rdi
movq 0x7c88e(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11c701
movq 0x7c8b0(%rip), %rdi     # 0x198fb8
leaq 0x31ece(%rip), %rsi     # 0x14e5dd
callq 0xa5c0
movq %rax, -0xa20(%rbp)
jmp 0x11c71d
cvtsi2sdl -0x548(%rbp), %xmm0
movsd %xmm0, -0xa30(%rbp)
leaq -0x488(%rbp), %rdi
callq 0x11d740
movsd -0xa30(%rbp), %xmm0
movq -0xa20(%rbp), %rdi
imulq $0x12c, %rax, %rax      # imm = 0x12C
movq %rax, %xmm1
movaps 0x11a05(%rip), %xmm2    # 0x12e160
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x11a09(%rip), %xmm2    # 0x12e170
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0xabd0
movq %rax, -0xa28(%rbp)
jmp 0x11c788
movq -0xa28(%rbp), %rdi
movq 0x7c7f2(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x11c79d
jmp 0x11c79f
movl $0x1, -0x29c(%rbp)
leaq -0x560(%rbp), %rdi
callq 0x48290
leaq -0x540(%rbp), %rdi
callq 0x11d9e0
leaq -0x528(%rbp), %rdi
callq 0x3ecb0
leaq -0x510(%rbp), %rdi
callq 0x3ecb0
leaq -0x4f8(%rbp), %rdi
callq 0x3ecb0
leaq -0x4e0(%rbp), %rdi
callq 0x3ecb0
leaq -0x488(%rbp), %rdi
callq 0x11da40
leaq -0x220(%rbp), %rdi
callq 0x11daa0
leaq -0x1e0(%rbp), %rdi
callq 0x11dac0
leaq -0x1b0(%rbp), %rdi
callq 0x58f00
leaq -0x180(%rbp), %rdi
callq 0x70cd0
leaq -0x150(%rbp), %rdi
callq 0x11dae0
leaq -0x30(%rbp), %rdi
callq 0xac88
xorl %eax, %eax
addq $0xa30, %rsp            # imm = 0xA30
popq %rbp
retq
leaq -0x560(%rbp), %rdi
callq 0x48290
leaq -0x540(%rbp), %rdi
callq 0x11d9e0
leaq -0x528(%rbp), %rdi
callq 0x3ecb0
leaq -0x510(%rbp), %rdi
callq 0x3ecb0
leaq -0x4f8(%rbp), %rdi
callq 0x3ecb0
leaq -0x4e0(%rbp), %rdi
callq 0x3ecb0
leaq -0x488(%rbp), %rdi
callq 0x11da40
leaq -0x220(%rbp), %rdi
callq 0x11daa0
leaq -0x1e0(%rbp), %rdi
callq 0x11dac0
leaq -0x1b0(%rbp), %rdi
callq 0x58f00
leaq -0x180(%rbp), %rdi
callq 0x70cd0
leaq -0x150(%rbp), %rdi
callq 0x11dae0
leaq -0x30(%rbp), %rdi
callq 0xac88
movq -0x68(%rbp), %rdi
callq 0xab50
nop