// File: thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: SvgDoc::OptimizeLevel(Polygon*, std::__cxx11::list<NSVGpath*, std::allocator<NSVGpath*>>, std::__cxx11::list<NSVGpath*, std::allocator<NSVGpath*>>, int, double, double, double&, double, int, int, int)
NSVGpath *SvgDoc::OptimizeLevel(Polygon *FixedPolyHull, std::list<NSVGpath *> FixedList, std::list<NSVGpath *> CurFloating, int num_rot, double StepAngle, double FixedArea,
                                double &Cost, double InBestCost, int FloatPolygon, int nbFixedPoly, int LevelOptimize)
{
Polygon *rot_p = NULL;
Polygon *trans_rot_p = NULL;
vector<Point> FixedHull;
vector<Point> tmpFixedHull;
double BestCost = 1e100;
int Best_i = -1, Best_j = -1;
int Best_Poly = -1;
double BestAngle;
Point BestTranslation;
Point OverAllCentroid;
Rectangle OverAll;
int Reason;
int FixedPolygon = 0;
Point RefPoint;

    if ( debug_level > 1 )
    {
        OutDebug << "Entering OptimizeLevel(" << LevelOptimize <<  "): FixedHullArea " <<  FixedPolyHull->area() << " Fixed area " << FixedArea;
        OutDebug << ", Cost is " << Cost << ", InBestCost=" << InBestCost << "\n";
        OutDebug << "Elements in list:" << CurFloating.size() << " first is " << CurFloating.front()->id << "\n";
    }
    FixedHull = FixedPolyHull->GetVertices();
    OverAllCentroid = FixedPolyHull->getCentroid();
    OverAll = FixedPolyHull->GetBoundingBox();

    NSVGpath *WorkingFloatingEntry = CurFloating.front();
    //  And remove element from temporary floating list
    CurFloating.pop_front();
    BestCost = 1e100;          //  Very large, each try should be better
    BestAngle = -1;            //   Impossible value

    double tmpPolygonArea = FixedArea + WorkingFloatingEntry->LargePolygon->area();
    int nPreviousVertices = getFixedNbVertex(FixedList);            //  Number of vertices of all polygons before this one
    if ( debug_level > 1 )
    {
        OutDebug << "Polygon to be placed : " << WorkingFloatingEntry->id << "  has " << WorkingFloatingEntry->LargePolygon->nVertices << " vertices.\n";
    }
    //  Build a cache object which will speed up computation if not yet present
    if (UseCache && WorkingFloatingEntry->CachePoly == NULL )
    {
        WorkingFloatingEntry->CachePoly = new CachePosition(WorkingFloatingEntry->LargePolygon->nVertices, num_rot, nPreviousVertices);
        if ( debug_level > 1 )
        {
            OutDebug << "Create cache object for polygon " << WorkingFloatingEntry->id << "  with " << WorkingFloatingEntry->LargePolygon->nVertices*num_rot*nPreviousVertices << " entries.\n";
        }
    }
    else if ( UseCache and debug_level > 1)
    {
        OutDebug << "Cache object for polygon " << WorkingFloatingEntry->id << "  is already present \n";
    }
#ifdef UNDEF
    if ( FloatPolygon == 2)
    {
        OutDebug << "Cache object for Polygon 2=" << WorkingFloatingEntry->CachePoly << " cache value for 0/3/2 = " << WorkingFloatingEntry->CachePoly->isOKPlaced(3, 0, 2, &trans_rot_p)<< "\n";
    }
#endif
    //  Try each possible angle
    int iRot = 0;
    for ( double angle = 0; angle < 2*M_PI - 0.001; angle += StepAngle, iRot++)
    {
        if ( debug_level > 1 )
            OutDebug << "L" << LevelOptimize << ": Rotation set to " << round(angle*180/M_PI) << "\n";
        if ( rot_p ) delete rot_p;
        rot_p = WorkingFloatingEntry->LargePolygon->Rotate(angle);
        nbRotation++;
        rot_p->ComputeAngles();     //  Compute angles to be more efficient later
        rot_p->CalcSegments();

        //  Then try all vertices of all placed polygons
        FixedPolygon = 0;
        int iFixedVertex = 0;
        for (std::list<NSVGpath *>::iterator it=FixedList.begin(); it != FixedList.end(); ++it, FixedPolygon++)
        {
            //  Get next placed polygon
            NSVGpath *path = *it;
            Polygon  *curFixed = path->PlacedPolygon;
            // For each vertex of this placed polygon
            for ( int i = 0; i < curFixed->nVertices-1; iFixedVertex++, i++)
            {
                if ( debug_level > 0 )
                    OutDebug << std::flush;
                //  Try all vertices of the floating polygon, and select the best
                for (int j = 0; j < rot_p->nVertices-1; j++)
                {
                    //  Use cache if available
                    trans_rot_p = NULL;
                    int Cached = 0;
                    //  If we use cache and only if the path is fixed, look for cache status
                    if ( UseCache && path->isFixed )
                    {
                        Cached = WorkingFloatingEntry->CachePoly->isOKPlaced(j, iRot, iFixedVertex, &trans_rot_p);
#if DEBUG_CACHE > 0
                        OutDebug << "isOKPlaced(idx=" << j << ", iRot=" << iRot << ", iFixedVertex=" << iFixedVertex << ") return " << Cached << '\n' << std::flush;
#endif // DEBUG_CACHE
                    }
#ifdef UNDEF
                    if ( FloatPolygon == 2 && iRot == 1 && FixedPolygon == 0 && i == 0 && j == 1)
                    {
                        OutDebug << "Breakpoint reached!\n";
                        OutDebug.flush();
                    }
#endif
                    if ( Cached < 0 )       //  Cache says impossible !
                    {
                        CacheHit_KO++;
                        if ( debug_level > 2 )
                            OutDebug << "Cache says placement polygon " << FloatPolygon << " vertex " << j << " on vertex " << i << " of Polygon " << FixedPolygon << "(" << iFixedVertex << ")" << "impossible " << *curFixed->GetVertex(i) << "\n";
                        continue;           //  Goto next vertex...
                    }
                    else if ( Cached == 0 )
                    {
                        CacheMiss++;        // Not yet in cache, check angles first
                        //  No need to check angles when cached, because we test against a fixed polygon, and this test is included in the cache result
                        nbCheckAngles++;
                        if ( rot_p->nVertices == 0 )
                        {
                            cerr << " rot_p (" << rot_p << ") invalid with 0 vertices, level =" << LevelOptimize << " Float poly = " << FloatPolygon << "\n";
                        }
                        if (CheckAngles(rot_p, j, curFixed, i) == 0)
                        {
                            //  Impossible, invalid cache entry if polygon is fixed
                            if ( UseCache && path->isFixed )
                            {
                                WorkingFloatingEntry->CachePoly->addOKPlaced(j, iRot, iFixedVertex, NULL);
#if DEBUG_CACHE > 0
                                OutDebug << "CheckAngle NOK, invalidate entry (idx=" << j << ", iRot=" << iRot << ", iFixedVertex=" << iFixedVertex << ")\n" << std::flush;
#endif // DEBUG_CACHE

                            }
                            if ( debug_level > 2 )
                                OutDebug << "Placement polygon " << FloatPolygon << " vertex " << j << " on vertex " << i << " of Polygon " << FixedPolygon << " impossible " << *curFixed->GetVertex(i) << ", reason angle mismatch\n";
                            continue;    //  Not possible go to next without further processing
                        }
                        //  Compute polygon translated and rotated...
                        trans_rot_p = rot_p->Translate(curFixed->GetVertex(i), j);
                        nbTranslation++;
                        trans_rot_p->CalcSegments();
                    }
                    else
                    {
                        CacheHit_OK++;
                    }

                    RefPoint = Point(WorkingFloatingEntry->StartX, WorkingFloatingEntry->StartY);
                    RefPoint.Transform(angle, WorkingFloatingEntry->LargePolygon->getCentroid(), trans_rot_p->getTranslation());
                    if ( (Reason = PlacementNotPossible(trans_rot_p, FixedList, &OverAll, &RefPoint, Cached)) )
                    {
                        if ( debug_level > 2 )
                            OutDebug << "Placement polygon " << FloatPolygon << " vertex " << j << " on vertex " << i << " of Polygon " << FixedPolygon << " impossible " << *curFixed->GetVertex(i) << ", reason " << Reason << "\n";
                        //  If impossible due to conflict with fixed polygon, invalidate cache entry
                        if ( path->isFixed && (Reason & FIXED_BIT) != 0 )
                        {
                            if ( UseCache )
                            {
                                WorkingFloatingEntry->CachePoly->addOKPlaced(j, iRot, iFixedVertex, NULL);
#if DEBUG_CACHE > 0
                                OutDebug << "PlacementNotPossible NOK, invalidate entry (idx=" << j << ", iRot=" << iRot << ", iFixedVertex=" << iFixedVertex << ")\n" << std::flush;
#endif // DEBUG_CACHE
                            }
                            //  And free memory of polygon translated / rotated
                            delete trans_rot_p;
                            trans_rot_p = NULL;
                        }
                        //  Free memory associated with polygon only if not cached
                        if ( Cached == 0 && trans_rot_p != NULL )
                        {
                            delete trans_rot_p;
                            trans_rot_p = NULL;
                        }

                        nbPlacementImpossible++;
                        if ( rot_p->nVertices == 0 )
                        {
                            cerr << " rot_p (" << rot_p << ") invalid with 0 vertices, level =" << LevelOptimize << " Float poly = " << FloatPolygon << "\n";
                        }
                        continue;
                    }
                    if ( path->isFixed && Cached == 0)        //  If current vertex belongs to a fixed path, cache value
                    {
                        if ( UseCache )
                        {
                            WorkingFloatingEntry->CachePoly->addOKPlaced(j, iRot, iFixedVertex, trans_rot_p);
#if DEBUG_CACHE > 0
                            OutDebug << "PlacementNotPossible OK, validate entry (idx=" << j << ", iRot=" << iRot << ", iFixedVertex=" << iFixedVertex << ")\n" << std::flush;
#endif // DEBUG_CACHE
                            Cached = 1;
                        }
#ifdef UNDEF
                        if ( LevelOptimize == 1 && FloatPolygon == 2 && iRot == 0 && iFixedVertex == 2 && j == 3 )
                        {
                            OutDebug << "iRot=0, Vertex 3 of Polygon 2 placed on vertex 2 of polygon 0, add cache entry "  << trans_rot_p << "\n";
                            Polygon *TestPoly = NULL;
                            int TestCache = WorkingFloatingEntry->CachePoly->isOKPlaced(j, iRot, iFixedVertex, &TestPoly);
                            OutDebug << "Check Cached=" << TestCache << " Value Cached=" << TestPoly << "\n";
                        }
#endif
                    }
                    //  Compute cost function
                    //  We will use the Hull area and a factor of the bounding box.
                    //  As the Hull and bounding box will only grow with subsequent calls, if a temp value is greater than the best one, no need to process further polygons
                    vector<Point> tmpHull = CombineHull(FixedHull, trans_rot_p->GetVertices());
                    double tmpHullArea = HullArea(tmpHull);
                    Rectangle tmpOverall = Hull2BoundingBox(FixedHull);
                    double CurrentCost = tmpHullArea + RectCostFactor*tmpOverall.get_area();
                    if ( debug_level > 1)
                        OutDebug << "  Vertex " << j << " on " << i << " of polygon " << FixedPolygon << " Hull area " << tmpHullArea << " Cost " << CurrentCost << "--> DiffArea=" << CurrentCost - tmpPolygonArea << "\n";
                    //  In this case, call again this function but with a list without the first element
                    //  First copy the list, the first element has already been removed
                    std::list<NSVGpath *> tmpFloatList = CurFloating;
                    //  Then add this element, as placed to the fixed list.
                    std::list<NSVGpath *> tmpFixedList = FixedList;
                    tmpFixedList.push_back(WorkingFloatingEntry);
                    //  Move Polygon at its place, but before delete existing polygon to save memory
                    if ( WorkingFloatingEntry->PlacedPolygon ) delete WorkingFloatingEntry->PlacedPolygon;
                    if ( WorkingFloatingEntry->LargeConvexHull ) delete WorkingFloatingEntry->LargeConvexHull;
                    Point temp_pT = trans_rot_p->getTranslation();
                    WorkingFloatingEntry->PlacedPolygon = WorkingFloatingEntry->LargePolygon->Transform(angle, &temp_pT);
                    WorkingFloatingEntry->PlacedPolygon->ComputeAngles();
                    WorkingFloatingEntry->PlacedPolygon->CalcSegments();
                    //  Update variables for Fixed polygons lists
                    double tmpFixedArea = FixedArea + WorkingFloatingEntry->LargePolygon->area();
                    tmpFixedHull = CombineHull(FixedHull, WorkingFloatingEntry->PlacedPolygon->GetVertices());
                    WorkingFloatingEntry->LargeConvexHull = new Polygon(tmpFixedHull);
                    WorkingFloatingEntry->LargeConvexHull->ReCalcArea();
                    if ( debug_level > 1 && !tmpFloatList.empty() && CurrentCost >= InBestCost )
                    {
                        OutDebug << "L" << LevelOptimize << ", CurrentCost (" << CurrentCost << ") larger than input best values (" << InBestCost << ") no need to process other polygons in list\n";
                    }
                    if ( debug_level > 1 && !tmpFloatList.empty() && CurrentCost >= BestCost )
                    {
                        OutDebug << "L" << LevelOptimize << ", CurrentCost (" << CurrentCost << ") larger than current best values (" << BestCost << ") no need to process other polygons in list\n";
                    }
                    if ( !tmpFloatList.empty() && (CurrentCost <= InBestCost && CurrentCost <= BestCost) ) //  To go deeper, we need something in list and cost lower than previous min
                    {
                        if ( debug_level > 1 )
                        {
                            OutDebug << "  Applying current translation : " << temp_pT << " to polygon " << FloatPolygon << "\n";
                            OutDebug << "  new hull with " << FixedHull.size() << " vertices, area " << HullArea(FixedHull) << " Fixed polygon area " << tmpFixedArea <<"\n";
                            OutDebug << "  LargeConvexHull area :" << WorkingFloatingEntry->LargeConvexHull->area() << "\n";
                            OutDebug << "  Then call Optimize level again...\n";
                        }
                        OverAll = Hull2BoundingBox(FixedHull);
                        //  Then call Optimize level if the floating list is non empty
                        NSVGpath *Res = OptimizeLevel(WorkingFloatingEntry->LargeConvexHull, tmpFixedList, tmpFloatList, num_rot, StepAngle, tmpFixedArea, CurrentCost, BestCost, FloatPolygon+1, nbFixedPoly, LevelOptimize - 1);
                        if ( Res == NULL )
                        {
                            //  Placement impossible, make sure that CurrentCost will be greater than BestCost
                            CurrentCost = BestCost + 10;
                        }
                        //  After return, the CurrentCost is updated
                        if ( debug_level > 1 )
                        {
                            OutDebug << "-----   Returning at level " << LevelOptimize << ",  Cost is " << CurrentCost << "\n";
                        }
                    }

                    if ( CurrentCost < BestCost  )
                    {   //  Yes record new best value and corresponding position
                        if ( CurrentCost < tmpPolygonArea )
                        {
                            cerr << "Internal error, hull area is lower than polygon area!\n";
                        }
                        //else
                        {
                            BestCost = CurrentCost;
                            BestAngle = angle;
                            BestTranslation = trans_rot_p->getTranslation();
                            Best_i = i;
                            Best_j = j;
                            Best_Poly = FixedPolygon;
                            if ( debug_level > 1 )
                            {
                                OutDebug << "L" << LevelOptimize << ", new best found placing polygon " << FloatPolygon << "\n";
                                OutDebug << "      Vertex " << j << " on vertex " << i << " of polygon " <<  FixedPolygon << "\n";
                                OutDebug << "      Rotation=" << round(angle*180/M_PI) << " Translation " << BestTranslation << " from " << *(rot_p->GetVertex(j)) << " to " <<  *(curFixed->GetVertex(i)) << "\n";
                                OutDebug << "      Hull area:" << tmpHullArea << "  Cost:" << CurrentCost << " Polygon area:" << tmpPolygonArea << "\n";

                            }
                        }
                    }
                    if ( Cached == 0 )
                    {
                        delete trans_rot_p;     //  No need to keep, free memory
                        if ( rot_p->nVertices == 0 )
                        {
                            cerr << " rot_p (" << rot_p << ") invalid with 0 vertices, level =" << LevelOptimize << " Float poly = " << FloatPolygon << "\n";
                        }
                    }
                }
             }
        }
    }
    //  Do some cleaning...
    if ( rot_p->nVertices == 0 )
    {
        cerr << " rot_p (" << rot_p << ") invalid with 0 vertices, level =" << LevelOptimize << " Float poly = " << FloatPolygon << "\n";
    }
    if ( rot_p != NULL ) delete rot_p;
    rot_p = NULL;
    //  Place polygon at BestAngle and Best Translation
    if ( BestAngle < 0 )
    {
        Cost = 1.0e50;        //      Return a large cost, all possible solutions will be better than this one
        return NULL;
    }
    if ( BestCost > InBestCost )    //  Not better at this level
    {
        Cost = BestCost;
        if ( debug_level > 1 )
        {
            OutDebug << "Level " << LevelOptimize << " No better move than " <<  InBestCost << " found, return at upper level\n";
        }
        return WorkingFloatingEntry;
    }
    if ( WorkingFloatingEntry->PlacedPolygon ) delete WorkingFloatingEntry->PlacedPolygon;
    if ( WorkingFloatingEntry->LargeConvexHull ) delete WorkingFloatingEntry->LargeConvexHull;
    WorkingFloatingEntry->PlacedPolygon = WorkingFloatingEntry->LargePolygon->Transform(BestAngle, &BestTranslation);
    WorkingFloatingEntry->PlacedPolygon->ComputeAngles();
    WorkingFloatingEntry->PlacedPolygon->CalcSegments();
    FixedArea += WorkingFloatingEntry->PlacedPolygon->area();
    FixedHull = CombineHull(FixedHull, WorkingFloatingEntry->PlacedPolygon->GetVertices());
    WorkingFloatingEntry->LargeConvexHull = new Polygon(FixedHull);
    WorkingFloatingEntry->LargeConvexHull->ReCalcArea();
    WorkingFloatingEntry->LargeConvexHull->getCentroid();
    Cost = BestCost;
    if ( debug_level > 0 )
    {
        OutDebug << "Level " << LevelOptimize << ": Applying best move : " << BestTranslation << "/" << round(BestAngle*180/M_PI) << "° to polygon " << FloatPolygon  << "(" << WorkingFloatingEntry->id << ") will place vertex " << Best_j << " on vertex " << Best_i << " of polygon " << Best_Poly << "\n";
        OutDebug << "  new hull with " << FixedHull.size() << " vertices, area " << HullArea(FixedHull) << " Fixed polygon area " << FixedArea <<"\n";
        OutDebug << "  LargeConvexHull area :" << WorkingFloatingEntry->LargeConvexHull->area() << " Cost= " << Cost << "\n";
        OutDebug << "  CurFloating.Size=" << CurFloating.size() << "\n";
        int idx_list = 1;
        for (std::list<NSVGpath *>::iterator it=CurFloating.begin(); it != CurFloating.end() ; ++it, idx_list++)
        {
            NSVGpath  *lPath = *it;
            OutDebug << " Element " << idx_list << ": Translation=" << lPath->PlacedPolygon->getTranslation() << " rot=" << round(lPath->PlacedPolygon->getRotation()*180/M_PI) ;
            OutDebug << " Hull area=" << lPath->LargeConvexHull->area() << "\n";
        }
    }
    return WorkingFloatingEntry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc00, %rsp            # imm = 0xC00
movq %rcx, -0x3f8(%rbp)
movq %rdx, -0x3f0(%rbp)
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd %xmm1, -0x40(%rbp)
movq %r9, -0x48(%rbp)
movsd %xmm2, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x3e8(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5aee0
leaq -0x90(%rbp), %rdi
callq 0x5aee0
movabsq $0x54b249ad2594c37d, %rax # imm = 0x54B249AD2594C37D
movq %rax, -0x98(%rbp)
movl $0xffffffff, -0x9c(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0xa0(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0xa4(%rbp) # imm = 0xFFFFFFFF
leaq -0xc0(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x6f46c
leaq -0xe0(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x6f480
leaq -0x100(%rbp), %rdi
callq 0x5b4e0
jmp 0x6f48e
movl $0x0, -0x108(%rbp)
leaq -0x120(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x6f4ac
movq -0x3e8(%rbp), %rax
cmpl $0x1, 0x60(%rax)
jle 0x6f6b1
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x16122(%rip), %rsi     # 0x855f1
callq 0x9530
movq %rax, -0x400(%rbp)
jmp 0x6f4dd
movq -0x400(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x9930
movq %rax, -0x408(%rbp)
jmp 0x6f4f5
movq -0x408(%rbp), %rdi
leaq 0x16106(%rip), %rsi     # 0x85609
callq 0x9530
movq %rax, -0x410(%rbp)
jmp 0x6f511
movq -0x18(%rbp), %rdi
callq 0x5ed10
movsd %xmm0, -0x418(%rbp)
jmp 0x6f524
movsd -0x418(%rbp), %xmm0
movq -0x410(%rbp), %rdi
callq 0x9a30
movq %rax, -0x420(%rbp)
jmp 0x6f541
movq -0x420(%rbp), %rdi
leaq 0x160cc(%rip), %rsi     # 0x8561b
callq 0x9530
movq %rax, -0x428(%rbp)
jmp 0x6f55d
movq -0x428(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
callq 0x9a30
jmp 0x6f570
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x160a6(%rip), %rsi     # 0x85628
callq 0x9530
movq %rax, -0x430(%rbp)
jmp 0x6f590
movq -0x430(%rbp), %rdi
movq -0x48(%rbp), %rax
movsd (%rax), %xmm0
callq 0x9a30
movq %rax, -0x438(%rbp)
jmp 0x6f5ad
movq -0x438(%rbp), %rdi
leaq 0x16078(%rip), %rsi     # 0x85633
callq 0x9530
movq %rax, -0x440(%rbp)
jmp 0x6f5c9
movq -0x440(%rbp), %rdi
movsd -0x50(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x448(%rbp)
jmp 0x6f5e3
movq -0x448(%rbp), %rdi
leaq 0x15cca(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x6f5f8
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x16037(%rip), %rsi     # 0x85641
callq 0x9530
movq %rax, -0x450(%rbp)
jmp 0x6f618
movq -0x3f8(%rbp), %rdi
callq 0x7ffb0
movq -0x450(%rbp), %rdi
movq %rax, %rsi
callq 0x9150
movq %rax, -0x458(%rbp)
jmp 0x6f63c
movq -0x458(%rbp), %rdi
leaq 0x16009(%rip), %rsi     # 0x85653
callq 0x9530
movq %rax, -0x460(%rbp)
jmp 0x6f658
movq -0x3f8(%rbp), %rdi
callq 0x80680
movq -0x460(%rbp), %rdi
movq (%rax), %rsi
addq $0x90, %rsi
callq 0x9530
movq %rax, -0x468(%rbp)
jmp 0x6f683
movq -0x468(%rbp), %rdi
leaq 0x15c2a(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x6f698
jmp 0x6f6b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x7238c
movq -0x18(%rbp), %rsi
leaq -0x138(%rbp), %rdi
callq 0x80730
jmp 0x6f6c3
leaq -0x78(%rbp), %rdi
leaq -0x138(%rbp), %rsi
movq %rsi, -0x480(%rbp)
callq 0x64270
movq -0x480(%rbp), %rdi
callq 0x5b3f0
movq -0x18(%rbp), %rdi
callq 0x615a0
movsd %xmm1, -0x478(%rbp)
movsd %xmm0, -0x470(%rbp)
jmp 0x6f701
movsd -0x478(%rbp), %xmm0
movsd -0x470(%rbp), %xmm1
movsd %xmm1, -0x148(%rbp)
movsd %xmm0, -0x140(%rbp)
movups -0x148(%rbp), %xmm0
movaps %xmm0, -0xe0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x168(%rbp), %rdi
callq 0x61320
jmp 0x6f741
movq -0x3f8(%rbp), %rdi
movups -0x168(%rbp), %xmm0
movups -0x158(%rbp), %xmm1
movaps %xmm1, -0xf0(%rbp)
movaps %xmm0, -0x100(%rbp)
callq 0x80680
movq -0x3f8(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x170(%rbp)
callq 0x806b0
movabsq $0x54b249ad2594c37d, %rax # imm = 0x54B249AD2594C37D
movq %rax, -0x98(%rbp)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, -0xb0(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x490(%rbp)
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x5ed10
movsd %xmm0, -0x488(%rbp)
jmp 0x6f7c8
movq -0x3f0(%rbp), %rsi
movsd -0x488(%rbp), %xmm1
movsd -0x490(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x178(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x805c0
jmp 0x6f7f9
movq -0x3e8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x723b0
movl %eax, -0x494(%rbp)
jmp 0x6f814
leaq -0x198(%rbp), %rdi
callq 0x7fd40
movl -0x494(%rbp), %ecx
movq -0x3e8(%rbp), %rax
movl %ecx, -0x17c(%rbp)
cmpl $0x1, 0x60(%rax)
jle 0x6f8f9
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x15e0f(%rip), %rsi     # 0x8565e
callq 0x9530
movq %rax, -0x4a0(%rbp)
jmp 0x6f85d
movq -0x4a0(%rbp), %rdi
movq -0x170(%rbp), %rsi
addq $0x90, %rsi
callq 0x9530
movq %rax, -0x4a8(%rbp)
jmp 0x6f880
movq -0x4a8(%rbp), %rdi
leaq 0x15de8(%rip), %rsi     # 0x85676
callq 0x9530
movq %rax, -0x4b0(%rbp)
jmp 0x6f89c
movq -0x4b0(%rbp), %rdi
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rax
movl 0x8(%rax), %esi
callq 0x9930
movq %rax, -0x4b8(%rbp)
jmp 0x6f8bf
movq -0x4b8(%rbp), %rdi
leaq 0x15db0(%rip), %rsi     # 0x8567d
callq 0x9530
jmp 0x6f8d4
jmp 0x6f8f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x7fd40
jmp 0x7238c
movq -0x3e8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x6fa4f
movq -0x170(%rbp), %rax
cmpq $0x0, 0x88(%rax)
jne 0x6fa4f
movl $0x38, %edi
callq 0x9550
movq %rax, -0x4c0(%rbp)
jmp 0x6f932
movq -0x4c0(%rbp), %rdi
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rax
movl 0x8(%rax), %esi
movl -0x2c(%rbp), %edx
movl -0x17c(%rbp), %ecx
callq 0x59e70
jmp 0x6f957
movq -0x3e8(%rbp), %rax
movq -0x4c0(%rbp), %rdx
movq -0x170(%rbp), %rcx
movq %rdx, 0x88(%rcx)
cmpl $0x1, 0x60(%rax)
jle 0x6fa4d
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x15cfa(%rip), %rsi     # 0x85689
callq 0x9530
movq %rax, -0x4c8(%rbp)
jmp 0x6f99d
movq -0x4c8(%rbp), %rdi
movq -0x170(%rbp), %rsi
addq $0x90, %rsi
callq 0x9530
movq %rax, -0x4d0(%rbp)
jmp 0x6f9c0
movq -0x4d0(%rbp), %rdi
leaq 0x15cdc(%rip), %rsi     # 0x856aa
callq 0x9530
movq %rax, -0x4d8(%rbp)
jmp 0x6f9dc
movq -0x4d8(%rbp), %rdi
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rax
movl 0x8(%rax), %esi
movl -0x2c(%rbp), %eax
imull %eax, %esi
movl -0x17c(%rbp), %eax
imull %eax, %esi
callq 0x9930
movq %rax, -0x4e0(%rbp)
jmp 0x6fa0e
movq -0x4e0(%rbp), %rdi
leaq 0x15c96(%rip), %rsi     # 0x856b2
callq 0x9530
jmp 0x6fa23
jmp 0x6fa4d
movq -0x4c0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
movl $0x38, %esi
callq 0x9560
jmp 0x7238c
jmp 0x6fac5
movq -0x3e8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x6fac3
movq -0x3e8(%rbp), %rax
cmpl $0x1, 0x60(%rax)
jle 0x6fac3
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x15c42(%rip), %rsi     # 0x856bd
callq 0x9530
movq %rax, -0x4e8(%rbp)
jmp 0x6fa89
movq -0x4e8(%rbp), %rdi
movq -0x170(%rbp), %rsi
addq $0x90, %rsi
callq 0x9530
movq %rax, -0x4f0(%rbp)
jmp 0x6faac
movq -0x4f0(%rbp), %rdi
leaq 0x15c1d(%rip), %rsi     # 0x856d7
callq 0x9530
jmp 0x6fac1
jmp 0x6fac3
jmp 0x6fac5
movl $0x0, -0x19c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x1a8(%rbp)
movsd 0x146c6(%rip), %xmm0    # 0x841a8
ucomisd -0x1a8(%rbp), %xmm0
jbe 0x7193a
movq -0x3e8(%rbp), %rax
cmpl $0x1, 0x60(%rax)
jle 0x6fba6
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x1354d(%rip), %rsi     # 0x83060
callq 0x9530
movq %rax, -0x4f8(%rbp)
jmp 0x6fb21
movq -0x4f8(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x9930
movq %rax, -0x500(%rbp)
jmp 0x6fb39
movq -0x500(%rbp), %rdi
leaq 0x15ba7(%rip), %rsi     # 0x856ee
callq 0x9530
movq %rax, -0x508(%rbp)
jmp 0x6fb55
movsd -0x1a8(%rbp), %xmm0
movsd 0x14653(%rip), %xmm1    # 0x841b8
mulsd %xmm1, %xmm0
movsd 0x124a7(%rip), %xmm1    # 0x82018
divsd %xmm1, %xmm0
callq 0x9220
movq -0x508(%rbp), %rdi
callq 0x9a30
movq %rax, -0x510(%rbp)
jmp 0x6fb8f
movq -0x510(%rbp), %rdi
leaq 0x1571e(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x6fba4
jmp 0x6fba6
cmpq $0x0, -0x58(%rbp)
je 0x6fbcd
movq -0x58(%rbp), %rax
movq %rax, -0x518(%rbp)
cmpq $0x0, %rax
je 0x6fbcb
movq -0x518(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x6fbcd
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
movsd -0x1a8(%rbp), %xmm0
callq 0x61ed0
movq %rax, -0x520(%rbp)
jmp 0x6fbee
movq -0x3e8(%rbp), %rax
movq -0x520(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq 0x278(%rax), %rcx
incq %rcx
movq %rcx, 0x278(%rax)
movq -0x58(%rbp), %rdi
callq 0x62930
jmp 0x6fc1c
movq -0x58(%rbp), %rdi
callq 0x63030
jmp 0x6fc27
movq -0x3f0(%rbp), %rdi
movl $0x0, -0x108(%rbp)
movl $0x0, -0x1ac(%rbp)
callq 0x803f0
movq %rax, -0x1b8(%rbp)
movq -0x3f0(%rbp), %rdi
callq 0x80450
movq %rax, -0x1c0(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x80420
testb $0x1, %al
jne 0x6fc7d
jmp 0x7190f
leaq -0x1b8(%rbp), %rdi
callq 0x80480
movq (%rax), %rax
movq %rax, -0x1c8(%rbp)
movq -0x1c8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x1d0(%rbp)
movl $0x0, -0x1d4(%rbp)
movl -0x1d4(%rbp), %eax
movq -0x1d0(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x718ed
movq -0x3e8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jle 0x6fcf2
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
movq 0x482af(%rip), %rsi     # 0xb7f98
callq 0x9590
jmp 0x6fcf0
jmp 0x6fcf2
movl $0x0, -0x1d8(%rbp)
movl -0x1d8(%rbp), %eax
movq -0x58(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x718c8
movq -0x3e8(%rbp), %rax
movq $0x0, -0x60(%rbp)
movl $0x0, -0x1dc(%rbp)
cmpl $0x0, 0x64(%rax)
je 0x6fd80
movq -0x1c8(%rbp), %rax
cmpl $0x0, 0x80(%rax)
je 0x6fd80
movq -0x170(%rbp), %rax
movq 0x88(%rax), %rdi
movl -0x1d8(%rbp), %esi
movl -0x19c(%rbp), %edx
movl -0x1ac(%rbp), %ecx
leaq -0x60(%rbp), %r8
callq 0x5a070
movl %eax, -0x524(%rbp)
jmp 0x6fd74
movl -0x524(%rbp), %eax
movl %eax, -0x1dc(%rbp)
cmpl $0x0, -0x1dc(%rbp)
jge 0x6ff4f
movq -0x3e8(%rbp), %rax
movq 0x2b0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x2b0(%rax)
cmpl $0x2, 0x60(%rax)
jle 0x6ff4a
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x1593f(%rip), %rsi     # 0x85701
callq 0x9530
movq %rax, -0x530(%rbp)
jmp 0x6fdd0
movq -0x530(%rbp), %rdi
movl 0x10(%rbp), %esi
callq 0x9930
movq %rax, -0x538(%rbp)
jmp 0x6fde8
movq -0x538(%rbp), %rdi
leaq 0x15c3b(%rip), %rsi     # 0x85a31
callq 0x9530
movq %rax, -0x540(%rbp)
jmp 0x6fe04
movq -0x540(%rbp), %rdi
movl -0x1d8(%rbp), %esi
callq 0x9930
movq %rax, -0x548(%rbp)
jmp 0x6fe1f
movq -0x548(%rbp), %rdi
leaq 0x15d86(%rip), %rsi     # 0x85bb3
callq 0x9530
movq %rax, -0x550(%rbp)
jmp 0x6fe3b
movq -0x550(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x9930
movq %rax, -0x558(%rbp)
jmp 0x6fe56
movq -0x558(%rbp), %rdi
leaq 0x158bb(%rip), %rsi     # 0x8571f
callq 0x9530
movq %rax, -0x560(%rbp)
jmp 0x6fe72
movq -0x560(%rbp), %rdi
movl -0x108(%rbp), %esi
callq 0x9930
movq %rax, -0x568(%rbp)
jmp 0x6fe8d
movq -0x568(%rbp), %rdi
leaq 0x14723(%rip), %rsi     # 0x845be
callq 0x9530
movq %rax, -0x570(%rbp)
jmp 0x6fea9
movq -0x570(%rbp), %rdi
movl -0x1ac(%rbp), %esi
callq 0x9930
movq %rax, -0x578(%rbp)
jmp 0x6fec4
movq -0x578(%rbp), %rdi
leaq 0x13292(%rip), %rsi     # 0x83164
callq 0x9530
movq %rax, -0x580(%rbp)
jmp 0x6fee0
movq -0x580(%rbp), %rdi
leaq 0x1587a(%rip), %rsi     # 0x85768
callq 0x9530
movq %rax, -0x588(%rbp)
jmp 0x6fefc
movq -0x1d0(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x7ff40
movq %rax, -0x590(%rbp)
jmp 0x6ff17
movq -0x590(%rbp), %rsi
movq -0x588(%rbp), %rdi
callq 0x80760
movq %rax, -0x598(%rbp)
jmp 0x6ff33
movq -0x598(%rbp), %rdi
leaq 0x1537a(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x6ff48
jmp 0x6ff4a
jmp 0x7188b
cmpl $0x0, -0x1dc(%rbp)
jne 0x702a1
movq -0x3e8(%rbp), %rax
movq 0x2a0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x2a0(%rax)
movq 0x280(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x280(%rax)
movq -0x58(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x70049
movq 0x4804c(%rip), %rdi     # 0xb7fe8
leaq 0x15789(%rip), %rsi     # 0x8572c
callq 0x9530
movq %rax, -0x5a0(%rbp)
jmp 0x6ffb1
movq -0x5a0(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x9450
movq %rax, -0x5a8(%rbp)
jmp 0x6ffca
movq -0x5a8(%rbp), %rdi
leaq 0x1575d(%rip), %rsi     # 0x85735
callq 0x9530
movq %rax, -0x5b0(%rbp)
jmp 0x6ffe6
movq -0x5b0(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x9930
movq %rax, -0x5b8(%rbp)
jmp 0x6fffe
movq -0x5b8(%rbp), %rdi
leaq 0x1574c(%rip), %rsi     # 0x85758
callq 0x9530
movq %rax, -0x5c0(%rbp)
jmp 0x7001a
movq -0x5c0(%rbp), %rdi
movl 0x10(%rbp), %esi
callq 0x9930
movq %rax, -0x5c8(%rbp)
jmp 0x70032
movq -0x5c8(%rbp), %rdi
leaq 0x1527b(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x70047
jmp 0x70049
movq -0x58(%rbp), %rdi
movl -0x1d8(%rbp), %esi
movq -0x1d0(%rbp), %rdx
movl -0x1d4(%rbp), %ecx
callq 0x72440
movb %al, -0x5c9(%rbp)
jmp 0x7006d
movb -0x5c9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x70229
movq -0x3e8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x700cc
movq -0x1c8(%rbp), %rax
cmpl $0x0, 0x80(%rax)
je 0x700cc
movq -0x170(%rbp), %rax
movq 0x88(%rax), %rdi
movl -0x1d8(%rbp), %esi
movl -0x19c(%rbp), %edx
movl -0x1ac(%rbp), %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x5a160
jmp 0x700ca
jmp 0x700cc
movq -0x3e8(%rbp), %rax
cmpl $0x2, 0x60(%rax)
jle 0x70224
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x15b38(%rip), %rsi     # 0x85c27
callq 0x9530
movq %rax, -0x5d8(%rbp)
jmp 0x700fd
movq -0x5d8(%rbp), %rdi
movl 0x10(%rbp), %esi
callq 0x9930
movq %rax, -0x5e0(%rbp)
jmp 0x70115
movq -0x5e0(%rbp), %rdi
leaq 0x1590e(%rip), %rsi     # 0x85a31
callq 0x9530
movq %rax, -0x5e8(%rbp)
jmp 0x70131
movq -0x5e8(%rbp), %rdi
movl -0x1d8(%rbp), %esi
callq 0x9930
movq %rax, -0x5f0(%rbp)
jmp 0x7014c
movq -0x5f0(%rbp), %rdi
leaq 0x15a59(%rip), %rsi     # 0x85bb3
callq 0x9530
movq %rax, -0x5f8(%rbp)
jmp 0x70168
movq -0x5f8(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x9930
movq %rax, -0x600(%rbp)
jmp 0x70183
movq -0x600(%rbp), %rdi
leaq 0x1558e(%rip), %rsi     # 0x8571f
callq 0x9530
movq %rax, -0x608(%rbp)
jmp 0x7019f
movq -0x608(%rbp), %rdi
movl -0x108(%rbp), %esi
callq 0x9930
movq %rax, -0x610(%rbp)
jmp 0x701ba
movq -0x610(%rbp), %rdi
leaq 0x1559f(%rip), %rsi     # 0x85767
callq 0x9530
movq %rax, -0x618(%rbp)
jmp 0x701d6
movq -0x1d0(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x7ff40
movq %rax, -0x620(%rbp)
jmp 0x701f1
movq -0x620(%rbp), %rsi
movq -0x618(%rbp), %rdi
callq 0x80760
movq %rax, -0x628(%rbp)
jmp 0x7020d
movq -0x628(%rbp), %rdi
leaq 0x15559(%rip), %rsi     # 0x85774
callq 0x9530
jmp 0x70222
jmp 0x70224
jmp 0x7188b
movq -0x58(%rbp), %rax
movq %rax, -0x638(%rbp)
movq -0x1d0(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x7ff40
movq %rax, -0x630(%rbp)
jmp 0x7024f
movq -0x630(%rbp), %rsi
movq -0x638(%rbp), %rdi
movl -0x1d8(%rbp), %edx
callq 0x61b20
movq %rax, -0x640(%rbp)
jmp 0x70271
movq -0x3e8(%rbp), %rax
movq -0x640(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq 0x270(%rax), %rcx
incq %rcx
movq %rcx, 0x270(%rax)
movq -0x60(%rbp), %rdi
callq 0x63030
jmp 0x7029f
jmp 0x702ba
movq -0x3e8(%rbp), %rax
movq 0x2a8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x2a8(%rax)
jmp 0x702bc
movq -0x170(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
leaq -0x1f0(%rbp), %rdi
callq 0x5b520
jmp 0x702da
movups -0x1f0(%rbp), %xmm0
movaps %xmm0, -0x120(%rbp)
movsd -0x1a8(%rbp), %xmm0
movsd %xmm0, -0x658(%rbp)
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x615a0
movsd %xmm1, -0x650(%rbp)
movsd %xmm0, -0x648(%rbp)
jmp 0x7031a
movsd -0x650(%rbp), %xmm0
movsd -0x648(%rbp), %xmm1
movsd %xmm1, -0x200(%rbp)
movsd %xmm0, -0x1f8(%rbp)
movq -0x60(%rbp), %rdi
callq 0x7fd80
movsd %xmm1, -0x668(%rbp)
movsd %xmm0, -0x660(%rbp)
jmp 0x70355
movsd -0x658(%rbp), %xmm0
movsd -0x668(%rbp), %xmm1
movsd -0x660(%rbp), %xmm2
movsd %xmm2, -0x210(%rbp)
movsd %xmm1, -0x208(%rbp)
movsd -0x200(%rbp), %xmm1
movsd -0x1f8(%rbp), %xmm2
movsd -0x210(%rbp), %xmm3
movsd -0x208(%rbp), %xmm4
leaq -0x120(%rbp), %rdi
callq 0x7fdb0
jmp 0x703ab
movq -0x3f0(%rbp), %rsi
movq -0x60(%rbp), %rax
movq %rax, -0x670(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x805c0
jmp 0x703cb
movq -0x670(%rbp), %rsi
movq -0x3e8(%rbp), %rdi
movl -0x1dc(%rbp), %r9d
leaq -0x228(%rbp), %rdx
leaq -0x100(%rbp), %rcx
leaq -0x120(%rbp), %r8
callq 0x72690
movl %eax, -0x674(%rbp)
jmp 0x70402
movl -0x674(%rbp), %eax
movl %eax, -0x104(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x7fd40
movl -0x674(%rbp), %eax
cmpl $0x0, %eax
je 0x70770
movq -0x3e8(%rbp), %rax
cmpl $0x2, 0x60(%rax)
jle 0x705db
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x157db(%rip), %rsi     # 0x85c27
callq 0x9530
movq %rax, -0x680(%rbp)
jmp 0x7045a
movq -0x680(%rbp), %rdi
movl 0x10(%rbp), %esi
callq 0x9930
movq %rax, -0x688(%rbp)
jmp 0x70472
movq -0x688(%rbp), %rdi
leaq 0x155b1(%rip), %rsi     # 0x85a31
callq 0x9530
movq %rax, -0x690(%rbp)
jmp 0x7048e
movq -0x690(%rbp), %rdi
movl -0x1d8(%rbp), %esi
callq 0x9930
movq %rax, -0x698(%rbp)
jmp 0x704a9
movq -0x698(%rbp), %rdi
leaq 0x156fc(%rip), %rsi     # 0x85bb3
callq 0x9530
movq %rax, -0x6a0(%rbp)
jmp 0x704c5
movq -0x6a0(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x9930
movq %rax, -0x6a8(%rbp)
jmp 0x704e0
movq -0x6a8(%rbp), %rdi
leaq 0x15231(%rip), %rsi     # 0x8571f
callq 0x9530
movq %rax, -0x6b0(%rbp)
jmp 0x704fc
movq -0x6b0(%rbp), %rdi
movl -0x108(%rbp), %esi
callq 0x9930
movq %rax, -0x6b8(%rbp)
jmp 0x70517
movq -0x6b8(%rbp), %rdi
leaq 0x15242(%rip), %rsi     # 0x85767
callq 0x9530
movq %rax, -0x6c0(%rbp)
jmp 0x70533
movq -0x1d0(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x7ff40
movq %rax, -0x6c8(%rbp)
jmp 0x7054e
movq -0x6c8(%rbp), %rsi
movq -0x6c0(%rbp), %rdi
callq 0x80760
movq %rax, -0x6d0(%rbp)
jmp 0x7056a
movq -0x6d0(%rbp), %rdi
leaq 0x15215(%rip), %rsi     # 0x8578d
callq 0x9530
movq %rax, -0x6d8(%rbp)
jmp 0x70586
movq -0x6d8(%rbp), %rdi
movl -0x104(%rbp), %esi
callq 0x9930
movq %rax, -0x6e0(%rbp)
jmp 0x705a1
movq -0x6e0(%rbp), %rdi
leaq 0x14d0c(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x705b6
jmp 0x705db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x7fd40
jmp 0x7238c
movq -0x1c8(%rbp), %rax
cmpl $0x0, 0x80(%rax)
je 0x7065a
movl -0x104(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x7065a
movq -0x3e8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x70634
movq -0x170(%rbp), %rax
movq 0x88(%rax), %rdi
movl -0x1d8(%rbp), %esi
movl -0x19c(%rbp), %edx
movl -0x1ac(%rbp), %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x5a160
jmp 0x70632
jmp 0x70634
movq -0x60(%rbp), %rax
movq %rax, -0x6e8(%rbp)
cmpq $0x0, %rax
je 0x70652
movq -0x6e8(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x60(%rbp)
cmpl $0x0, -0x1dc(%rbp)
jne 0x70690
cmpq $0x0, -0x60(%rbp)
je 0x70690
movq -0x60(%rbp), %rax
movq %rax, -0x6f0(%rbp)
cmpq $0x0, %rax
je 0x70688
movq -0x6f0(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x60(%rbp)
movq -0x3e8(%rbp), %rax
movq 0x298(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x298(%rax)
movq -0x58(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x7076b
movq 0x4792a(%rip), %rdi     # 0xb7fe8
leaq 0x15067(%rip), %rsi     # 0x8572c
callq 0x9530
movq %rax, -0x6f8(%rbp)
jmp 0x706d3
movq -0x6f8(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x9450
movq %rax, -0x700(%rbp)
jmp 0x706ec
movq -0x700(%rbp), %rdi
leaq 0x1503b(%rip), %rsi     # 0x85735
callq 0x9530
movq %rax, -0x708(%rbp)
jmp 0x70708
movq -0x708(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x9930
movq %rax, -0x710(%rbp)
jmp 0x70720
movq -0x710(%rbp), %rdi
leaq 0x1502a(%rip), %rsi     # 0x85758
callq 0x9530
movq %rax, -0x718(%rbp)
jmp 0x7073c
movq -0x718(%rbp), %rdi
movl 0x10(%rbp), %esi
callq 0x9930
movq %rax, -0x720(%rbp)
jmp 0x70754
movq -0x720(%rbp), %rdi
leaq 0x14b59(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x70769
jmp 0x7076b
jmp 0x7188b
movq -0x1c8(%rbp), %rax
cmpl $0x0, 0x80(%rax)
je 0x707cd
cmpl $0x0, -0x1dc(%rbp)
jne 0x707cd
movq -0x3e8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x707cb
movq -0x170(%rbp), %rax
movq 0x88(%rax), %rdi
movl -0x1d8(%rbp), %esi
movl -0x19c(%rbp), %edx
movl -0x1ac(%rbp), %ecx
movq -0x60(%rbp), %r8
callq 0x5a160
jmp 0x707c1
movl $0x1, -0x1dc(%rbp)
jmp 0x707cd
movq -0x60(%rbp), %rsi
leaq -0x258(%rbp), %rdi
callq 0x80730
jmp 0x707df
leaq -0x240(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x258(%rbp), %rdx
callq 0x5a8f0
jmp 0x707f8
leaq -0x258(%rbp), %rdi
callq 0x5b3f0
leaq -0x240(%rbp), %rdi
callq 0x5aa10
movsd %xmm0, -0x728(%rbp)
jmp 0x7081a
movsd -0x728(%rbp), %xmm0
movsd %xmm0, -0x260(%rbp)
leaq -0x280(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x5abd0
jmp 0x7083c
movq -0x3e8(%rbp), %rax
movsd -0x260(%rbp), %xmm0
movsd %xmm0, -0x740(%rbp)
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0x738(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x807d0
movsd %xmm0, -0x730(%rbp)
jmp 0x70876
movq -0x3e8(%rbp), %rax
movsd -0x740(%rbp), %xmm1
movsd -0x730(%rbp), %xmm2
movsd -0x738(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x288(%rbp)
cmpl $0x1, 0x60(%rax)
jle 0x70a60
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x150a8(%rip), %rsi     # 0x85969
callq 0x9530
movq %rax, -0x748(%rbp)
jmp 0x708cf
movq -0x748(%rbp), %rdi
movl -0x1d8(%rbp), %esi
callq 0x9930
movq %rax, -0x750(%rbp)
jmp 0x708ea
movq -0x750(%rbp), %rdi
leaq 0x14e9f(%rip), %rsi     # 0x85797
callq 0x9530
movq %rax, -0x758(%rbp)
jmp 0x70906
movq -0x758(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x9930
movq %rax, -0x760(%rbp)
jmp 0x70921
movq -0x760(%rbp), %rdi
leaq 0x14e6d(%rip), %rsi     # 0x8579c
callq 0x9530
movq %rax, -0x768(%rbp)
jmp 0x7093d
movq -0x768(%rbp), %rdi
movl -0x108(%rbp), %esi
callq 0x9930
movq %rax, -0x770(%rbp)
jmp 0x70958
movq -0x770(%rbp), %rdi
leaq 0x14e43(%rip), %rsi     # 0x857a9
callq 0x9530
movq %rax, -0x778(%rbp)
jmp 0x70974
movq -0x778(%rbp), %rdi
movsd -0x260(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x780(%rbp)
jmp 0x70991
movq -0x780(%rbp), %rdi
leaq 0x14e16(%rip), %rsi     # 0x857b5
callq 0x9530
movq %rax, -0x788(%rbp)
jmp 0x709ad
movq -0x788(%rbp), %rdi
movsd -0x288(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x790(%rbp)
jmp 0x709ca
movq -0x790(%rbp), %rdi
leaq 0x14de4(%rip), %rsi     # 0x857bc
callq 0x9530
movq %rax, -0x798(%rbp)
jmp 0x709e6
movq -0x798(%rbp), %rdi
movsd -0x288(%rbp), %xmm0
movsd -0x178(%rbp), %xmm1
subsd %xmm1, %xmm0
callq 0x9a30
movq %rax, -0x7a0(%rbp)
jmp 0x70a0f
movq -0x7a0(%rbp), %rdi
leaq 0x1489e(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x70a24
jmp 0x70a60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x5b3f0
jmp 0x7238c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x718b7
movq -0x3f8(%rbp), %rsi
leaq -0x2a0(%rbp), %rdi
callq 0x805c0
jmp 0x70a75
movq -0x3f0(%rbp), %rsi
leaq -0x2b8(%rbp), %rdi
callq 0x805c0
jmp 0x70a8a
leaq -0x2b8(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0x7ff70
jmp 0x70a9f
movq -0x170(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x70b02
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x7a8(%rbp)
cmpq $0x0, %rax
je 0x70ad2
movq -0x7a8(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x70b02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x718ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x7189f
movq -0x170(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x70b37
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x7b0(%rbp)
cmpq $0x0, %rax
je 0x70b35
movq -0x7b0(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x70b37
movq -0x60(%rbp), %rdi
callq 0x7fd80
movsd %xmm1, -0x7c0(%rbp)
movsd %xmm0, -0x7b8(%rbp)
jmp 0x70b52
movsd -0x7c0(%rbp), %xmm0
movsd -0x7b8(%rbp), %xmm1
movsd %xmm1, -0x2c8(%rbp)
movsd %xmm0, -0x2c0(%rbp)
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
movsd -0x1a8(%rbp), %xmm0
leaq -0x2c8(%rbp), %rsi
callq 0x623c0
movq %rax, -0x7c8(%rbp)
jmp 0x70b9a
movq -0x7c8(%rbp), %rcx
movq -0x170(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x62930
jmp 0x70bbe
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x63030
jmp 0x70bd0
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x7d8(%rbp)
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x5ed10
movsd %xmm0, -0x7d0(%rbp)
jmp 0x70bf7
movsd -0x7d0(%rbp), %xmm1
movsd -0x7d8(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x2d0(%rbp)
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rsi
leaq -0x300(%rbp), %rdi
callq 0x80730
jmp 0x70c2c
leaq -0x2e8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x300(%rbp), %rdx
callq 0x5a8f0
jmp 0x70c45
leaq -0x90(%rbp), %rdi
leaq -0x2e8(%rbp), %rsi
movq %rsi, -0x7e8(%rbp)
callq 0x64270
movq -0x7e8(%rbp), %rdi
callq 0x5b3f0
leaq -0x300(%rbp), %rdi
callq 0x5b3f0
movl $0xc0, %edi
callq 0x9550
movq %rax, -0x7e0(%rbp)
jmp 0x70c8a
movq -0x7e0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x5e780
jmp 0x70c9f
movq -0x7e0(%rbp), %rcx
movq -0x170(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x612f0
jmp 0x70cc3
movq -0x3e8(%rbp), %rax
cmpl $0x1, 0x60(%rax)
jle 0x70e04
leaq -0x2a0(%rbp), %rdi
callq 0x806e0
testb $0x1, %al
jne 0x70e04
movsd -0x288(%rbp), %xmm0
ucomisd -0x50(%rbp), %xmm0
jb 0x70e04
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x12353(%rip), %rsi     # 0x83060
callq 0x9530
movq %rax, -0x7f0(%rbp)
jmp 0x70d1b
movq -0x7f0(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x9930
movq %rax, -0x7f8(%rbp)
jmp 0x70d33
movq -0x7f8(%rbp), %rdi
leaq 0x14a89(%rip), %rsi     # 0x857ca
callq 0x9530
movq %rax, -0x800(%rbp)
jmp 0x70d4f
movq -0x800(%rbp), %rdi
movsd -0x288(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x808(%rbp)
jmp 0x70d6c
movq -0x808(%rbp), %rdi
leaq 0x14a60(%rip), %rsi     # 0x857da
callq 0x9530
movq %rax, -0x810(%rbp)
jmp 0x70d88
movq -0x810(%rbp), %rdi
movsd -0x50(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x818(%rbp)
jmp 0x70da2
movq -0x818(%rbp), %rdi
leaq 0x14a4c(%rip), %rsi     # 0x857fc
callq 0x9530
jmp 0x70db7
jmp 0x70e04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x300(%rbp), %rdi
callq 0x5b3f0
jmp 0x7189f
movq -0x7e0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
movl $0xc0, %esi
callq 0x9560
jmp 0x7189f
movq -0x3e8(%rbp), %rax
cmpl $0x1, 0x60(%rax)
jle 0x70f00
leaq -0x2a0(%rbp), %rdi
callq 0x806e0
testb $0x1, %al
jne 0x70f00
movsd -0x288(%rbp), %xmm0
ucomisd -0x98(%rbp), %xmm0
jb 0x70f00
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x1220f(%rip), %rsi     # 0x83060
callq 0x9530
movq %rax, -0x820(%rbp)
jmp 0x70e5f
movq -0x820(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x9930
movq %rax, -0x828(%rbp)
jmp 0x70e77
movq -0x828(%rbp), %rdi
leaq 0x14945(%rip), %rsi     # 0x857ca
callq 0x9530
movq %rax, -0x830(%rbp)
jmp 0x70e93
movq -0x830(%rbp), %rdi
movsd -0x288(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x838(%rbp)
jmp 0x70eb0
movq -0x838(%rbp), %rdi
leaq 0x1496b(%rip), %rsi     # 0x85829
callq 0x9530
movq %rax, -0x840(%rbp)
jmp 0x70ecc
movq -0x840(%rbp), %rdi
movsd -0x98(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x848(%rbp)
jmp 0x70ee9
movq -0x848(%rbp), %rdi
leaq 0x14905(%rip), %rsi     # 0x857fc
callq 0x9530
jmp 0x70efe
jmp 0x70f00
leaq -0x2a0(%rbp), %rdi
callq 0x806e0
testb $0x1, %al
jne 0x71334
movsd -0x288(%rbp), %xmm1
movsd -0x50(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x71334
movsd -0x288(%rbp), %xmm1
movsd -0x98(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x71334
movq -0x3e8(%rbp), %rax
cmpl $0x1, 0x60(%rax)
jle 0x7113d
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x148e5(%rip), %rsi     # 0x8584d
callq 0x9530
movq %rax, -0x850(%rbp)
jmp 0x70f76
movq -0x850(%rbp), %rdi
leaq -0x2c8(%rbp), %rsi
callq 0x80760
movq %rax, -0x858(%rbp)
jmp 0x70f92
movq -0x858(%rbp), %rdi
leaq 0x14a78(%rip), %rsi     # 0x85a18
callq 0x9530
movq %rax, -0x860(%rbp)
jmp 0x70fae
movq -0x860(%rbp), %rdi
movl 0x10(%rbp), %esi
callq 0x9930
movq %rax, -0x868(%rbp)
jmp 0x70fc6
movq -0x868(%rbp), %rdi
leaq 0x142e7(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x70fdb
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x14882(%rip), %rsi     # 0x8586f
callq 0x9530
movq %rax, -0x870(%rbp)
jmp 0x70ffb
leaq -0x78(%rbp), %rdi
callq 0x5add0
movq -0x870(%rbp), %rdi
movq %rax, %rsi
callq 0x9150
movq %rax, -0x878(%rbp)
jmp 0x7101c
movq -0x878(%rbp), %rdi
leaq 0x14856(%rip), %rsi     # 0x85880
callq 0x9530
movq %rax, -0x880(%rbp)
jmp 0x71038
leaq -0x78(%rbp), %rdi
callq 0x5aa10
movsd %xmm0, -0x888(%rbp)
jmp 0x7104b
movsd -0x888(%rbp), %xmm0
movq -0x880(%rbp), %rdi
callq 0x9a30
movq %rax, -0x890(%rbp)
jmp 0x71068
movq -0x890(%rbp), %rdi
leaq 0x1481b(%rip), %rsi     # 0x85891
callq 0x9530
movq %rax, -0x898(%rbp)
jmp 0x71084
movq -0x898(%rbp), %rdi
movsd -0x2d0(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x8a0(%rbp)
jmp 0x710a1
movq -0x8a0(%rbp), %rdi
leaq 0x1420c(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x710b6
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x147de(%rip), %rsi     # 0x858a6
callq 0x9530
movq %rax, -0x8a8(%rbp)
jmp 0x710d6
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x5ed10
movsd %xmm0, -0x8b0(%rbp)
jmp 0x710f0
movsd -0x8b0(%rbp), %xmm0
movq -0x8a8(%rbp), %rdi
callq 0x9a30
movq %rax, -0x8b8(%rbp)
jmp 0x7110d
movq -0x8b8(%rbp), %rdi
leaq 0x141a0(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x71122
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x1478b(%rip), %rsi     # 0x858bf
callq 0x9530
jmp 0x7113b
jmp 0x7113d
leaq -0x320(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x5abd0
jmp 0x7114f
movups -0x320(%rbp), %xmm0
movups -0x310(%rbp), %xmm1
movaps %xmm1, -0xf0(%rbp)
movaps %xmm0, -0x100(%rbp)
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x8c0(%rbp)
leaq -0x340(%rbp), %rdi
leaq -0x2b8(%rbp), %rsi
callq 0x805c0
jmp 0x71192
leaq -0x358(%rbp), %rdi
leaq -0x2a0(%rbp), %rsi
callq 0x805c0
jmp 0x711a7
movq -0x8c0(%rbp), %rsi
movq -0x3e8(%rbp), %rdi
movl -0x2c(%rbp), %r8d
movsd -0x38(%rbp), %xmm0
movsd -0x2d0(%rbp), %xmm1
movsd -0x98(%rbp), %xmm2
movl 0x10(%rbp), %ecx
incl %ecx
movl 0x18(%rbp), %edx
movl 0x20(%rbp), %r9d
decl %r9d
movq %rsp, %rax
movl %r9d, 0x10(%rax)
movl %edx, 0x8(%rax)
movl %ecx, (%rax)
leaq -0x340(%rbp), %rdx
leaq -0x358(%rbp), %rcx
leaq -0x288(%rbp), %r9
callq 0x6f3b0
movq %rax, -0x8c8(%rbp)
jmp 0x7120c
leaq -0x358(%rbp), %rdi
callq 0x7fd40
leaq -0x340(%rbp), %rdi
callq 0x7fd40
movq -0x8c8(%rbp), %rax
movq %rax, -0x328(%rbp)
cmpq $0x0, -0x328(%rbp)
jne 0x71299
movsd 0x10dc4(%rip), %xmm0    # 0x82008
addsd -0x98(%rbp), %xmm0
movsd %xmm0, -0x288(%rbp)
jmp 0x71299
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x71288
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x358(%rbp), %rdi
callq 0x7fd40
leaq -0x340(%rbp), %rdi
callq 0x7fd40
jmp 0x7189f
movq -0x3e8(%rbp), %rax
cmpl $0x1, 0x60(%rax)
jle 0x71332
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x14628(%rip), %rsi     # 0x858e4
callq 0x9530
movq %rax, -0x8d0(%rbp)
jmp 0x712ca
movq -0x8d0(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x9930
movq %rax, -0x8d8(%rbp)
jmp 0x712e2
movq -0x8d8(%rbp), %rdi
leaq 0x14610(%rip), %rsi     # 0x85900
callq 0x9530
movq %rax, -0x8e0(%rbp)
jmp 0x712fe
movq -0x8e0(%rbp), %rdi
movsd -0x288(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x8e8(%rbp)
jmp 0x7131b
movq -0x8e8(%rbp), %rdi
leaq 0x13f92(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x71330
jmp 0x71332
jmp 0x71334
movsd -0x288(%rbp), %xmm1
movsd -0x98(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x71778
movsd -0x288(%rbp), %xmm1
movsd -0x178(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x7137b
movq 0x46c7d(%rip), %rdi     # 0xb7fe8
leaq 0x1459a(%rip), %rsi     # 0x8590c
callq 0x9530
jmp 0x71379
jmp 0x7137b
movsd -0x288(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
movsd -0x1a8(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
movq -0x60(%rbp), %rdi
callq 0x7fd80
movsd %xmm1, -0x8f8(%rbp)
movsd %xmm0, -0x8f0(%rbp)
jmp 0x713b6
movq -0x3e8(%rbp), %rax
movsd -0x8f8(%rbp), %xmm0
movsd -0x8f0(%rbp), %xmm1
movsd %xmm1, -0x368(%rbp)
movsd %xmm0, -0x360(%rbp)
movq -0x368(%rbp), %rcx
movq %rcx, -0xc0(%rbp)
movq -0x360(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
movl -0x1d4(%rbp), %ecx
movl %ecx, -0x9c(%rbp)
movl -0x1d8(%rbp), %ecx
movl %ecx, -0xa0(%rbp)
movl -0x108(%rbp), %ecx
movl %ecx, -0xa4(%rbp)
cmpl $0x1, 0x60(%rax)
jle 0x71776
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x11c27(%rip), %rsi     # 0x83060
callq 0x9530
movq %rax, -0x900(%rbp)
jmp 0x71447
movq -0x900(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x9930
movq %rax, -0x908(%rbp)
jmp 0x7145f
movq -0x908(%rbp), %rdi
leaq 0x144d6(%rip), %rsi     # 0x85943
callq 0x9530
movq %rax, -0x910(%rbp)
jmp 0x7147b
movq -0x910(%rbp), %rdi
movl 0x10(%rbp), %esi
callq 0x9930
movq %rax, -0x918(%rbp)
jmp 0x71493
movq -0x918(%rbp), %rdi
leaq 0x13e1a(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x714a8
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x144ab(%rip), %rsi     # 0x85965
callq 0x9530
movq %rax, -0x920(%rbp)
jmp 0x714c8
movq -0x920(%rbp), %rdi
movl -0x1d8(%rbp), %esi
callq 0x9930
movq %rax, -0x928(%rbp)
jmp 0x714e3
movq -0x928(%rbp), %rdi
leaq 0x146c2(%rip), %rsi     # 0x85bb3
callq 0x9530
movq %rax, -0x930(%rbp)
jmp 0x714ff
movq -0x930(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x9930
movq %rax, -0x938(%rbp)
jmp 0x7151a
movq -0x938(%rbp), %rdi
leaq 0x14274(%rip), %rsi     # 0x8579c
callq 0x9530
movq %rax, -0x940(%rbp)
jmp 0x71536
movq -0x940(%rbp), %rdi
movl -0x108(%rbp), %esi
callq 0x9930
movq %rax, -0x948(%rbp)
jmp 0x71551
movq -0x948(%rbp), %rdi
leaq 0x13d5c(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x71566
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x143fb(%rip), %rsi     # 0x85973
callq 0x9530
movq %rax, -0x950(%rbp)
jmp 0x71586
movsd -0x1a8(%rbp), %xmm0
movsd 0x12c22(%rip), %xmm1    # 0x841b8
mulsd %xmm1, %xmm0
movsd 0x10a76(%rip), %xmm1    # 0x82018
divsd %xmm1, %xmm0
callq 0x9220
movq -0x950(%rbp), %rdi
callq 0x9a30
movq %rax, -0x958(%rbp)
jmp 0x715c0
movq -0x958(%rbp), %rdi
leaq 0x143b5(%rip), %rsi     # 0x85983
callq 0x9530
movq %rax, -0x960(%rbp)
jmp 0x715dc
movq -0x960(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x80760
movq %rax, -0x968(%rbp)
jmp 0x715f8
movq -0x968(%rbp), %rdi
leaq 0x1438b(%rip), %rsi     # 0x85991
callq 0x9530
movq %rax, -0x970(%rbp)
jmp 0x71614
movq -0x58(%rbp), %rdi
movl -0x1d8(%rbp), %esi
callq 0x7ff40
movq %rax, -0x978(%rbp)
jmp 0x7162c
movq -0x978(%rbp), %rsi
movq -0x970(%rbp), %rdi
callq 0x80760
movq %rax, -0x980(%rbp)
jmp 0x71648
movq -0x980(%rbp), %rdi
leaq 0x13cac(%rip), %rsi     # 0x85302
callq 0x9530
movq %rax, -0x988(%rbp)
jmp 0x71664
movq -0x1d0(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x7ff40
movq %rax, -0x990(%rbp)
jmp 0x7167f
movq -0x990(%rbp), %rsi
movq -0x988(%rbp), %rdi
callq 0x80760
movq %rax, -0x998(%rbp)
jmp 0x7169b
movq -0x998(%rbp), %rdi
leaq 0x13c12(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x716b0
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x142d6(%rip), %rsi     # 0x85998
callq 0x9530
movq %rax, -0x9a0(%rbp)
jmp 0x716d0
movq -0x9a0(%rbp), %rdi
movsd -0x260(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x9a8(%rbp)
jmp 0x716ed
movq -0x9a8(%rbp), %rdi
leaq 0x142ae(%rip), %rsi     # 0x859a9
callq 0x9530
movq %rax, -0x9b0(%rbp)
jmp 0x71709
movq -0x9b0(%rbp), %rdi
movsd -0x288(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x9b8(%rbp)
jmp 0x71726
movq -0x9b8(%rbp), %rdi
leaq 0x1427d(%rip), %rsi     # 0x859b1
callq 0x9530
movq %rax, -0x9c0(%rbp)
jmp 0x71742
movq -0x9c0(%rbp), %rdi
movsd -0x178(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x9c8(%rbp)
jmp 0x7175f
movq -0x9c8(%rbp), %rdi
leaq 0x13b4e(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x71774
jmp 0x71776
jmp 0x71778
cmpl $0x0, -0x1dc(%rbp)
jne 0x71867
movq -0x60(%rbp), %rax
movq %rax, -0x9d0(%rbp)
cmpq $0x0, %rax
je 0x717a3
movq -0x9d0(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x58(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x71865
movq 0x46830(%rip), %rdi     # 0xb7fe8
leaq 0x13f6d(%rip), %rsi     # 0x8572c
callq 0x9530
movq %rax, -0x9d8(%rbp)
jmp 0x717cd
movq -0x9d8(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x9450
movq %rax, -0x9e0(%rbp)
jmp 0x717e6
movq -0x9e0(%rbp), %rdi
leaq 0x13f41(%rip), %rsi     # 0x85735
callq 0x9530
movq %rax, -0x9e8(%rbp)
jmp 0x71802
movq -0x9e8(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x9930
movq %rax, -0x9f0(%rbp)
jmp 0x7181a
movq -0x9f0(%rbp), %rdi
leaq 0x13f30(%rip), %rsi     # 0x85758
callq 0x9530
movq %rax, -0x9f8(%rbp)
jmp 0x71836
movq -0x9f8(%rbp), %rdi
movl 0x10(%rbp), %esi
callq 0x9930
movq %rax, -0xa00(%rbp)
jmp 0x7184e
movq -0xa00(%rbp), %rdi
leaq 0x13a5f(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x71863
jmp 0x71865
jmp 0x71867
leaq -0x2b8(%rbp), %rdi
callq 0x7fd40
leaq -0x2a0(%rbp), %rdi
callq 0x7fd40
leaq -0x240(%rbp), %rdi
callq 0x5b3f0
movl -0x1d8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d8(%rbp)
jmp 0x6fcfc
leaq -0x2b8(%rbp), %rdi
callq 0x7fd40
leaq -0x2a0(%rbp), %rdi
callq 0x7fd40
leaq -0x240(%rbp), %rdi
callq 0x5b3f0
jmp 0x7238c
jmp 0x718ca
movl -0x1ac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1ac(%rbp)
movl -0x1d4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d4(%rbp)
jmp 0x6fcaf
jmp 0x718ef
leaq -0x1b8(%rbp), %rdi
callq 0x80570
movl -0x108(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x108(%rbp)
jmp 0x6fc4e
jmp 0x71911
movsd -0x38(%rbp), %xmm0
addsd -0x1a8(%rbp), %xmm0
movsd %xmm0, -0x1a8(%rbp)
movl -0x19c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x19c(%rbp)
jmp 0x6fada
movq -0x58(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x719fc
movq 0x46699(%rip), %rdi     # 0xb7fe8
leaq 0x13dd6(%rip), %rsi     # 0x8572c
callq 0x9530
movq %rax, -0xa08(%rbp)
jmp 0x71964
movq -0xa08(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x9450
movq %rax, -0xa10(%rbp)
jmp 0x7197d
movq -0xa10(%rbp), %rdi
leaq 0x13daa(%rip), %rsi     # 0x85735
callq 0x9530
movq %rax, -0xa18(%rbp)
jmp 0x71999
movq -0xa18(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x9930
movq %rax, -0xa20(%rbp)
jmp 0x719b1
movq -0xa20(%rbp), %rdi
leaq 0x13d99(%rip), %rsi     # 0x85758
callq 0x9530
movq %rax, -0xa28(%rbp)
jmp 0x719cd
movq -0xa28(%rbp), %rdi
movl 0x10(%rbp), %esi
callq 0x9930
movq %rax, -0xa30(%rbp)
jmp 0x719e5
movq -0xa30(%rbp), %rdi
leaq 0x138c8(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x719fa
jmp 0x719fc
cmpq $0x0, -0x58(%rbp)
je 0x71a23
movq -0x58(%rbp), %rax
movq %rax, -0xa38(%rbp)
cmpq $0x0, %rax
je 0x71a21
movq -0xa38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x71a23
movq $0x0, -0x58(%rbp)
xorps %xmm0, %xmm0
ucomisd -0xb0(%rbp), %xmm0
jbe 0x71a5f
movq -0x48(%rbp), %rax
movsd 0x1277c(%rip), %xmm0    # 0x841c0
movsd %xmm0, (%rax)
movq $0x0, -0x8(%rbp)
movl $0x1, -0x36c(%rbp)
jmp 0x7236a
movsd -0x98(%rbp), %xmm0
ucomisd -0x50(%rbp), %xmm0
jbe 0x71b32
movq -0x3e8(%rbp), %rax
movsd -0x98(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movsd %xmm0, (%rcx)
cmpl $0x1, 0x60(%rax)
jle 0x71b18
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x13f1b(%rip), %rsi     # 0x859c0
callq 0x9530
movq %rax, -0xa40(%rbp)
jmp 0x71ab3
movq -0xa40(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x9930
movq %rax, -0xa48(%rbp)
jmp 0x71acb
movq -0xa48(%rbp), %rdi
leaq 0x13eee(%rip), %rsi     # 0x859c7
callq 0x9530
movq %rax, -0xa50(%rbp)
jmp 0x71ae7
movq -0xa50(%rbp), %rdi
movsd -0x50(%rbp), %xmm0
callq 0x9a30
movq %rax, -0xa58(%rbp)
jmp 0x71b01
movq -0xa58(%rbp), %rdi
leaq 0x13ece(%rip), %rsi     # 0x859dd
callq 0x9530
jmp 0x71b16
jmp 0x71b18
movq -0x170(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x36c(%rbp)
jmp 0x7236a
movq -0x170(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x71b67
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0xa60(%rbp)
cmpq $0x0, %rax
je 0x71b65
movq -0xa60(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x71b67
movq -0x170(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x71b9c
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0xa68(%rbp)
cmpq $0x0, %rax
je 0x71b9a
movq -0xa68(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x71b9c
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
movsd -0xb0(%rbp), %xmm0
leaq -0xc0(%rbp), %rsi
callq 0x623c0
movq %rax, -0xa70(%rbp)
jmp 0x71bc4
movq -0xa70(%rbp), %rcx
movq -0x170(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x62930
jmp 0x71be8
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x63030
jmp 0x71bfa
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x5ed10
movsd %xmm0, -0xa78(%rbp)
jmp 0x71c14
movsd -0xa78(%rbp), %xmm1
movsd -0x40(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rsi
leaq -0x3a0(%rbp), %rdi
callq 0x80730
jmp 0x71c43
leaq -0x388(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x3a0(%rbp), %rdx
callq 0x5a8f0
jmp 0x71c5c
leaq -0x78(%rbp), %rdi
leaq -0x388(%rbp), %rsi
movq %rsi, -0xa88(%rbp)
callq 0x64270
movq -0xa88(%rbp), %rdi
callq 0x5b3f0
leaq -0x3a0(%rbp), %rdi
callq 0x5b3f0
movl $0xc0, %edi
callq 0x9550
movq %rax, -0xa80(%rbp)
jmp 0x71c9e
movq -0xa80(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x5e780
jmp 0x71cb0
movq -0xa80(%rbp), %rcx
movq -0x170(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x612f0
jmp 0x71cd4
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x615a0
movsd %xmm1, -0xa98(%rbp)
movsd %xmm0, -0xa90(%rbp)
jmp 0x71cf6
movq -0x3e8(%rbp), %rax
movsd -0xa98(%rbp), %xmm0
movsd -0xa90(%rbp), %xmm1
movsd %xmm1, -0x3b0(%rbp)
movsd %xmm0, -0x3a8(%rbp)
movsd -0x98(%rbp), %xmm0
movq -0x48(%rbp), %rcx
movsd %xmm0, (%rcx)
cmpl $0x0, 0x60(%rax)
jle 0x72355
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x13c77(%rip), %rsi     # 0x859c0
callq 0x9530
movq %rax, -0xaa0(%rbp)
jmp 0x71d57
movq -0xaa0(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0x9930
movq %rax, -0xaa8(%rbp)
jmp 0x71d6f
movq -0xaa8(%rbp), %rdi
leaq 0x13c7f(%rip), %rsi     # 0x859fc
callq 0x9530
movq %rax, -0xab0(%rbp)
jmp 0x71d8b
movq -0xab0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x80760
movq %rax, -0xab8(%rbp)
jmp 0x71da7
movq -0xab8(%rbp), %rdi
leaq 0x13c5f(%rip), %rsi     # 0x85a14
callq 0x9530
movq %rax, -0xac0(%rbp)
jmp 0x71dc3
movsd -0xb0(%rbp), %xmm0
movsd 0x123e5(%rip), %xmm1    # 0x841b8
mulsd %xmm1, %xmm0
movsd 0x10239(%rip), %xmm1    # 0x82018
divsd %xmm1, %xmm0
callq 0x9220
movq -0xac0(%rbp), %rdi
callq 0x9a30
movq %rax, -0xac8(%rbp)
jmp 0x71dfd
movq -0xac8(%rbp), %rdi
leaq 0x13c0b(%rip), %rsi     # 0x85a16
callq 0x9530
movq %rax, -0xad0(%rbp)
jmp 0x71e19
movq -0xad0(%rbp), %rdi
movl 0x10(%rbp), %esi
callq 0x9930
movq %rax, -0xad8(%rbp)
jmp 0x71e31
movq -0xad8(%rbp), %rdi
leaq 0x1277f(%rip), %rsi     # 0x845be
callq 0x9530
movq %rax, -0xae0(%rbp)
jmp 0x71e4d
movq -0xae0(%rbp), %rdi
movq -0x170(%rbp), %rsi
addq $0x90, %rsi
callq 0x9530
movq %rax, -0xae8(%rbp)
jmp 0x71e70
movq -0xae8(%rbp), %rdi
leaq 0x13ba7(%rip), %rsi     # 0x85a25
callq 0x9530
movq %rax, -0xaf0(%rbp)
jmp 0x71e8c
movq -0xaf0(%rbp), %rdi
movl -0xa0(%rbp), %esi
callq 0x9930
movq %rax, -0xaf8(%rbp)
jmp 0x71ea7
movq -0xaf8(%rbp), %rdi
leaq 0x13cfe(%rip), %rsi     # 0x85bb3
callq 0x9530
movq %rax, -0xb00(%rbp)
jmp 0x71ec3
movq -0xb00(%rbp), %rdi
movl -0x9c(%rbp), %esi
callq 0x9930
movq %rax, -0xb08(%rbp)
jmp 0x71ede
movq -0xb08(%rbp), %rdi
leaq 0x138b0(%rip), %rsi     # 0x8579c
callq 0x9530
movq %rax, -0xb10(%rbp)
jmp 0x71efa
movq -0xb10(%rbp), %rdi
movl -0xa4(%rbp), %esi
callq 0x9930
movq %rax, -0xb18(%rbp)
jmp 0x71f15
movq -0xb18(%rbp), %rdi
leaq 0x13398(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x71f2a
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x13933(%rip), %rsi     # 0x8586f
callq 0x9530
movq %rax, -0xb20(%rbp)
jmp 0x71f4a
leaq -0x78(%rbp), %rdi
callq 0x5add0
movq -0xb20(%rbp), %rdi
movq %rax, %rsi
callq 0x9150
movq %rax, -0xb28(%rbp)
jmp 0x71f6b
movq -0xb28(%rbp), %rdi
leaq 0x13907(%rip), %rsi     # 0x85880
callq 0x9530
movq %rax, -0xb30(%rbp)
jmp 0x71f87
leaq -0x78(%rbp), %rdi
callq 0x5aa10
movsd %xmm0, -0xb38(%rbp)
jmp 0x71f9a
movsd -0xb38(%rbp), %xmm0
movq -0xb30(%rbp), %rdi
callq 0x9a30
movq %rax, -0xb40(%rbp)
jmp 0x71fb7
movq -0xb40(%rbp), %rdi
leaq 0x138cc(%rip), %rsi     # 0x85891
callq 0x9530
movq %rax, -0xb48(%rbp)
jmp 0x71fd3
movq -0xb48(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
callq 0x9a30
movq %rax, -0xb50(%rbp)
jmp 0x71fed
movq -0xb50(%rbp), %rdi
leaq 0x132c0(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x72002
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x13892(%rip), %rsi     # 0x858a6
callq 0x9530
movq %rax, -0xb58(%rbp)
jmp 0x72022
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x5ed10
movsd %xmm0, -0xb60(%rbp)
jmp 0x7203c
movsd -0xb60(%rbp), %xmm0
movq -0xb58(%rbp), %rdi
callq 0x9a30
movq %rax, -0xb68(%rbp)
jmp 0x72059
movq -0xb68(%rbp), %rdi
leaq 0x139d3(%rip), %rsi     # 0x85a3a
callq 0x9530
movq %rax, -0xb70(%rbp)
jmp 0x72075
movq -0xb70(%rbp), %rdi
movq -0x48(%rbp), %rax
movsd (%rax), %xmm0
callq 0x9a30
movq %rax, -0xb78(%rbp)
jmp 0x72092
movq -0xb78(%rbp), %rdi
leaq 0x1321b(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x720a7
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x13989(%rip), %rsi     # 0x85a42
callq 0x9530
movq %rax, -0xb80(%rbp)
jmp 0x720c7
movq -0x3f8(%rbp), %rdi
callq 0x7ffb0
movq -0xb80(%rbp), %rdi
movq %rax, %rsi
callq 0x9150
movq %rax, -0xb88(%rbp)
jmp 0x720eb
movq -0xb88(%rbp), %rdi
leaq 0x131c2(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x72100
movq -0x3f8(%rbp), %rdi
movl $0x1, -0x3b4(%rbp)
callq 0x803f0
movq %rax, -0x3c0(%rbp)
movq -0x3f8(%rbp), %rdi
callq 0x80450
movq %rax, -0x3c8(%rbp)
leaq -0x3c0(%rbp), %rdi
leaq -0x3c8(%rbp), %rsi
callq 0x80420
testb $0x1, %al
jne 0x7214c
jmp 0x72353
leaq -0x3c0(%rbp), %rdi
callq 0x80480
movq -0x3e8(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x3d0(%rbp)
addq $0x68, %rdi
leaq 0x138e2(%rip), %rsi     # 0x85a56
callq 0x9530
movq %rax, -0xb90(%rbp)
jmp 0x72182
movq -0xb90(%rbp), %rdi
movl -0x3b4(%rbp), %esi
callq 0x9930
movq %rax, -0xb98(%rbp)
jmp 0x7219d
movq -0xb98(%rbp), %rdi
leaq 0x138b5(%rip), %rsi     # 0x85a60
callq 0x9530
movq %rax, -0xba0(%rbp)
jmp 0x721b9
movq -0x3d0(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x7fd80
movsd %xmm1, -0xbb0(%rbp)
movsd %xmm0, -0xba8(%rbp)
jmp 0x721db
movq -0xba0(%rbp), %rdi
movsd -0xbb0(%rbp), %xmm0
movsd -0xba8(%rbp), %xmm1
movsd %xmm1, -0x3e0(%rbp)
movsd %xmm0, -0x3d8(%rbp)
leaq -0x3e0(%rbp), %rsi
callq 0x80760
movq %rax, -0xbb8(%rbp)
jmp 0x72217
movq -0xbb8(%rbp), %rdi
leaq 0x1384a(%rip), %rsi     # 0x85a6f
callq 0x9530
movq %rax, -0xbc0(%rbp)
jmp 0x72233
movq -0x3d0(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x7fd60
movsd %xmm0, -0xbc8(%rbp)
jmp 0x7224d
movsd -0xbc8(%rbp), %xmm0
movsd 0x11f5b(%rip), %xmm1    # 0x841b8
mulsd %xmm1, %xmm0
movsd 0xfdaf(%rip), %xmm1     # 0x82018
divsd %xmm1, %xmm0
callq 0x9220
movq -0xbc0(%rbp), %rdi
callq 0x9a30
jmp 0x72280
movq -0x3e8(%rbp), %rdi
addq $0x68, %rdi
leaq 0x137e3(%rip), %rsi     # 0x85a75
callq 0x9530
movq %rax, -0xbd0(%rbp)
jmp 0x722a0
movq -0x3d0(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x5ed10
movsd %xmm0, -0xbd8(%rbp)
jmp 0x722ba
movsd -0xbd8(%rbp), %xmm0
movq -0xbd0(%rbp), %rdi
callq 0x9a30
movq %rax, -0xbe0(%rbp)
jmp 0x722d7
movq -0xbe0(%rbp), %rdi
leaq 0x12fd6(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x722ec
jmp 0x722ee
leaq -0x3c0(%rbp), %rdi
callq 0x80570
movl -0x3b4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3b4(%rbp)
jmp 0x7211d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x3a0(%rbp), %rdi
callq 0x5b3f0
jmp 0x7238c
movq -0xa80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
movl $0xc0, %esi
callq 0x9560
jmp 0x7238c
jmp 0x72355
movq -0x170(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x36c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x5b3f0
leaq -0x78(%rbp), %rdi
callq 0x5b3f0
movq -0x8(%rbp), %rax
addq $0xc00, %rsp            # imm = 0xC00
popq %rbp
retq
leaq -0x90(%rbp), %rdi
callq 0x5b3f0
leaq -0x78(%rbp), %rdi
callq 0x5b3f0
movq -0xc8(%rbp), %rdi
callq 0x9960
nopl (%rax)