// File: millanek[P]evo/evo_findDiscordantPairsFromSAM.cpp
// Function: DiscordPairsFromSAMMain(int, char**)
int DiscordPairsFromSAMMain(int argc, char** argv) {
    parseDiscordPairsFromSAMOptions(argc, argv);
    string line; // for reading the input files
    
    std::istream* hetsFile = createReader(opt::hetsFile.c_str());
    std::ifstream* samFile = new std::ifstream(opt::samFile.c_str());
    
    std::ofstream* phaseSwitchFile = new std::ofstream("switches" + opt::runName + ".txt");
    std::ofstream* recombFile = new std::ofstream("recombMap" + opt::runName + ".txt");
    
    std::map<int,PhaseInfo*> posToPhase;
    std::map<string,std::vector<int>> infoPairNameToPos;
    std::map<string,std::vector<string>> infoPairNameToStrands;
    std::vector<int> phaseBlockSNPnums;
    
    std::map<string,std::vector<RecombRead*>> samNameToReads;
    int numHetPairs = 0;
    std::unordered_map<string, ReadLinkSNPpair*> SNPpairs;
    
    
    std::cout << "1) Processing hets..." << std::endl;
    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++; phaseBlockSNPnums.push_back(0);
            } 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);
                posToPhase[snpPos] = thisPhase;
                phaseBlockSNPnums[blockNum-1]++;
            }
        }
        //maxBlockIndex = (int)std::distance(phaseBlockSNPnums.begin(),std::max_element(phaseBlockSNPnums.begin(), phaseBlockSNPnums.end()));
    } 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);
            posToPhase[snpPos] = thisPhase;
        }
        numHetPairs = nChoosek((int)posToPhase.size(),2);
    }
    
    
    
    std::cout << std::endl;
    std::cout << "2) Loading read-pairs... " << std::endl;
    // 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
    int readN = 0;
    std::vector<RecombRead*> informativeReads;
    while (getline(*samFile,line)) {
        // std::cerr << line << std::endl;
        readN++;
        std::vector<string> samRecVec = split(line, '\t'); //assert(pairVec.size() == 8);
        RecombRead* thisRead = new RecombRead(samRecVec);
        informativeReads.push_back(thisRead);
    }
    
    std::cout << std::endl;
    std::cout << "3) Linking read-pairs and hets... " << std::endl;
    int num0het = 0; int num1het = 0; int num2plusHets = 0;
    int totalUsedLength = 0;
    std::vector<RecombReadPair*> informativeReadPairs;
    for (int r = 0; r < informativeReads.size(); r=r+2) {
        RecombReadPair* thisReadPair = new RecombReadPair(informativeReads[r], informativeReads[r+1]);
        thisReadPair->findAndCombinePairHets(posToPhase);
        thisReadPair->filterHetsByQuality(opt::minBQ);
        
        if (thisReadPair->hetSites.size() == 0) {
            num0het++;
        } else if (thisReadPair->hetSites.size() == 1) {
            num1het++;
        } else {
            num2plusHets++;
        }
        
        if (thisReadPair->hetSites.size() > 1) {
            for (std::map<int, std::vector<int>>::iterator it = thisReadPair->read1->BlockIDsToHetPos.begin();
                 it != thisReadPair->read1->BlockIDsToHetPos.end(); it++) {
                if (thisReadPair->read2->BlockIDsToHetPos.count(it->first) == 1) {
                    informativeReadPairs.push_back(thisReadPair);
                    totalUsedLength += thisReadPair->read1->usedLength;
                    totalUsedLength += thisReadPair->read2->usedLength;
                }
            }
        }
    }
    
    std::cout << "Initial Read Pairs.size(): " << informativeReads.size()/2.0 << std::endl;
    std::cout << "num0het: " << num0het << std::endl;
    std::cout << "num1het: " << num1het << std::endl;
    std::cout << "num2plusHets: " << num2plusHets << std::endl;
    std::cout << "informativeReadPairs.size(): " << informativeReadPairs.size() << std::endl;
    std::cout << std::endl;
    
    std::cout << "4) Categorising concordant-discordant read-pairs... " << std::endl;
    int numConcordant = 0; int numDiscordant = 0;
    int numMatch = 0; int numMismatch = 0; long long int totalEffectiveLength = 0;
    std::vector<double> matchBaseScores; std::vector<double> mismatchBaseScores;
    std::vector<double> concordantBaseScores; std::vector<double> discordantBaseScores;
    std::vector<PhaseSwitch*> phaseSwitches;
    std::vector<std::vector<int>> phaseConcordanceCoords;
        
    
    std::vector<int> coveredHetPos;
    if (opt::hapcutFormat) {
        int readPairsProcessed = 0;
        for (int r = 0; r < informativeReadPairs.size(); r++) {
            readPairsProcessed++;
            
           for (int i = 0; i < informativeReadPairs[r]->hetSites.size(); i++) {
                HetInfo* thisHet = informativeReadPairs[r]->hetSites[i];
                if (thisHet->readPhaseBaseMismatch) {
                    numMismatch++;
                    mismatchBaseScores.push_back(thisHet->thisBaseQuality);
                } else {
                    // std::cout << "Fine: " << std::endl;
                     matchBaseScores.push_back(thisHet->thisBaseQuality);
                     numMatch++;
                }
               coveredHetPos.push_back(thisHet->pos);
            }
            
            // 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))
            
            // std::vector<PhaseSwitch*> thisPairSwitches;
            std::vector<int> switchPairI; std::vector<int> switchPairJ;
            std::vector<int> concordPairI; std::vector<int> concordPairJ;
            for (int i = 0; i < informativeReadPairs[r]->hetSites.size() - 1; i++) {
                for (int j = 1; j < informativeReadPairs[r]->hetSites.size(); j++) {
                    if (informativeReadPairs[r]->hetSites[i]->phaseBlock == informativeReadPairs[r]->hetSites[j]->phaseBlock) {
                        int phaseI = informativeReadPairs[r]->hetSites[i]->thisHetPhase01;
                        int phaseJ = informativeReadPairs[r]->hetSites[j]->thisHetPhase01;
                        int iPos = informativeReadPairs[r]->hetSites[i]->pos;
                        int jPos = informativeReadPairs[r]->hetSites[j]->pos;
                        if (phaseI != phaseJ && abs(jPos - iPos) > opt::minDist) {
                            switchPairI.push_back(i); switchPairJ.push_back(j);
                            //int iPos = informativeReadPairs[r]->hetSites[i]->pos;
                            //int jPos = informativeReadPairs[r]->hetSites[j]->pos;
                            //int iQual = informativeReadPairs[r]->hetSites[i]->thisPhaseQuality;
                            //int jQual = informativeReadPairs[r]->hetSites[j]->thisPhaseQuality;
                            // PhaseSwitch* thisSwitch = new PhaseSwitch(iPos, jPos, iQual, jQual);
                            // thisPairSwitches.push_back(thisSwitch);
                        } else {
                            concordPairI.push_back(i); concordPairJ.push_back(j);
                        }
                    }
                }
            }
            
            // TO DO:
            // Select the 'right' switch pair if there are multiple options:
            // The shortest one? Needs more thought....
            if (switchPairI.size() > 0) {
                numDiscordant++;
                int iPos = informativeReadPairs[r]->hetSites[switchPairI[0]]->pos;
                int jPos = informativeReadPairs[r]->hetSites[switchPairJ[0]]->pos;
                int iQual = informativeReadPairs[r]->hetSites[switchPairI[0]]->thisPhaseQuality;
                int jQual = informativeReadPairs[r]->hetSites[switchPairJ[0]]->thisPhaseQuality;
                if (jPos - iPos < 0) {
                    int tmp = iPos; iPos = jPos; jPos = tmp;
                    tmp = iQual; iQual = jQual; jQual = tmp;
                }
                PhaseSwitch* thisSwitch = new PhaseSwitch(iPos, jPos, iQual, jQual);
                phaseSwitches.push_back(thisSwitch);
                switchPairI.empty(); switchPairJ.empty();
                totalEffectiveLength = totalEffectiveLength + (jPos - iPos);
                
            } else {
                numConcordant++;
                std::vector<int> thisConcordantCoords;
                int maxD = 0; int maxDindex = 0;
                for (int i = 0; i != concordPairI.size(); i++) {
                    int iPos = informativeReadPairs[r]->hetSites[concordPairI[i]]->pos;
                    int jPos = informativeReadPairs[r]->hetSites[concordPairJ[i]]->pos;
                    if (abs(jPos - iPos) > maxD) {
                        maxDindex = i;
                    }
                }
                int iPosDindex = informativeReadPairs[r]->hetSites[concordPairI[maxDindex]]->pos;
                int jPosDindex = informativeReadPairs[r]->hetSites[concordPairJ[maxDindex]]->pos;
                if (jPosDindex - iPosDindex < 0) {
                    int tmp = iPosDindex; iPosDindex = jPosDindex; jPosDindex = tmp;
                }
                
                int concordantPairDist = jPosDindex - iPosDindex;
                totalEffectiveLength = totalEffectiveLength + concordantPairDist;
                thisConcordantCoords.push_back(iPosDindex);
                thisConcordantCoords.push_back(jPosDindex);
                thisConcordantCoords.push_back(concordantPairDist);
                phaseConcordanceCoords.push_back(thisConcordantCoords);
            }
          /*  if (readPairsProcessed % 10000 == 0) {
                std::cout << "readPairsProcessed: " << readPairsProcessed << std::endl;
               // std::cout << "informativeReadPairs[r]->hetSites.size(): " << informativeReadPairs[r]->hetSites.size() << std::endl;
                std::cout << "phaseSwitches.size(): " << phaseSwitches.size() << std::endl;
                std::cout << "Effective coverage (bp): " << totalEffectiveLength << std::endl;
                std::cout << std::endl;
            } */
        }
        
        std::cout << "Effective coverage (bp): " << totalEffectiveLength << std::endl;
        std::cout << "numConcordant: " << numConcordant << std::endl;
        std::cout << "numDiscordant: " << numDiscordant << std::endl;
        std::cout << "phaseConcordanceCoords.size(): " << phaseConcordanceCoords.size() << 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;
        }
        
        
        
        std::cout << std::endl;
        std::cout << "5) Making a genetic map... " << std::endl;
        std::sort(coveredHetPos.begin(), coveredHetPos.end());
        std::vector<int>::iterator it = std::unique(coveredHetPos.begin(), coveredHetPos.end());
        coveredHetPos.resize(distance(coveredHetPos.begin(),it));
        std::cout << "coveredHetPos.size() " << coveredHetPos.size() << std::endl;
        
        double meanRecombinationRate = (double)numDiscordant/(double)totalEffectiveLength;
        std::cout << "meanRecombinationRate " << meanRecombinationRate << std::endl;
        std::vector<double> recombFractions(coveredHetPos.size()+1, meanRecombinationRate);
        
        int numProcessedHets = 0;
        for (int i = 0; i != coveredHetPos.size() - 1; i++) {
            int left = coveredHetPos[i];
            int right = coveredHetPos[i + 1];
            //int distSNPs = (right - left) + 1;
            
            int coveringReadPairs = 0;
            
            double totalRecombFractionPerBP = 0;
            for (int j = 0; j != phaseSwitches.size(); j++) {
                if(phaseSwitches[j]->posLeft <= left && phaseSwitches[j]->posRight >= right){
                    coveringReadPairs++;
                    double recombFractionPerBP = (double)1.0/(double)phaseSwitches[j]->dist;
                    totalRecombFractionPerBP += recombFractionPerBP;
                }
            }
          //  std::cout << "totalRecombFraction: " << totalRecombFraction << std::endl;
            
            double totalConcordantFraction = 0;
            for (int j = 0; j != phaseConcordanceCoords.size(); j++) {
                if(phaseConcordanceCoords[j][0] <= left && phaseConcordanceCoords[j][1] >= right){
                    coveringReadPairs++;
                    //double concordPairFraction = (double)distSNPs/(double)(phaseConcordanceCoords[j][2]);
                    totalConcordantFraction++;
                }
            }
           // std::cout << "totalConcordantFraction: " << totalConcordantFraction << std::endl;
            
            if (coveringReadPairs > 10) {
                recombFractions[i+1] = totalRecombFractionPerBP/totalConcordantFraction;
            }
            
            numProcessedHets++;
            if (numProcessedHets % 10000 == 0) {
                std::cout << "numProcessedHets: " << numProcessedHets << " ("<< (double)numProcessedHets/coveredHetPos.size() << "%)"<< std::endl;
                std::cout << "pos: " << left << "bp"<< std::endl;
                
            }
            
        }
        
        *recombFile << "0\t" << coveredHetPos[0] << "\t" << recombFractions[0] << std::endl;
        for (int i = 1; i != coveredHetPos.size(); i++) {
            *recombFile << coveredHetPos[i-1] << "\t" << coveredHetPos[i] << "\t" << recombFractions[i] << std::endl;
        }
        //int chrSize = 0;
        //*recombFile << coveredHetPos.back() << "\t" <<  << "\t" << recombFractions[i] << std::endl;
        //print_vector(coveredHetPos, std::cout);
        
        
    } else {
        for (int r = 0; r < informativeReadPairs.size(); r++) {
            if (informativeReadPairs[r]->hetSites.size() > 1) {
                for (int i = 0; i < informativeReadPairs[r]->hetSites.size() - 1; i++) {
                    for (int j = 1; j < informativeReadPairs[r]->hetSites.size(); j++) {
                        char readBase1 = informativeReadPairs[r]->hetSites[i]->thisBase;
                        char readBase2 = informativeReadPairs[r]->hetSites[j]->thisBase;
                        int pos1 = informativeReadPairs[r]->hetSites[i]->pos;
                        int pos2 = informativeReadPairs[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 << "totalUsedLength: " << totalUsedLength << std::endl;
        std::cout << "totalUsedLength/(goodReadPairs.size()*300): " << (double)totalUsedLength/(double)(informativeReadPairs.size()*300) << std::endl;
    }
    
    return 0;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb70, %rsp            # imm = 0xB70
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12d140
leaq -0x30(%rbp), %rdi
callq 0xa820
leaq 0x7190a(%rip), %rdi     # 0x19b8b8
callq 0xa220
movq %rax, -0x6f0(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x6e8(%rbp)
callq 0xab60
movq -0x6f0(%rbp), %rsi
movq -0x6e8(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x2d6c0
jmp 0x129fe3
leaq -0x58(%rbp), %rdi
movl $0x8, %esi
callq 0x80e30
movq %rax, -0x6f8(%rbp)
jmp 0x129ffa
leaq -0x58(%rbp), %rdi
callq 0xac88
leaq -0x59(%rbp), %rdi
callq 0xa640
movq -0x6f8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x208, %edi            # imm = 0x208
callq 0xa5d0
movq %rax, -0x700(%rbp)
jmp 0x12a02a
leaq 0x718a7(%rip), %rdi     # 0x19b8d8
callq 0xa220
movq -0x700(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0xab90
jmp 0x12a04c
movq -0x700(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x200, %edi            # imm = 0x200
callq 0xa5d0
movq %rax, -0x708(%rbp)
jmp 0x12a06a
movb $0x1, -0xc1(%rbp)
leaq 0x2438e(%rip), %rsi     # 0x14e406
leaq 0x71879(%rip), %rdx     # 0x19b8f8
leaq -0xc0(%rbp), %rdi
callq 0xba820
jmp 0x12a08d
leaq 0x1f513(%rip), %rdx     # 0x1495a7
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x3e020
jmp 0x12a0a9
movq -0x708(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x10, %edx
callq 0xac00
jmp 0x12a0c3
movb $0x0, -0xc1(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xac88
leaq -0xc0(%rbp), %rdi
callq 0xac88
movq -0x708(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x200, %edi            # imm = 0x200
callq 0xa5d0
movq %rax, -0x710(%rbp)
jmp 0x12a100
movb $0x1, -0x111(%rbp)
leaq 0x24bb1(%rip), %rsi     # 0x14ecbf
leaq 0x717e3(%rip), %rdx     # 0x19b8f8
leaq -0x110(%rbp), %rdi
callq 0xba820
jmp 0x12a123
leaq 0x1f47d(%rip), %rdx     # 0x1495a7
leaq -0xf0(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x3e020
jmp 0x12a13f
movq -0x710(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
movl $0x10, %edx
callq 0xac00
jmp 0x12a159
movb $0x0, -0x111(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0xac88
leaq -0x110(%rbp), %rdi
callq 0xac88
movq -0x710(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x11cc50
leaq -0x178(%rbp), %rdi
callq 0x73cf0
leaq -0x1a8(%rbp), %rdi
callq 0x58920
leaq -0x1c0(%rbp), %rdi
callq 0x46270
leaq -0x1f0(%rbp), %rdi
callq 0x11cc70
movl $0x0, -0x1f4(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x11cc90
movq 0x6edd9(%rip), %rdi     # 0x198fb8
leaq 0x24ae3(%rip), %rsi     # 0x14ecc9
callq 0xa5c0
movq %rax, -0x718(%rbp)
jmp 0x12a1f4
movq -0x718(%rbp), %rdi
movq 0x6ed86(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12a209
testb $0x1, 0x71708(%rip)     # 0x19b918
je 0x12a892
movl $0x0, -0x234(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa0d0
movq %rax, -0x720(%rbp)
jmp 0x12a236
movq -0x720(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x721(%rbp)
jmp 0x12a254
movb -0x721(%rbp), %al
testb $0x1, %al
jne 0x12a263
jmp 0x12a88d
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0xac60
movq %rax, -0x730(%rbp)
jmp 0x12a279
movq -0x730(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x12a3c8
jmp 0x12a888
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12a2b4
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 0x12d12b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12d12b
movq -0x700(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0xa5e0
jmp 0x12d12b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12a335
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12a329
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xac88
leaq -0xc0(%rbp), %rdi
callq 0xac88
testb $0x1, -0xc1(%rbp)
jne 0x12a340
jmp 0x12a351
movq -0x708(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0xa5e0
jmp 0x12d12b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12a396
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12a38a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0xac88
leaq -0x110(%rbp), %rdi
callq 0xac88
testb $0x1, -0x111(%rbp)
jne 0x12a3a1
jmp 0x12a3b2
movq -0x710(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0xa5e0
jmp 0x12d12b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12d0e3
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0xac60
movq %rax, -0x738(%rbp)
jmp 0x12a3de
movq -0x738(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x42, %eax
jne 0x12a445
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0xac60
movq %rax, -0x740(%rbp)
jmp 0x12a404
movq -0x740(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4c, %eax
jne 0x12a445
movl -0x234(%rbp), %eax
incl %eax
movl %eax, -0x234(%rbp)
movl $0x0, -0x238(%rbp)
leaq -0x1c0(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x4ce80
jmp 0x12a440
jmp 0x12a886
leaq -0x250(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x9, %edx
callq 0x7bbe0
jmp 0x12a45c
leaq -0x250(%rbp), %rdi
movl $0x4, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movl %eax, -0x254(%rbp)
leaq -0x250(%rbp), %rdi
movl $0x1, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movl %eax, -0x258(%rbp)
leaq -0x250(%rbp), %rdi
movl $0x2, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movl %eax, -0x25c(%rbp)
leaq -0x250(%rbp), %rdi
movl $0x5, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa930
cmpq $0x1, %rax
jne 0x12a4f2
jmp 0x12a511
leaq 0x23f24(%rip), %rdi     # 0x14e41d
leaq 0x247df(%rip), %rsi     # 0x14ecdf
movl $0x6d, %edx
leaq 0x247f6(%rip), %rcx     # 0x14ed02
callq 0xa390
leaq -0x250(%rbp), %rdi
movl $0x6, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa930
cmpq $0x1, %rax
jne 0x12a532
jmp 0x12a551
leaq 0x23f45(%rip), %rdi     # 0x14e47e
leaq 0x2479f(%rip), %rsi     # 0x14ecdf
movl $0x6d, %edx
leaq 0x247b6(%rip), %rcx     # 0x14ed02
callq 0xa390
leaq -0x250(%rbp), %rdi
movl $0x5, %esi
callq 0x3d940
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xac60
movq %rax, -0x748(%rbp)
jmp 0x12a577
movq -0x748(%rbp), %rax
movb (%rax), %al
movb %al, -0x25d(%rbp)
leaq -0x250(%rbp), %rdi
movl $0x6, %esi
callq 0x3d940
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xac60
movq %rax, -0x750(%rbp)
jmp 0x12a5ac
movq -0x750(%rbp), %rax
movb (%rax), %al
movb %al, -0x25e(%rbp)
leaq -0x250(%rbp), %rdi
movl $0xa, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, -0x760(%rbp)
leaq -0x289(%rbp), %rdi
movq %rdi, -0x758(%rbp)
callq 0xab60
movq -0x760(%rbp), %rsi
movq -0x758(%rbp), %rdx
leaq -0x288(%rbp), %rdi
callq 0x2d6c0
jmp 0x12a60a
leaq -0x288(%rbp), %rdi
callq 0x7bab0
movsd %xmm0, -0x768(%rbp)
jmp 0x12a620
leaq -0x288(%rbp), %rdi
callq 0xac88
leaq -0x289(%rbp), %rdi
callq 0xa640
movsd -0x768(%rbp), %xmm0
movsd %xmm0, -0x268(%rbp)
leaq -0x250(%rbp), %rdi
movl $0xb, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movl %eax, -0x290(%rbp)
leaq -0x2a8(%rbp), %rdi
callq 0xad970
cmpl $0x0, -0x258(%rbp)
jne 0x12a71d
cmpl $0x1, -0x25c(%rbp)
jne 0x12a71d
leaq -0x2a8(%rbp), %rdi
leaq -0x25d(%rbp), %rsi
callq 0xad990
jmp 0x12a6aa
leaq -0x2a8(%rbp), %rdi
leaq -0x25e(%rbp), %rsi
callq 0xad990
jmp 0x12a6bf
jmp 0x12a76c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12a875
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12a6fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x288(%rbp), %rdi
callq 0xac88
leaq -0x289(%rbp), %rdi
callq 0xa640
jmp 0x12a875
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12a869
cmpl $0x1, -0x258(%rbp)
jne 0x12a75b
cmpl $0x0, -0x25c(%rbp)
jne 0x12a75b
leaq -0x2a8(%rbp), %rdi
leaq -0x25e(%rbp), %rsi
callq 0xad990
jmp 0x12a744
leaq -0x2a8(%rbp), %rdi
leaq -0x25d(%rbp), %rsi
callq 0xad990
jmp 0x12a759
jmp 0x12a76a
movl $0x2, -0x2ac(%rbp)
jmp 0x12a821
jmp 0x12a76c
movl $0x30, %edi
callq 0xa5d0
movq %rax, -0x770(%rbp)
jmp 0x12a77f
movq -0x770(%rbp), %rdi
movl -0x254(%rbp), %esi
movsd -0x268(%rbp), %xmm0
movl -0x290(%rbp), %edx
movl -0x234(%rbp), %r8d
leaq -0x2a8(%rbp), %rcx
callq 0x11ccb0
jmp 0x12a7af
movq -0x770(%rbp), %rax
movq %rax, -0x2b8(%rbp)
movq -0x2b8(%rbp), %rax
movq %rax, -0x780(%rbp)
leaq -0x148(%rbp), %rdi
leaq -0x254(%rbp), %rsi
callq 0x11cd40
movq %rax, -0x778(%rbp)
jmp 0x12a7e7
movq -0x778(%rbp), %rax
movq -0x780(%rbp), %rcx
movq %rcx, (%rax)
movl -0x234(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq -0x1c0(%rbp), %rdi
callq 0x4d100
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x0, -0x2ac(%rbp)
leaq -0x2a8(%rbp), %rdi
callq 0xae570
leaq -0x250(%rbp), %rdi
callq 0x3dfa0
movl -0x2ac(%rbp), %eax
testl %eax, %eax
je 0x12a84a
jmp 0x12a845
jmp 0x12a220
jmp 0x12a886
movq -0x770(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x30, %esi
callq 0xa5e0
leaq -0x2a8(%rbp), %rdi
callq 0xae570
leaq -0x250(%rbp), %rdi
callq 0x3dfa0
jmp 0x12d0e3
jmp 0x12a888
jmp 0x12a220
jmp 0x12ab7b
jmp 0x12a894
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa0d0
movq %rax, -0x788(%rbp)
jmp 0x12a8aa
movq -0x788(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x789(%rbp)
jmp 0x12a8c8
movb -0x789(%rbp), %al
testb $0x1, %al
jne 0x12a8d7
jmp 0x12ab4f
leaq -0x2d0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x9, %edx
callq 0x7bbe0
jmp 0x12a8ee
leaq -0x2d0(%rbp), %rdi
movl $0x1, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa220
movq %rax, %rdi
callq 0xa970
movl %eax, -0x2d4(%rbp)
leaq -0x2d0(%rbp), %rdi
movl $0x2, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa930
cmpq $0x1, %rax
jne 0x12a936
jmp 0x12a955
leaq 0x23b63(%rip), %rdi     # 0x14e4a0
leaq 0x2439b(%rip), %rsi     # 0x14ecdf
movl $0x84, %edx
leaq 0x243b2(%rip), %rcx     # 0x14ed02
callq 0xa390
leaq -0x2d0(%rbp), %rdi
movl $0x3, %esi
callq 0x3d940
movq %rax, %rdi
callq 0xa930
cmpq $0x1, %rax
jne 0x12a976
jmp 0x12a995
leaq 0x23b45(%rip), %rdi     # 0x14e4c2
leaq 0x2435b(%rip), %rsi     # 0x14ecdf
movl $0x84, %edx
leaq 0x24372(%rip), %rcx     # 0x14ed02
callq 0xa390
leaq -0x2d0(%rbp), %rdi
movl $0x2, %esi
callq 0x3d940
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xac60
movq %rax, -0x798(%rbp)
jmp 0x12a9bb
movq -0x798(%rbp), %rax
movb (%rax), %al
movb %al, -0x2d5(%rbp)
leaq -0x2d0(%rbp), %rdi
movl $0x3, %esi
callq 0x3d940
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xac60
movq %rax, -0x7a0(%rbp)
jmp 0x12a9f0
movq -0x7a0(%rbp), %rax
movb (%rax), %al
movb %al, -0x2d6(%rbp)
leaq -0x2f0(%rbp), %rdi
movq %rdi, -0x7a8(%rbp)
callq 0xad970
movq -0x7a8(%rbp), %rdi
leaq -0x2d5(%rbp), %rsi
callq 0xad990
jmp 0x12aa27
leaq -0x2f0(%rbp), %rdi
leaq -0x2d6(%rbp), %rsi
callq 0xad990
jmp 0x12aa3c
movq $0x0, -0x2f8(%rbp)
movl $0x0, -0x2fc(%rbp)
movl $0x30, %edi
callq 0xa5d0
movq %rax, -0x7b0(%rbp)
jmp 0x12aa64
movq -0x7b0(%rbp), %rdi
movl -0x2d4(%rbp), %esi
movsd -0x2f8(%rbp), %xmm0
movl -0x2fc(%rbp), %edx
leaq -0x2f0(%rbp), %rcx
movl $0x1, %r8d
callq 0x11ccb0
jmp 0x12aa93
movq -0x7b0(%rbp), %rax
movq %rax, -0x308(%rbp)
movq -0x308(%rbp), %rax
movq %rax, -0x7c0(%rbp)
leaq -0x148(%rbp), %rdi
leaq -0x2d4(%rbp), %rsi
callq 0x11cd40
movq %rax, -0x7b8(%rbp)
jmp 0x12aacb
movq -0x7b8(%rbp), %rax
movq -0x7c0(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x2f0(%rbp), %rdi
callq 0xae570
leaq -0x2d0(%rbp), %rdi
callq 0x3dfa0
jmp 0x12a894
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12ab3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12ab32
movq -0x7b0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x30, %esi
callq 0xa5e0
leaq -0x2f0(%rbp), %rdi
callq 0xae570
leaq -0x2d0(%rbp), %rdi
callq 0x3dfa0
jmp 0x12d0e3
leaq -0x148(%rbp), %rdi
callq 0x11ce20
movl %eax, %edi
movl $0x2, %esi
callq 0xf55c0
movl %eax, -0x7c4(%rbp)
jmp 0x12ab6f
movl -0x7c4(%rbp), %eax
movl %eax, -0x1f4(%rbp)
movq 0x6e436(%rip), %rdi     # 0x198fb8
movq 0x6e3ff(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12ab90
movq 0x6e421(%rip), %rdi     # 0x198fb8
leaq 0x2418e(%rip), %rsi     # 0x14ed2c
callq 0xa5c0
movq %rax, -0x7d0(%rbp)
jmp 0x12abac
movq -0x7d0(%rbp), %rdi
movq 0x6e3ce(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12abc1
movl $0x0, -0x30c(%rbp)
leaq -0x328(%rbp), %rdi
callq 0x1213d0
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa0d0
movq %rax, -0x7d8(%rbp)
jmp 0x12abed
movq -0x7d8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xa740
movb %al, -0x7d9(%rbp)
jmp 0x12ac0b
movb -0x7d9(%rbp), %al
testb $0x1, %al
jne 0x12ac1a
jmp 0x12ad3e
movl -0x30c(%rbp), %eax
incl %eax
movl %eax, -0x30c(%rbp)
leaq -0x340(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x9, %edx
callq 0x7bbe0
jmp 0x12ac3f
movl $0x150, %edi            # imm = 0x150
callq 0xa5d0
movq %rax, -0x7e8(%rbp)
jmp 0x12ac52
movb $0x1, -0x361(%rbp)
leaq -0x360(%rbp), %rdi
leaq -0x340(%rbp), %rsi
callq 0x3fee0
jmp 0x12ac6e
movq -0x7e8(%rbp), %rdi
leaq -0x360(%rbp), %rsi
callq 0x11ce40
jmp 0x12ac83
movb $0x0, -0x361(%rbp)
leaq -0x360(%rbp), %rdi
callq 0x3dfa0
movq -0x7e8(%rbp), %rax
movq %rax, -0x348(%rbp)
leaq -0x328(%rbp), %rdi
leaq -0x348(%rbp), %rsi
callq 0x11d2d0
jmp 0x12acb9
leaq -0x340(%rbp), %rdi
callq 0x3dfa0
jmp 0x12abd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12d0d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12ad2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12ad0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x360(%rbp), %rdi
callq 0x3dfa0
testb $0x1, -0x361(%rbp)
jne 0x12ad1a
jmp 0x12ad2b
movq -0x7e8(%rbp), %rdi
movl $0x150, %esi            # imm = 0x150
callq 0xa5e0
jmp 0x12ad2d
leaq -0x340(%rbp), %rdi
callq 0x3dfa0
jmp 0x12d0d7
movq 0x6e273(%rip), %rdi     # 0x198fb8
movq 0x6e23c(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12ad53
movq 0x6e25e(%rip), %rdi     # 0x198fb8
leaq 0x23fe5(%rip), %rsi     # 0x14ed46
callq 0xa5c0
movq %rax, -0x7f0(%rbp)
jmp 0x12ad6f
movq -0x7f0(%rbp), %rdi
movq 0x6e20b(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12ad84
movl $0x0, -0x368(%rbp)
movl $0x0, -0x36c(%rbp)
movl $0x0, -0x370(%rbp)
movl $0x0, -0x374(%rbp)
leaq -0x390(%rbp), %rdi
callq 0x11d340
movl $0x0, -0x394(%rbp)
movslq -0x394(%rbp), %rax
movq %rax, -0x7f8(%rbp)
leaq -0x328(%rbp), %rdi
callq 0x11d530
movq %rax, %rcx
movq -0x7f8(%rbp), %rax
cmpq %rcx, %rax
jae 0x12b059
movl $0x30, %edi
callq 0xa5d0
movq %rax, -0x800(%rbp)
jmp 0x12ae02
movslq -0x394(%rbp), %rsi
leaq -0x328(%rbp), %rdi
movq %rdi, -0x810(%rbp)
callq 0x11d550
movq -0x810(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x808(%rbp)
movl -0x394(%rbp), %eax
incl %eax
movslq %eax, %rsi
callq 0x11d550
movq -0x800(%rbp), %rdi
movq -0x808(%rbp), %rsi
movq (%rax), %rdx
callq 0x11d570
jmp 0x12ae55
movq -0x800(%rbp), %rax
movq %rax, -0x3a0(%rbp)
movq -0x3a0(%rbp), %rdi
leaq -0x148(%rbp), %rsi
callq 0x126a70
jmp 0x12ae78
movq -0x3a0(%rbp), %rdi
movl 0x6ec4b(%rip), %esi     # 0x199ad0
callq 0x126ba0
jmp 0x12ae8c
movq -0x3a0(%rbp), %rdi
addq $0x18, %rdi
callq 0x11d780
cmpq $0x0, %rax
jne 0x12aee6
movl -0x368(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x368(%rbp)
jmp 0x12af1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12d0cb
movq -0x800(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x30, %esi
callq 0xa5e0
jmp 0x12d0cb
movq -0x3a0(%rbp), %rdi
addq $0x18, %rdi
callq 0x11d780
cmpq $0x1, %rax
jne 0x12af0d
movl -0x36c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x36c(%rbp)
jmp 0x12af1c
movl -0x370(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x370(%rbp)
jmp 0x12af1e
movq -0x3a0(%rbp), %rdi
addq $0x18, %rdi
callq 0x11d780
cmpq $0x1, %rax
jbe 0x12b043
movq -0x3a0(%rbp), %rax
movq (%rax), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x12d4a0
movq %rax, -0x3a8(%rbp)
movq -0x3a0(%rbp), %rax
movq (%rax), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0xa5b30
movq %rax, -0x3b0(%rbp)
leaq -0x3a8(%rbp), %rdi
leaq -0x3b0(%rbp), %rsi
callq 0x12d4d0
testb $0x1, %al
jne 0x12af8e
jmp 0x12b041
movq -0x3a0(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x120, %rax            # imm = 0x120
movq %rax, -0x820(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x12d500
movq -0x820(%rbp), %rdi
movq %rax, %rsi
callq 0x1271d0
movq %rax, -0x818(%rbp)
jmp 0x12afca
movq -0x818(%rbp), %rax
cmpq $0x1, %rax
jne 0x12b025
leaq -0x390(%rbp), %rdi
leaq -0x3a0(%rbp), %rsi
callq 0x11d5d0
jmp 0x12afec
movq -0x3a0(%rbp), %rax
movq (%rax), %rax
movl 0x100(%rax), %eax
addl -0x374(%rbp), %eax
movl %eax, -0x374(%rbp)
movq -0x3a0(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x100(%rax), %eax
addl -0x374(%rbp), %eax
movl %eax, -0x374(%rbp)
jmp 0x12b027
leaq -0x3a8(%rbp), %rdi
xorl %esi, %esi
callq 0x12d520
movq %rax, -0x3b8(%rbp)
jmp 0x12af55
jmp 0x12b043
jmp 0x12b045
movl -0x394(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x394(%rbp)
jmp 0x12adc2
movq 0x6df58(%rip), %rdi     # 0x198fb8
leaq 0x23d02(%rip), %rsi     # 0x14ed69
callq 0xa5c0
movq %rax, -0x828(%rbp)
jmp 0x12b075
leaq -0x328(%rbp), %rdi
callq 0x11d530
movq -0x828(%rbp), %rdi
movq %rax, %xmm0
movaps 0x30cc(%rip), %xmm1     # 0x12e160
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x30d0(%rip), %xmm1     # 0x12e170
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x3051(%rip), %xmm1     # 0x12e108
mulsd %xmm1, %xmm0
callq 0xabd0
movq %rax, -0x830(%rbp)
jmp 0x12b0c9
movq -0x830(%rbp), %rdi
movq 0x6deb1(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12b0de
movq 0x6ded3(%rip), %rdi     # 0x198fb8
leaq 0x23427(%rip), %rsi     # 0x14e513
callq 0xa5c0
movq %rax, -0x838(%rbp)
jmp 0x12b0fa
movq -0x838(%rbp), %rdi
movl -0x368(%rbp), %esi
callq 0xab20
movq %rax, -0x840(%rbp)
jmp 0x12b115
movq -0x840(%rbp), %rdi
movq 0x6de65(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12b12a
movq 0x6de87(%rip), %rdi     # 0x198fb8
leaq 0x233e5(%rip), %rsi     # 0x14e51d
callq 0xa5c0
movq %rax, -0x848(%rbp)
jmp 0x12b146
movq -0x848(%rbp), %rdi
movl -0x36c(%rbp), %esi
callq 0xab20
movq %rax, -0x850(%rbp)
jmp 0x12b161
movq -0x850(%rbp), %rdi
movq 0x6de19(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12b176
movq 0x6de3b(%rip), %rdi     # 0x198fb8
leaq 0x233a3(%rip), %rsi     # 0x14e527
callq 0xa5c0
movq %rax, -0x858(%rbp)
jmp 0x12b192
movq -0x858(%rbp), %rdi
movl -0x370(%rbp), %esi
callq 0xab20
movq %rax, -0x860(%rbp)
jmp 0x12b1ad
movq -0x860(%rbp), %rdi
movq 0x6ddcd(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12b1c2
movq 0x6ddef(%rip), %rdi     # 0x198fb8
leaq 0x23bb5(%rip), %rsi     # 0x14ed85
callq 0xa5c0
movq %rax, -0x868(%rbp)
jmp 0x12b1de
leaq -0x390(%rbp), %rdi
callq 0x11d740
movq -0x868(%rbp), %rdi
movq %rax, %rsi
callq 0xa140
movq %rax, -0x870(%rbp)
jmp 0x12b202
movq -0x870(%rbp), %rdi
movq 0x6dd78(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12b217
movq 0x6dd9a(%rip), %rdi     # 0x198fb8
movq 0x6dd63(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12b22c
movq 0x6dd85(%rip), %rdi     # 0x198fb8
leaq 0x23b69(%rip), %rsi     # 0x14eda3
callq 0xa5c0
movq %rax, -0x878(%rbp)
jmp 0x12b248
movq -0x878(%rbp), %rdi
movq 0x6dd32(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12b25d
movl $0x0, -0x3bc(%rbp)
movl $0x0, -0x3c0(%rbp)
movl $0x0, -0x3c4(%rbp)
movl $0x0, -0x3c8(%rbp)
movq $0x0, -0x3d0(%rbp)
leaq -0x3e8(%rbp), %rdi
callq 0x48410
leaq -0x400(%rbp), %rdi
callq 0x48410
leaq -0x418(%rbp), %rdi
callq 0x48410
leaq -0x430(%rbp), %rdi
callq 0x48410
leaq -0x448(%rbp), %rdi
callq 0x11d720
leaq -0x460(%rbp), %rdi
callq 0x6ccb0
leaq -0x478(%rbp), %rdi
callq 0x46270
testb $0x1, 0x7062d(%rip)     # 0x19b918
je 0x12ca2d
movl $0x0, -0x47c(%rbp)
movl $0x0, -0x480(%rbp)
movslq -0x480(%rbp), %rax
movq %rax, -0x880(%rbp)
leaq -0x390(%rbp), %rdi
callq 0x11d740
movq %rax, %rcx
movq -0x880(%rbp), %rax
cmpq %rcx, %rax
jae 0x12bcd0
movl -0x47c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x47c(%rbp)
movl $0x0, -0x484(%rbp)
movslq -0x484(%rbp), %rax
movq %rax, -0x888(%rbp)
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
movq %rax, %rcx
movq -0x888(%rbp), %rax
cmpq %rcx, %rax
jae 0x12b475
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x484(%rbp), %rsi
callq 0x11d7a0
movq (%rax), %rax
movq %rax, -0x490(%rbp)
movq -0x490(%rbp), %rax
testb $0x1, 0x24(%rax)
je 0x12b412
movl -0x3c8(%rbp), %eax
incl %eax
movl %eax, -0x3c8(%rbp)
movq -0x490(%rbp), %rax
cvtsi2sdl 0xc(%rax), %xmm0
movsd %xmm0, -0x498(%rbp)
leaq -0x400(%rbp), %rdi
leaq -0x498(%rbp), %rsi
callq 0x48450
jmp 0x12b3ff
jmp 0x12b44a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12d077
movq -0x490(%rbp), %rax
cvtsi2sdl 0xc(%rax), %xmm0
movsd %xmm0, -0x4a0(%rbp)
leaq -0x3e8(%rbp), %rdi
leaq -0x4a0(%rbp), %rsi
callq 0x48450
jmp 0x12b43b
movl -0x3c4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c4(%rbp)
movq -0x490(%rbp), %rsi
leaq -0x478(%rbp), %rdi
callq 0x6b600
jmp 0x12b45f
jmp 0x12b461
movl -0x484(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x484(%rbp)
jmp 0x12b34b
leaq -0x4b8(%rbp), %rdi
callq 0x46270
leaq -0x4d0(%rbp), %rdi
callq 0x46270
leaq -0x4e8(%rbp), %rdi
callq 0x46270
leaq -0x500(%rbp), %rdi
callq 0x46270
movl $0x0, -0x504(%rbp)
movslq -0x504(%rbp), %rax
movq %rax, -0x890(%rbp)
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
movq %rax, %rcx
movq -0x890(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x12b730
movl $0x1, -0x508(%rbp)
movslq -0x508(%rbp), %rax
movq %rax, -0x898(%rbp)
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
movq %rax, %rcx
movq -0x898(%rbp), %rax
cmpq %rcx, %rax
jae 0x12b71a
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x504(%rbp), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x89c(%rbp)
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x508(%rbp), %rsi
callq 0x11d7a0
movq %rax, %rcx
movl -0x89c(%rbp), %eax
movq (%rcx), %rcx
cmpl 0x4(%rcx), %eax
jne 0x12b704
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x504(%rbp), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl 0x20(%rax), %eax
movl %eax, -0x50c(%rbp)
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x508(%rbp), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl 0x20(%rax), %eax
movl %eax, -0x510(%rbp)
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x504(%rbp), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x514(%rbp)
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x508(%rbp), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x518(%rbp)
movl -0x50c(%rbp), %eax
cmpl -0x510(%rbp), %eax
je 0x12b6d6
movl -0x518(%rbp), %eax
subl -0x514(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl 0x6e43d(%rip), %eax     # 0x199ad4
jle 0x12b6d6
leaq -0x4b8(%rbp), %rdi
leaq -0x504(%rbp), %rsi
callq 0x6b600
jmp 0x12b6ae
leaq -0x4d0(%rbp), %rdi
leaq -0x508(%rbp), %rsi
callq 0x6b600
jmp 0x12b6c3
jmp 0x12b702
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12bc9b
leaq -0x4e8(%rbp), %rdi
leaq -0x504(%rbp), %rsi
callq 0x6b600
jmp 0x12b6eb
leaq -0x500(%rbp), %rdi
leaq -0x508(%rbp), %rsi
callq 0x6b600
jmp 0x12b700
jmp 0x12b702
jmp 0x12b704
jmp 0x12b706
movl -0x508(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x508(%rbp)
jmp 0x12b4fd
jmp 0x12b71c
movl -0x504(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x504(%rbp)
jmp 0x12b4af
leaq -0x4b8(%rbp), %rdi
callq 0x467f0
cmpq $0x0, %rax
jbe 0x12b99f
movl -0x3c0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c0(%rbp)
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x8c0(%rbp)
leaq -0x4b8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4d100
movq -0x8c0(%rbp), %rdi
movslq (%rax), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x51c(%rbp)
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x8b8(%rbp)
leaq -0x4d0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4d100
movq -0x8b8(%rbp), %rdi
movslq (%rax), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x520(%rbp)
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x8b0(%rbp)
leaq -0x4b8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4d100
movq -0x8b0(%rbp), %rdi
movslq (%rax), %rsi
callq 0x11d7a0
movq (%rax), %rax
cvttsd2si 0x18(%rax), %eax
movl %eax, -0x524(%rbp)
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x8a8(%rbp)
leaq -0x4d0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4d100
movq -0x8a8(%rbp), %rdi
movslq (%rax), %rsi
callq 0x11d7a0
movq (%rax), %rax
cvttsd2si 0x18(%rax), %eax
movl %eax, -0x528(%rbp)
movl -0x520(%rbp), %eax
subl -0x51c(%rbp), %eax
cmpl $0x0, %eax
jge 0x12b8e0
movl -0x51c(%rbp), %eax
movl %eax, -0x52c(%rbp)
movl -0x520(%rbp), %eax
movl %eax, -0x51c(%rbp)
movl -0x52c(%rbp), %eax
movl %eax, -0x520(%rbp)
movl -0x524(%rbp), %eax
movl %eax, -0x52c(%rbp)
movl -0x528(%rbp), %eax
movl %eax, -0x524(%rbp)
movl -0x52c(%rbp), %eax
movl %eax, -0x528(%rbp)
movl $0x20, %edi
callq 0xa5d0
movq %rax, -0x8c8(%rbp)
jmp 0x12b8f3
movq -0x8c8(%rbp), %rdi
movl -0x51c(%rbp), %esi
movl -0x520(%rbp), %edx
cvtsi2sdl -0x524(%rbp), %xmm0
cvtsi2sdl -0x528(%rbp), %xmm1
callq 0x11d7c0
jmp 0x12b91d
movq -0x8c8(%rbp), %rax
movq %rax, -0x538(%rbp)
leaq -0x448(%rbp), %rdi
leaq -0x538(%rbp), %rsi
callq 0x11d810
jmp 0x12b940
leaq -0x4b8(%rbp), %rdi
callq 0x12d560
leaq -0x4d0(%rbp), %rdi
callq 0x12d560
movq -0x3d0(%rbp), %rax
movl -0x520(%rbp), %ecx
subl -0x51c(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x3d0(%rbp)
jmp 0x12bc57
movq -0x8c8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x20, %esi
callq 0xa5e0
jmp 0x12bc9b
movl -0x3bc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3bc(%rbp)
leaq -0x550(%rbp), %rdi
callq 0x46270
movl $0x0, -0x554(%rbp)
movl $0x0, -0x558(%rbp)
movl $0x0, -0x55c(%rbp)
movslq -0x55c(%rbp), %rax
movq %rax, -0x8d0(%rbp)
leaq -0x4e8(%rbp), %rdi
callq 0x467f0
movq %rax, %rcx
movq -0x8d0(%rbp), %rax
cmpq %rcx, %rax
je 0x12bade
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x8e0(%rbp)
movslq -0x55c(%rbp), %rsi
leaq -0x4e8(%rbp), %rdi
callq 0x4d100
movq -0x8e0(%rbp), %rdi
movslq (%rax), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x560(%rbp)
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x8d8(%rbp)
movslq -0x55c(%rbp), %rsi
leaq -0x500(%rbp), %rdi
callq 0x4d100
movq -0x8d8(%rbp), %rdi
movslq (%rax), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x564(%rbp)
movl -0x564(%rbp), %eax
subl -0x560(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl -0x554(%rbp), %eax
jle 0x12bac8
movl -0x55c(%rbp), %eax
movl %eax, -0x558(%rbp)
jmp 0x12baca
movl -0x55c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x55c(%rbp)
jmp 0x12b9d8
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x8f0(%rbp)
movslq -0x558(%rbp), %rsi
leaq -0x4e8(%rbp), %rdi
callq 0x4d100
movq -0x8f0(%rbp), %rdi
movslq (%rax), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x568(%rbp)
movslq -0x480(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x8e8(%rbp)
movslq -0x558(%rbp), %rsi
leaq -0x500(%rbp), %rdi
callq 0x4d100
movq -0x8e8(%rbp), %rdi
movslq (%rax), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x56c(%rbp)
movl -0x56c(%rbp), %eax
subl -0x568(%rbp), %eax
cmpl $0x0, %eax
jge 0x12bbaf
movl -0x568(%rbp), %eax
movl %eax, -0x570(%rbp)
movl -0x56c(%rbp), %eax
movl %eax, -0x568(%rbp)
movl -0x570(%rbp), %eax
movl %eax, -0x56c(%rbp)
movl -0x56c(%rbp), %eax
movl -0x568(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x574(%rbp)
movq -0x3d0(%rbp), %rax
movslq -0x574(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x3d0(%rbp)
leaq -0x550(%rbp), %rdi
leaq -0x568(%rbp), %rsi
callq 0x6b600
jmp 0x12bbf0
leaq -0x550(%rbp), %rdi
leaq -0x56c(%rbp), %rsi
callq 0x6b600
jmp 0x12bc05
leaq -0x550(%rbp), %rdi
leaq -0x574(%rbp), %rsi
callq 0x6b600
jmp 0x12bc1a
leaq -0x460(%rbp), %rdi
leaq -0x550(%rbp), %rsi
callq 0x6ccd0
jmp 0x12bc2f
leaq -0x550(%rbp), %rdi
callq 0x48290
jmp 0x12bc57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x550(%rbp), %rdi
callq 0x48290
jmp 0x12bc9b
leaq -0x500(%rbp), %rdi
callq 0x48290
leaq -0x4e8(%rbp), %rdi
callq 0x48290
leaq -0x4d0(%rbp), %rdi
callq 0x48290
leaq -0x4b8(%rbp), %rdi
callq 0x48290
movl -0x480(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x480(%rbp)
jmp 0x12b305
leaq -0x500(%rbp), %rdi
callq 0x48290
leaq -0x4e8(%rbp), %rdi
callq 0x48290
leaq -0x4d0(%rbp), %rdi
callq 0x48290
leaq -0x4b8(%rbp), %rdi
callq 0x48290
jmp 0x12d077
movq 0x6d2e1(%rip), %rdi     # 0x198fb8
leaq 0x230fa(%rip), %rsi     # 0x14edd8
callq 0xa5c0
movq %rax, -0x8f8(%rbp)
jmp 0x12bcec
movq -0x8f8(%rbp), %rdi
movq -0x3d0(%rbp), %rsi
callq 0xa300
movq %rax, -0x900(%rbp)
jmp 0x12bd08
movq -0x900(%rbp), %rdi
movq 0x6d272(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12bd1d
movq 0x6d294(%rip), %rdi     # 0x198fb8
leaq 0x2280b(%rip), %rsi     # 0x14e536
callq 0xa5c0
movq %rax, -0x908(%rbp)
jmp 0x12bd39
movq -0x908(%rbp), %rdi
movl -0x3bc(%rbp), %esi
callq 0xab20
movq %rax, -0x910(%rbp)
jmp 0x12bd54
movq -0x910(%rbp), %rdi
movq 0x6d226(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12bd69
movq 0x6d248(%rip), %rdi     # 0x198fb8
leaq 0x227cf(%rip), %rsi     # 0x14e546
callq 0xa5c0
movq %rax, -0x918(%rbp)
jmp 0x12bd85
movq -0x918(%rbp), %rdi
movl -0x3c0(%rbp), %esi
callq 0xab20
movq %rax, -0x920(%rbp)
jmp 0x12bda0
movq -0x920(%rbp), %rdi
movq 0x6d1da(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12bdb5
movq 0x6d1fc(%rip), %rdi     # 0x198fb8
leaq 0x2302f(%rip), %rsi     # 0x14edf2
callq 0xa5c0
movq %rax, -0x928(%rbp)
jmp 0x12bdd1
leaq -0x460(%rbp), %rdi
callq 0x6d780
movq -0x928(%rbp), %rdi
movq %rax, %rsi
callq 0xa140
movq %rax, -0x930(%rbp)
jmp 0x12bdf5
movq -0x930(%rbp), %rdi
movq 0x6d185(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12be0a
movq 0x6d1a7(%rip), %rdi     # 0x198fb8
leaq 0x2273e(%rip), %rsi     # 0x14e556
callq 0xa5c0
movq %rax, -0x938(%rbp)
jmp 0x12be26
movq -0x938(%rbp), %rdi
movl -0x3c4(%rbp), %esi
callq 0xab20
movq %rax, -0x940(%rbp)
jmp 0x12be41
movq -0x940(%rbp), %rdi
movq 0x6d139(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12be56
movq 0x6d15b(%rip), %rdi     # 0x198fb8
leaq 0x226fd(%rip), %rsi     # 0x14e561
callq 0xa5c0
movq %rax, -0x948(%rbp)
jmp 0x12be72
movq -0x948(%rbp), %rdi
movl -0x3c8(%rbp), %esi
callq 0xab20
movq %rax, -0x950(%rbp)
jmp 0x12be8d
movq -0x950(%rbp), %rdi
movq 0x6d0ed(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12bea2
movq 0x6d10f(%rip), %rdi     # 0x198fb8
leaq 0x226bf(%rip), %rsi     # 0x14e56f
callq 0xa5c0
movq %rax, -0x958(%rbp)
jmp 0x12bebe
leaq -0x590(%rbp), %rdi
leaq -0x400(%rbp), %rsi
callq 0x53120
jmp 0x12bed3
leaq -0x590(%rbp), %rdi
callq 0x53060
movsd %xmm0, -0x960(%rbp)
jmp 0x12bee9
movsd -0x960(%rbp), %xmm0
movq -0x958(%rbp), %rdi
callq 0xabd0
movq %rax, -0x968(%rbp)
jmp 0x12bf06
movq -0x968(%rbp), %rdi
movq 0x6d074(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12bf1b
leaq -0x590(%rbp), %rdi
callq 0x3ecb0
movq 0x6d08a(%rip), %rdi     # 0x198fb8
leaq 0x22654(%rip), %rsi     # 0x14e589
callq 0xa5c0
movq %rax, -0x970(%rbp)
jmp 0x12bf43
leaq -0x5a8(%rbp), %rdi
leaq -0x3e8(%rbp), %rsi
callq 0x53120
jmp 0x12bf58
leaq -0x5a8(%rbp), %rdi
callq 0x53060
movsd %xmm0, -0x978(%rbp)
jmp 0x12bf6e
movsd -0x978(%rbp), %xmm0
movq -0x970(%rbp), %rdi
callq 0xabd0
movq %rax, -0x980(%rbp)
jmp 0x12bf8b
movq -0x980(%rbp), %rdi
movq 0x6cfef(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12bfa0
leaq -0x5a8(%rbp), %rdi
callq 0x3ecb0
movl $0x0, -0x5ac(%rbp)
movslq -0x5ac(%rbp), %rax
movq %rax, -0x988(%rbp)
leaq -0x448(%rbp), %rdi
callq 0x11d880
movq %rax, %rcx
movq -0x988(%rbp), %rax
cmpq %rcx, %rax
je 0x12c1ac
movq -0x80(%rbp), %rax
movq %rax, -0x998(%rbp)
movslq -0x5ac(%rbp), %rsi
leaq -0x448(%rbp), %rdi
callq 0x11d8a0
movq -0x998(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %esi
callq 0xab20
movq %rax, -0x990(%rbp)
jmp 0x12c01b
movq -0x990(%rbp), %rdi
leaq 0x9eb5(%rip), %rsi      # 0x135ede
callq 0xa5c0
movq %rax, -0x9a0(%rbp)
jmp 0x12c037
movslq -0x5ac(%rbp), %rsi
leaq -0x448(%rbp), %rdi
callq 0x11d8a0
movq -0x9a0(%rbp), %rdi
movq (%rax), %rax
movl 0x4(%rax), %esi
callq 0xab20
movq %rax, -0x9a8(%rbp)
jmp 0x12c065
movq -0x9a8(%rbp), %rdi
leaq 0x9e6b(%rip), %rsi      # 0x135ede
callq 0xa5c0
movq %rax, -0x9b0(%rbp)
jmp 0x12c081
movslq -0x5ac(%rbp), %rsi
leaq -0x448(%rbp), %rdi
callq 0x11d8a0
movq -0x9b0(%rbp), %rdi
movq (%rax), %rax
movl 0x18(%rax), %esi
callq 0xab20
movq %rax, -0x9b8(%rbp)
jmp 0x12c0af
movq -0x9b8(%rbp), %rdi
leaq 0x9e21(%rip), %rsi      # 0x135ede
callq 0xa5c0
movq %rax, -0x9c0(%rbp)
jmp 0x12c0cb
movslq -0x5ac(%rbp), %rsi
leaq -0x448(%rbp), %rdi
callq 0x11d8a0
movq -0x9c0(%rbp), %rdi
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
callq 0xabd0
movq %rax, -0x9c8(%rbp)
jmp 0x12c0fb
movq -0x9c8(%rbp), %rdi
leaq 0x9dd5(%rip), %rsi      # 0x135ede
callq 0xa5c0
movq %rax, -0x9d0(%rbp)
jmp 0x12c117
movslq -0x5ac(%rbp), %rsi
leaq -0x448(%rbp), %rdi
callq 0x11d8a0
movq -0x9d0(%rbp), %rdi
movq (%rax), %rax
movsd 0x10(%rax), %xmm0
callq 0xabd0
movq %rax, -0x9d8(%rbp)
jmp 0x12c147
movq -0x9d8(%rbp), %rdi
movq 0x6ce33(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12c15c
jmp 0x12c15e
movl -0x5ac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5ac(%rbp)
jmp 0x12bfb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x590(%rbp), %rdi
callq 0x3ecb0
jmp 0x12d077
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x5a8(%rbp), %rdi
callq 0x3ecb0
jmp 0x12d077
movq 0x6ce05(%rip), %rdi     # 0x198fb8
movq 0x6cdce(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12c1c1
movq 0x6cdf0(%rip), %rdi     # 0x198fb8
leaq 0x22c43(%rip), %rsi     # 0x14ee12
callq 0xa5c0
movq %rax, -0x9e0(%rbp)
jmp 0x12c1dd
movq -0x9e0(%rbp), %rdi
movq 0x6cd9d(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12c1f2
leaq -0x478(%rbp), %rdi
movq %rdi, -0x9e8(%rbp)
callq 0x46a90
movq -0x9e8(%rbp), %rdi
movq %rax, -0x5b8(%rbp)
callq 0x46ac0
movq %rax, -0x5c0(%rbp)
movq -0x5b8(%rbp), %rdi
movq -0x5c0(%rbp), %rsi
callq 0x83bb0
jmp 0x12c234
leaq -0x478(%rbp), %rdi
movq %rdi, -0x9f8(%rbp)
callq 0x46a90
movq -0x9f8(%rbp), %rdi
movq %rax, -0x5d0(%rbp)
callq 0x46ac0
movq %rax, -0x5d8(%rbp)
movq -0x5d0(%rbp), %rdi
movq -0x5d8(%rbp), %rsi
callq 0x83bf0
movq %rax, -0x9f0(%rbp)
jmp 0x12c27d
movq -0x9f0(%rbp), %rax
movq %rax, -0x5c8(%rbp)
leaq -0x478(%rbp), %rdi
callq 0x46a90
movq %rax, -0x5e0(%rbp)
movq -0x5c8(%rbp), %rax
movq %rax, -0x5e8(%rbp)
movq -0x5e0(%rbp), %rdi
movq -0x5e8(%rbp), %rsi
callq 0x70630
movq %rax, -0xa00(%rbp)
jmp 0x12c2c8
movq -0xa00(%rbp), %rsi
leaq -0x478(%rbp), %rdi
callq 0x83c30
jmp 0x12c2dd
movq 0x6ccd4(%rip), %rdi     # 0x198fb8
leaq 0x22b43(%rip), %rsi     # 0x14ee2e
callq 0xa5c0
movq %rax, -0xa08(%rbp)
jmp 0x12c2f9
leaq -0x478(%rbp), %rdi
callq 0x467f0
movq -0xa08(%rbp), %rdi
movq %rax, %rsi
callq 0xa140
movq %rax, -0xa10(%rbp)
jmp 0x12c31d
movq -0xa10(%rbp), %rdi
movq 0x6cc5d(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12c332
cvtsi2sdl -0x3c0(%rbp), %xmm0
cvtsi2sdq -0x3d0(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x5f0(%rbp)
movq 0x6cc62(%rip), %rdi     # 0x198fb8
leaq 0x22ae7(%rip), %rsi     # 0x14ee44
callq 0xa5c0
movq %rax, -0xa18(%rbp)
jmp 0x12c36b
movq -0xa18(%rbp), %rdi
movsd -0x5f0(%rbp), %xmm0
callq 0xabd0
movq %rax, -0xa20(%rbp)
jmp 0x12c388
movq -0xa20(%rbp), %rdi
movq 0x6cbf2(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12c39d
leaq -0x478(%rbp), %rdi
callq 0x467f0
incq %rax
movq %rax, -0xa30(%rbp)
leaq -0x609(%rbp), %rdi
movq %rdi, -0xa28(%rbp)
callq 0x484d0
movq -0xa30(%rbp), %rsi
movq -0xa28(%rbp), %rcx
leaq -0x608(%rbp), %rdi
leaq -0x5f0(%rbp), %rdx
callq 0x83450
jmp 0x12c3e9
leaq -0x609(%rbp), %rdi
callq 0x4a130
movl $0x0, -0x610(%rbp)
movl $0x0, -0x614(%rbp)
movslq -0x614(%rbp), %rax
movq %rax, -0xa38(%rbp)
leaq -0x478(%rbp), %rdi
callq 0x467f0
movq %rax, %rcx
movq -0xa38(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x12c853
movslq -0x614(%rbp), %rsi
leaq -0x478(%rbp), %rdi
callq 0x4d100
movl (%rax), %eax
movl %eax, -0x618(%rbp)
movl -0x614(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
leaq -0x478(%rbp), %rdi
callq 0x4d100
movl (%rax), %eax
movl %eax, -0x61c(%rbp)
movl $0x0, -0x620(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x628(%rbp)
movl $0x0, -0x62c(%rbp)
movslq -0x62c(%rbp), %rax
movq %rax, -0xa40(%rbp)
leaq -0x448(%rbp), %rdi
callq 0x11d880
movq %rax, %rcx
movq -0xa40(%rbp), %rax
cmpq %rcx, %rax
je 0x12c591
movslq -0x62c(%rbp), %rsi
leaq -0x448(%rbp), %rdi
callq 0x11d8a0
movq (%rax), %rax
movl (%rax), %eax
cmpl -0x618(%rbp), %eax
jg 0x12c57b
movslq -0x62c(%rbp), %rsi
leaq -0x448(%rbp), %rdi
callq 0x11d8a0
movq (%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x61c(%rbp), %eax
jl 0x12c57b
movl -0x620(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x620(%rbp)
movslq -0x62c(%rbp), %rsi
leaq -0x448(%rbp), %rdi
callq 0x11d8a0
movq (%rax), %rax
cvtsi2sdl 0x18(%rax), %xmm1
movsd 0x5d80(%rip), %xmm0     # 0x1322b8
divsd %xmm1, %xmm0
movsd %xmm0, -0x638(%rbp)
movsd -0x638(%rbp), %xmm0
addsd -0x628(%rbp), %xmm0
movsd %xmm0, -0x628(%rbp)
jmp 0x12c57b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x609(%rbp), %rdi
callq 0x4a130
jmp 0x12d077
jmp 0x12c57d
movl -0x62c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x62c(%rbp)
jmp 0x12c494
xorps %xmm0, %xmm0
movsd %xmm0, -0x640(%rbp)
movl $0x0, -0x644(%rbp)
movslq -0x644(%rbp), %rax
movq %rax, -0xa48(%rbp)
leaq -0x460(%rbp), %rdi
callq 0x6d780
movq %rax, %rcx
movq -0xa48(%rbp), %rax
cmpq %rcx, %rax
je 0x12c663
movslq -0x644(%rbp), %rsi
leaq -0x460(%rbp), %rdi
callq 0x705d0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4d100
movl (%rax), %eax
cmpl -0x618(%rbp), %eax
jg 0x12c64d
movslq -0x644(%rbp), %rsi
leaq -0x460(%rbp), %rdi
callq 0x705d0
movq %rax, %rdi
movl $0x1, %esi
callq 0x4d100
movl (%rax), %eax
cmpl -0x61c(%rbp), %eax
jl 0x12c64d
movl -0x620(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x620(%rbp)
movsd 0x5c7b(%rip), %xmm0     # 0x1322b8
addsd -0x640(%rbp), %xmm0
movsd %xmm0, -0x640(%rbp)
jmp 0x12c64f
movl -0x644(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x644(%rbp)
jmp 0x12c5a6
cmpl $0xa, -0x620(%rbp)
jle 0x12c6a8
movsd -0x628(%rbp), %xmm0
divsd -0x640(%rbp), %xmm0
movsd %xmm0, -0xa50(%rbp)
movl -0x614(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
leaq -0x608(%rbp), %rdi
callq 0x3ec30
movsd -0xa50(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x610(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x610(%rbp)
movl -0x610(%rbp), %eax
movl $0x2710, %ecx           # imm = 0x2710
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x12c83d
movq 0x6c8e3(%rip), %rdi     # 0x198fb8
leaq 0x2277f(%rip), %rsi     # 0x14ee5b
callq 0xa5c0
movq %rax, -0xa58(%rbp)
jmp 0x12c6ea
movq -0xa58(%rbp), %rdi
movl -0x610(%rbp), %esi
callq 0xab20
movq %rax, -0xa60(%rbp)
jmp 0x12c705
movq -0xa60(%rbp), %rdi
leaq 0x1155c(%rip), %rsi     # 0x13dc6f
callq 0xa5c0
movq %rax, -0xa68(%rbp)
jmp 0x12c721
cvtsi2sdl -0x610(%rbp), %xmm0
movsd %xmm0, -0xa78(%rbp)
leaq -0x478(%rbp), %rdi
callq 0x467f0
movsd -0xa78(%rbp), %xmm0
movq -0xa68(%rbp), %rdi
movq %rax, %xmm1
movaps 0x1a08(%rip), %xmm2     # 0x12e160
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x1a0c(%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, -0xa70(%rbp)
jmp 0x12c785
movq -0xa70(%rbp), %rdi
leaq 0x17763(%rip), %rsi     # 0x143ef6
callq 0xa5c0
movq %rax, -0xa80(%rbp)
jmp 0x12c7a1
movq -0xa80(%rbp), %rdi
movq 0x6c7d9(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12c7b6
movq 0x6c7fb(%rip), %rdi     # 0x198fb8
leaq 0xcd84(%rip), %rsi      # 0x139548
callq 0xa5c0
movq %rax, -0xa88(%rbp)
jmp 0x12c7d2
movq -0xa88(%rbp), %rdi
movl -0x618(%rbp), %esi
callq 0xab20
movq %rax, -0xa90(%rbp)
jmp 0x12c7ed
movq -0xa90(%rbp), %rdi
leaq 0x15e01(%rip), %rsi     # 0x1425fc
callq 0xa5c0
movq %rax, -0xa98(%rbp)
jmp 0x12c809
movq -0xa98(%rbp), %rdi
movq 0x6c771(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12c81e
jmp 0x12c83d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x608(%rbp), %rdi
callq 0x3ecb0
jmp 0x12d077
jmp 0x12c83f
movl -0x614(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x614(%rbp)
jmp 0x12c409
movq -0xd0(%rbp), %rdi
leaq 0x1cd85(%rip), %rsi     # 0x1495e6
callq 0xa5c0
movq %rax, -0xaa0(%rbp)
jmp 0x12c86f
xorl %eax, %eax
movl %eax, %esi
leaq -0x478(%rbp), %rdi
callq 0x4d100
movq -0xaa0(%rbp), %rdi
movl (%rax), %esi
callq 0xab20
movq %rax, -0xaa8(%rbp)
jmp 0x12c896
movq -0xaa8(%rbp), %rdi
leaq 0x963a(%rip), %rsi      # 0x135ede
callq 0xa5c0
movq %rax, -0xab0(%rbp)
jmp 0x12c8b2
xorl %eax, %eax
movl %eax, %esi
leaq -0x608(%rbp), %rdi
callq 0x3ec30
movq -0xab0(%rbp), %rdi
movsd (%rax), %xmm0
callq 0xabd0
movq %rax, -0xab8(%rbp)
jmp 0x12c8db
movq -0xab8(%rbp), %rdi
movq 0x6c69f(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12c8f0
movl $0x1, -0x648(%rbp)
movslq -0x648(%rbp), %rax
movq %rax, -0xac0(%rbp)
leaq -0x478(%rbp), %rdi
callq 0x467f0
movq %rax, %rcx
movq -0xac0(%rbp), %rax
cmpq %rcx, %rax
je 0x12ca1c
movq -0xd0(%rbp), %rax
movq %rax, -0xad0(%rbp)
movl -0x648(%rbp), %eax
decl %eax
movslq %eax, %rsi
leaq -0x478(%rbp), %rdi
callq 0x4d100
movq -0xad0(%rbp), %rdi
movl (%rax), %esi
callq 0xab20
movq %rax, -0xac8(%rbp)
jmp 0x12c963
movq -0xac8(%rbp), %rdi
leaq 0x956d(%rip), %rsi      # 0x135ede
callq 0xa5c0
movq %rax, -0xad8(%rbp)
jmp 0x12c97f
movslq -0x648(%rbp), %rsi
leaq -0x478(%rbp), %rdi
callq 0x4d100
movq -0xad8(%rbp), %rdi
movl (%rax), %esi
callq 0xab20
movq %rax, -0xae0(%rbp)
jmp 0x12c9a9
movq -0xae0(%rbp), %rdi
leaq 0x9527(%rip), %rsi      # 0x135ede
callq 0xa5c0
movq %rax, -0xae8(%rbp)
jmp 0x12c9c5
movslq -0x648(%rbp), %rsi
leaq -0x608(%rbp), %rdi
callq 0x3ec30
movq -0xae8(%rbp), %rdi
movsd (%rax), %xmm0
callq 0xabd0
movq %rax, -0xaf0(%rbp)
jmp 0x12c9f1
movq -0xaf0(%rbp), %rdi
movq 0x6c589(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12ca06
jmp 0x12ca08
movl -0x648(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x648(%rbp)
jmp 0x12c8fa
leaq -0x608(%rbp), %rdi
callq 0x3ecb0
jmp 0x12cfa5
movl $0x0, -0x64c(%rbp)
movslq -0x64c(%rbp), %rax
movq %rax, -0xaf8(%rbp)
leaq -0x390(%rbp), %rdi
callq 0x11d740
movq %rax, %rcx
movq -0xaf8(%rbp), %rax
cmpq %rcx, %rax
jae 0x12ce66
movslq -0x64c(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
cmpq $0x1, %rax
jbe 0x12ce50
movl $0x0, -0x650(%rbp)
movslq -0x650(%rbp), %rax
movq %rax, -0xb00(%rbp)
movslq -0x64c(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
movq %rax, %rcx
movq -0xb00(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x12ce4e
movl $0x1, -0x654(%rbp)
movslq -0x654(%rbp), %rax
movq %rax, -0xb08(%rbp)
movslq -0x64c(%rbp), %rsi
leaq -0x390(%rbp), %rdi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x11d780
movq %rax, %rcx
movq -0xb08(%rbp), %rax
cmpq %rcx, %rax
jae 0x12ce38
movslq -0x64c(%rbp), %rsi
leaq -0x390(%rbp), %rdi
movq %rdi, -0xb10(%rbp)
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x650(%rbp), %rsi
callq 0x11d7a0
movq -0xb10(%rbp), %rdi
movq (%rax), %rax
movb 0x8(%rax), %al
movb %al, -0x655(%rbp)
movslq -0x64c(%rbp), %rsi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x654(%rbp), %rsi
callq 0x11d7a0
movq -0xb10(%rbp), %rdi
movq (%rax), %rax
movb 0x8(%rax), %al
movb %al, -0x656(%rbp)
movslq -0x64c(%rbp), %rsi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x650(%rbp), %rsi
callq 0x11d7a0
movq -0xb10(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x65c(%rbp)
movslq -0x64c(%rbp), %rsi
callq 0x11d760
movq (%rax), %rdi
addq $0x18, %rdi
movslq -0x654(%rbp), %rsi
callq 0x11d7a0
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x660(%rbp)
movl -0x65c(%rbp), %esi
leaq -0x6c0(%rbp), %rdi
callq 0x3e190
jmp 0x12cc06
leaq 0x13183(%rip), %rdx     # 0x13fd90
leaq -0x6a0(%rbp), %rdi
leaq -0x6c0(%rbp), %rsi
callq 0x3e020
jmp 0x12cc22
movl -0x660(%rbp), %esi
leaq -0x6e0(%rbp), %rdi
callq 0x3e190
jmp 0x12cc36
leaq -0x680(%rbp), %rdi
leaq -0x6a0(%rbp), %rsi
leaq -0x6e0(%rbp), %rdx
callq 0x3e070
jmp 0x12cc52
leaq -0x6e0(%rbp), %rdi
callq 0xac88
leaq -0x6a0(%rbp), %rdi
callq 0xac88
leaq -0x6c0(%rbp), %rdi
callq 0xac88
leaq -0x230(%rbp), %rdi
leaq -0x680(%rbp), %rsi
callq 0x11d8c0
movq %rax, -0xb18(%rbp)
jmp 0x12cc92
movq -0xb18(%rbp), %rax
cmpq $0x0, %rax
jne 0x12cd95
movl $0x38, %edi
callq 0xa5d0
movq %rax, -0xb20(%rbp)
jmp 0x12ccb6
movq -0xb20(%rbp), %rdi
movl -0x65c(%rbp), %esi
movl -0x660(%rbp), %edx
movsbl -0x655(%rbp), %ecx
movsbl -0x656(%rbp), %r8d
callq 0x11d8f0
jmp 0x12ccdf
leaq -0x230(%rbp), %rdi
leaq -0x680(%rbp), %rsi
callq 0x11d990
movq %rax, -0xb28(%rbp)
jmp 0x12ccfb
movq -0xb28(%rbp), %rax
movq -0xb20(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x12ce07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12cd51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12cd45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x6e0(%rbp), %rdi
callq 0xac88
leaq -0x6a0(%rbp), %rdi
callq 0xac88
leaq -0x6c0(%rbp), %rdi
callq 0xac88
jmp 0x12d077
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x12ce27
movq -0xb20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x38, %esi
callq 0xa5e0
jmp 0x12ce27
leaq -0x230(%rbp), %rdi
leaq -0x680(%rbp), %rsi
callq 0x11d990
movq %rax, -0xb30(%rbp)
jmp 0x12cdb1
movq -0xb30(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
leaq -0x655(%rbp), %rsi
callq 0xad990
jmp 0x12cdcd
leaq -0x230(%rbp), %rdi
leaq -0x680(%rbp), %rsi
callq 0x11d990
movq %rax, -0xb38(%rbp)
jmp 0x12cde9
movq -0xb38(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
leaq -0x656(%rbp), %rsi
callq 0xad990
jmp 0x12ce05
jmp 0x12ce07
leaq -0x680(%rbp), %rdi
callq 0xac88
movl -0x654(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x654(%rbp)
jmp 0x12cae5
leaq -0x680(%rbp), %rdi
callq 0xac88
jmp 0x12d077
jmp 0x12ce3a
movl -0x650(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x650(%rbp)
jmp 0x12ca97
jmp 0x12ce50
jmp 0x12ce52
movl -0x64c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64c(%rbp)
jmp 0x12ca37
movq 0x6c14b(%rip), %rdi     # 0x198fb8
leaq 0x2172c(%rip), %rsi     # 0x14e5a0
callq 0xa5c0
movq %rax, -0xb40(%rbp)
jmp 0x12ce82
leaq -0x230(%rbp), %rdi
callq 0x11d9c0
movq -0xb40(%rbp), %rdi
movq %rax, %rsi
callq 0xa140
movq %rax, -0xb48(%rbp)
jmp 0x12cea6
movq -0xb48(%rbp), %rdi
movq 0x6c0d4(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12cebb
movq 0x6c0f6(%rip), %rdi     # 0x198fb8
leaq 0x21702(%rip), %rsi     # 0x14e5cb
callq 0xa5c0
movq %rax, -0xb50(%rbp)
jmp 0x12ced7
movq -0xb50(%rbp), %rdi
movl -0x374(%rbp), %esi
callq 0xab20
movq %rax, -0xb58(%rbp)
jmp 0x12cef2
movq -0xb58(%rbp), %rdi
movq 0x6c088(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12cf07
movq 0x6c0aa(%rip), %rdi     # 0x198fb8
leaq 0x216c8(%rip), %rsi     # 0x14e5dd
callq 0xa5c0
movq %rax, -0xb60(%rbp)
jmp 0x12cf23
cvtsi2sdl -0x374(%rbp), %xmm0
movsd %xmm0, -0xb70(%rbp)
leaq -0x390(%rbp), %rdi
callq 0x11d740
movsd -0xb70(%rbp), %xmm0
movq -0xb60(%rbp), %rdi
imulq $0x12c, %rax, %rax      # imm = 0x12C
movq %rax, %xmm1
movaps 0x11ff(%rip), %xmm2     # 0x12e160
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x1203(%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, -0xb68(%rbp)
jmp 0x12cf8e
movq -0xb68(%rbp), %rdi
movq 0x6bfec(%rip), %rsi     # 0x198f88
callq 0xa610
jmp 0x12cfa3
jmp 0x12cfa5
movl $0x1, -0x2ac(%rbp)
leaq -0x478(%rbp), %rdi
callq 0x48290
leaq -0x460(%rbp), %rdi
callq 0x6d0b0
leaq -0x448(%rbp), %rdi
callq 0x11d9e0
leaq -0x430(%rbp), %rdi
callq 0x3ecb0
leaq -0x418(%rbp), %rdi
callq 0x3ecb0
leaq -0x400(%rbp), %rdi
callq 0x3ecb0
leaq -0x3e8(%rbp), %rdi
callq 0x3ecb0
leaq -0x390(%rbp), %rdi
callq 0x11da40
leaq -0x328(%rbp), %rdi
callq 0x11f370
leaq -0x230(%rbp), %rdi
callq 0x11daa0
leaq -0x1f0(%rbp), %rdi
callq 0x11dac0
leaq -0x1c0(%rbp), %rdi
callq 0x48290
leaq -0x1a8(%rbp), %rdi
callq 0x58f00
leaq -0x178(%rbp), %rdi
callq 0x70cd0
leaq -0x148(%rbp), %rdi
callq 0x11dae0
leaq -0x30(%rbp), %rdi
callq 0xac88
xorl %eax, %eax
addq $0xb70, %rsp            # imm = 0xB70
popq %rbp
retq
leaq -0x478(%rbp), %rdi
callq 0x48290
leaq -0x460(%rbp), %rdi
callq 0x6d0b0
leaq -0x448(%rbp), %rdi
callq 0x11d9e0
leaq -0x430(%rbp), %rdi
callq 0x3ecb0
leaq -0x418(%rbp), %rdi
callq 0x3ecb0
leaq -0x400(%rbp), %rdi
callq 0x3ecb0
leaq -0x3e8(%rbp), %rdi
callq 0x3ecb0
leaq -0x390(%rbp), %rdi
callq 0x11da40
leaq -0x328(%rbp), %rdi
callq 0x11f370
leaq -0x230(%rbp), %rdi
callq 0x11daa0
leaq -0x1f0(%rbp), %rdi
callq 0x11dac0
leaq -0x1c0(%rbp), %rdi
callq 0x48290
leaq -0x1a8(%rbp), %rdi
callq 0x58f00
leaq -0x178(%rbp), %rdi
callq 0x70cd0
leaq -0x148(%rbp), %rdi
callq 0x11dae0
leaq -0x30(%rbp), %rdi
callq 0xac88
movq -0x68(%rbp), %rdi
callq 0xab50
nopl (%rax)