// File: thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: SvgDoc::OptimizeLevelFreeRot(Polygon*, std::__cxx11::list<NSVGpath*, std::allocator<NSVGpath*>>, std::__cxx11::list<NSVGpath*, std::allocator<NSVGpath*>>, double, double&, double, int, int, int)
NSVGpath *SvgDoc::OptimizeLevelFreeRot(Polygon *FixedPolyHull, std::list<NSVGpath *> FixedList, std::list<NSVGpath *> CurFloating, 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 << " 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 = -500;            //   Impossible value
    if ( debug_level > 1 )
    {
        OutDebug << "Polygon to be placed : " << WorkingFloatingEntry->id << "  has " << WorkingFloatingEntry->LargePolygon->nVertices << " vertices.\n";
    }
    double tmpPolygonArea = FixedArea + WorkingFloatingEntry->LargePolygon->area();
    int nPreviousVertices = getFixedNbVertex(FixedList);            //  Number of vertices of all polygons before this one
    //  Build a cache object which will speed up computation if not yet present
    if ( UseCache && WorkingFloatingEntry->CachePoly == NULL )
    {
        //  Use 4 for num_rot because 4 possibilities will be tested, even if 2 at most are possible.
        WorkingFloatingEntry->CachePoly = new CachePosition(WorkingFloatingEntry->LargePolygon->nVertices, 4, nPreviousVertices);
    }
    //  Precomputing of segments and angle to save time
    WorkingFloatingEntry->LargePolygon->ComputeAngles();     //  Compute angles to be more efficient later
    WorkingFloatingEntry->LargePolygon->CalcSegments();

    //  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;
        if ( debug_level > 2 )
        {
            OutDebug << "\n\n-------    Trying matching polygon " << FloatPolygon << " with Polygon " << FixedPolygon << "\n";
        }
        // For each vertex of this placed polygon
        for ( int iVFixed = 0; iVFixed < curFixed->nVertices-1; iFixedVertex++, iVFixed++)
        {
            double angle = 0;
            if ( debug_level > 2 )
            {
                OutDebug << "\nTrying on vertex " << iVFixed << " of fixed polygon\n";
            }
            //  Try all vertices of the floating polygon, and select the best
            for (int iVFloat = 0; iVFloat < WorkingFloatingEntry->LargePolygon->nVertices-1; iVFloat++)
            {
                if ( debug_level > 3 )
                {
                    OutDebug << "\nTrying with vertex " << iVFloat << " on vertex " << iVFixed << "\n";
                }
                //  For each case, try 4 angles. Angles are computed such as edge of flaot polygon are aligned to edge of fixed polygon with matching vertex.
                //  As there is 2 edges for each vertex, there are 4 possible angles, even if at most 2 will be possible
                for ( int iRot = 0; iRot < 4; iRot++)
                {
                    //  Use cache if available

                    trans_rot_p = NULL;
                    int Cached = 0;
                    if ( UseCache && path->isFixed )
                        WorkingFloatingEntry->CachePoly->isOKPlacedFreeRot(iVFloat, iRot, iFixedVertex, &trans_rot_p);
                    if ( Cached < 0 )       //  Cache says impossible !
                    {
                        CacheHit_KO++;
                        if ( debug_level > 2 )
                            OutDebug << "Cache says placement polygon " << FloatPolygon << " vertex " << iVFloat << " on vertex " << iVFixed << " of Polygon " << FixedPolygon << "(" << iFixedVertex << ")" << "impossible " << *curFixed->GetVertex(iVFixed) << "\n";
                        continue;           //  Goto next vertex...
                    }
                    else if ( Cached == 0 )
                    {
                        CacheMiss++;        // Not yet in cache, check angles first
                        nbCheckAngles++;
                        angle = 0;
                        //  Compute angle associated with floating polygon vertex j placed on vertex i of fixed polygon curFixed polygon (index i_rot)
                        //  If not possible, invalidate cache
                        int Res = ComputeFreeRotAngle(WorkingFloatingEntry->LargePolygon, iVFloat, curFixed, iVFixed, iRot, angle);
                        if ( debug_level > 3 )
                        {
                            OutDebug << "iRot =" << iRot << " angle=" << round(angle * 180 / M_PI);
                            OutDebug << "  ComputeFreeRotAngle: Res=" << Res << "\n";
                        }
                        if ( Res == 0)
                        {
                            //  Impossible, invalid cache entry
                            if ( UseCache && path->isFixed )
                                WorkingFloatingEntry->CachePoly->addOKPlacedFreeRot(iVFloat, iRot, iFixedVertex, NULL);
                            if ( debug_level > 2 )
                                OutDebug << "ComputeFreeRotAngle: Placement polygon " << FloatPolygon << " vertex " << iVFloat << " with rotation " << angle << "(" << iRot << ")" << " on vertex " << iVFixed << " of Polygon " << FixedPolygon << " impossible " << *curFixed->GetVertex(iVFixed) << ", reason angle mismatch\n";
                            continue;    //  Not possible goto next without further processing
                        }
                        //  Compute polygon translated and rotated...
                        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();
                        trans_rot_p = rot_p->Translate(curFixed->GetVertex(iVFixed), iVFloat);
                        nbTranslation++;
                        trans_rot_p->CalcSegments();
                    }
                    else
                    {
                        CacheHit_OK++;
                        angle = trans_rot_p->getRotation();
                    }

                    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 " << iVFloat << " on vertex " << iVFixed << " of Polygon " << FixedPolygon << " impossible " << *curFixed->GetVertex(iVFixed) << ", 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->addOKPlacedFreeRot(iVFloat, iRot, iFixedVertex, NULL);
                            delete trans_rot_p;
                            trans_rot_p = NULL;
                        }
                        //  Free memory associated with polygon
                        if ( Cached == 0 && trans_rot_p != NULL )
                        {
                            delete trans_rot_p;
                            trans_rot_p = NULL;
                        }

                        nbPlacementImpossible++;
                        continue;
                    }
                    if ( path->isFixed && Cached == 0)        //  If current vertex belongs to a fixed path, cache value
                    {
                        if ( UseCache )
                        {
                            WorkingFloatingEntry->CachePoly->addOKPlacedFreeRot(iVFloat, iRot, iFixedVertex, trans_rot_p);
                            Cached = 1;
                        }
                    }
                    //  Compute cost function
                    //  We will use only the Hull area.
                    //  As the Hull 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);
                    if ( debug_level > 1)
                        OutDebug << "  Vertex " << iVFloat << " on " << iVFixed << " of polygon " << FixedPolygon << " Hull area " << tmpHullArea << "--> DiffArea=" << tmpHullArea - 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() && tmpHullArea >= InBestCost )
                    {
                        OutDebug << " TmpHullarea (" << tmpHullArea << ") larger than input best values (" << InBestCost << ") no need to process other polygons in list\n";
                    }
                    if ( debug_level > 1 && !tmpFloatList.empty() && tmpHullArea >= BestCost )
                    {
                        OutDebug << " TmpHullarea (" << tmpHullArea << ") larger than current best values (" << BestCost << ") no need to process other polygons in list\n";
                    }
                    if ( !tmpFloatList.empty() && (tmpHullArea <= InBestCost && tmpHullArea <= BestCost) ) //  No need to go deeper, if nothing in list or cost already too high
                    {
                        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 = OptimizeLevelFreeRot(WorkingFloatingEntry->LargeConvexHull, tmpFixedList, tmpFloatList, tmpFixedArea, tmpHullArea, BestCost, FloatPolygon+1, nbFixedPoly, LevelOptimize - 1);
                        if ( Res == NULL )
                        {
                            //  Not possible, make sure that tmpHullArea will be greater than BestCost
                            tmpHullArea = BestCost + 10;
                        }
                        //  After return, the tmpHullArea is updated
                        if ( debug_level > 1 )
                        {
                            OutDebug << "-----   Returning at level " << LevelOptimize << ",  Cost is " << tmpHullArea << "\n";
                        }
                    }
                    if ( tmpHullArea < BestCost  )
                    {   //  Yes record new best value and corresponding position
                        BestCost = tmpHullArea;
                        BestAngle = angle;
                        BestTranslation = trans_rot_p->getTranslation();
                        Best_i = iVFixed;
                        Best_j = iVFloat;
                        Best_Poly = FixedPolygon;
                        if ( debug_level > 1 )
                        {
                            OutDebug << "New best found placing polygon " << FloatPolygon << "\n";
                            OutDebug << "  Vertex " << iVFloat << " on vertex " << iVFixed << " of polygon " <<  FixedPolygon << "\n";
                            OutDebug << " Rotation=" << round(angle*180/M_PI) << " Translation " << BestTranslation << " from " << *(rot_p->GetVertex(iVFloat)) << " to " <<  *(curFixed->GetVertex(iVFixed)) << "\n";
                            OutDebug << "  Hull area:" << tmpHullArea << " 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 != NULL ) delete rot_p;
    rot_p = NULL;
    //  Place polygon at BestAngle and Best Translation
    if ( BestAngle < -100 )
    {
        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 << " 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;
            if ( lPath->PlacedPolygon == NULL )
            {
                OutDebug << "Element " << idx_list << "Not placed\n";
            }
            else
            {
                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 $0xb10, %rsp            # imm = 0xB10
movq %rcx, -0x3d0(%rbp)
movq %rdx, -0x3c8(%rbp)
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movsd %xmm1, -0x40(%rbp)
movl %r9d, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x3c0(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5aee0
leaq -0x88(%rbp), %rdi
callq 0x5aee0
movabsq $0x54b249ad2594c37d, %rax # imm = 0x54B249AD2594C37D
movq %rax, -0x90(%rbp)
movl $0xffffffff, -0x94(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x98(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x9c(%rbp) # imm = 0xFFFFFFFF
leaq -0xb8(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x74354
leaq -0xe0(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x74368
leaq -0x100(%rbp), %rdi
callq 0x5b4e0
jmp 0x74376
movl $0x0, -0x108(%rbp)
leaq -0x120(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
jmp 0x74394
movq -0x3c0(%rbp), %rax
cmpl $0x1, 0x60(%rax)
jle 0x74560
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x1123a(%rip), %rsi     # 0x855f1
callq 0x9530
movq %rax, -0x3d8(%rbp)
jmp 0x743c5
movq -0x3d8(%rbp), %rdi
movl 0x18(%rbp), %esi
callq 0x9930
movq %rax, -0x3e0(%rbp)
jmp 0x743dd
movq -0x3e0(%rbp), %rdi
leaq 0x1121e(%rip), %rsi     # 0x85609
callq 0x9530
movq %rax, -0x3e8(%rbp)
jmp 0x743f9
movq -0x18(%rbp), %rdi
callq 0x5ed10
movsd %xmm0, -0x3f0(%rbp)
jmp 0x7440c
movsd -0x3f0(%rbp), %xmm0
movq -0x3e8(%rbp), %rdi
callq 0x9a30
movq %rax, -0x3f8(%rbp)
jmp 0x74429
movq -0x3f8(%rbp), %rdi
leaq 0x111e4(%rip), %rsi     # 0x8561b
callq 0x9530
movq %rax, -0x400(%rbp)
jmp 0x74445
movq -0x400(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x9a30
jmp 0x74458
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x111ca(%rip), %rsi     # 0x85634
callq 0x9530
movq %rax, -0x408(%rbp)
jmp 0x74478
movq -0x408(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x410(%rbp)
jmp 0x74492
movq -0x410(%rbp), %rdi
leaq 0x10e1b(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x744a7
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x11188(%rip), %rsi     # 0x85641
callq 0x9530
movq %rax, -0x418(%rbp)
jmp 0x744c7
movq -0x3d0(%rbp), %rdi
callq 0x7ffb0
movq -0x418(%rbp), %rdi
movq %rax, %rsi
callq 0x9150
movq %rax, -0x420(%rbp)
jmp 0x744eb
movq -0x420(%rbp), %rdi
leaq 0x1115a(%rip), %rsi     # 0x85653
callq 0x9530
movq %rax, -0x428(%rbp)
jmp 0x74507
movq -0x3d0(%rbp), %rdi
callq 0x80680
movq -0x428(%rbp), %rdi
movq (%rax), %rsi
addq $0x90, %rsi
callq 0x9530
movq %rax, -0x430(%rbp)
jmp 0x74532
movq -0x430(%rbp), %rdi
leaq 0x10d7b(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x74547
jmp 0x74560
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x76fa8
movq -0x18(%rbp), %rsi
leaq -0x138(%rbp), %rdi
callq 0x80730
jmp 0x74572
leaq -0x70(%rbp), %rdi
leaq -0x138(%rbp), %rsi
movq %rsi, -0x448(%rbp)
callq 0x64270
movq -0x448(%rbp), %rdi
callq 0x5b3f0
movq -0x18(%rbp), %rdi
callq 0x615a0
movsd %xmm1, -0x440(%rbp)
movsd %xmm0, -0x438(%rbp)
jmp 0x745b0
movsd -0x440(%rbp), %xmm0
movsd -0x438(%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 0x745f0
movq -0x3d0(%rbp), %rdi
movq -0x168(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x160(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x158(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x150(%rbp), %rax
movq %rax, -0xe8(%rbp)
callq 0x80680
movq -0x3d0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x170(%rbp)
callq 0x806b0
movq -0x3c0(%rbp), %rax
movsd 0xfb57(%rip), %xmm0     # 0x841b0
movsd %xmm0, -0x90(%rbp)
movsd 0xfb6f(%rip), %xmm0     # 0x841d8
movsd %xmm0, -0xa8(%rbp)
cmpl $0x1, 0x60(%rax)
jle 0x74714
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x10fd1(%rip), %rsi     # 0x8565e
callq 0x9530
movq %rax, -0x450(%rbp)
jmp 0x7469b
movq -0x450(%rbp), %rdi
movq -0x170(%rbp), %rsi
addq $0x90, %rsi
callq 0x9530
movq %rax, -0x458(%rbp)
jmp 0x746be
movq -0x458(%rbp), %rdi
leaq 0x10faa(%rip), %rsi     # 0x85676
callq 0x9530
movq %rax, -0x460(%rbp)
jmp 0x746da
movq -0x460(%rbp), %rdi
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rax
movl 0x8(%rax), %esi
callq 0x9930
movq %rax, -0x468(%rbp)
jmp 0x746fd
movq -0x468(%rbp), %rdi
leaq 0x10f72(%rip), %rsi     # 0x8567d
callq 0x9530
jmp 0x74712
jmp 0x74714
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x478(%rbp)
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x5ed10
movsd %xmm0, -0x470(%rbp)
jmp 0x7473b
movq -0x3c8(%rbp), %rsi
movsd -0x470(%rbp), %xmm1
movsd -0x478(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x178(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x805c0
jmp 0x7476c
movq -0x3c0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x723b0
movl %eax, -0x47c(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x7fd40
movl -0x47c(%rbp), %ecx
movq -0x3c0(%rbp), %rax
movl %ecx, -0x17c(%rbp)
cmpl $0x0, 0x64(%rax)
je 0x74838
movq -0x170(%rbp), %rax
cmpq $0x0, 0x88(%rax)
jne 0x74838
movl $0x38, %edi
callq 0x9550
movq %rax, -0x488(%rbp)
jmp 0x747d2
movq -0x488(%rbp), %rdi
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rax
movl 0x8(%rax), %esi
movl -0x17c(%rbp), %ecx
movl $0x4, %edx
callq 0x59e70
jmp 0x747f9
movq -0x488(%rbp), %rcx
movq -0x170(%rbp), %rax
movq %rcx, 0x88(%rax)
jmp 0x74838
movq -0x488(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
movl $0x38, %esi
callq 0x9560
jmp 0x76fa8
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x62930
jmp 0x7484a
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x63030
jmp 0x7485c
movq -0x3c8(%rbp), %rdi
movl $0x0, -0x108(%rbp)
movl $0x0, -0x19c(%rbp)
callq 0x803f0
movq %rax, -0x1a8(%rbp)
movq -0x3c8(%rbp), %rdi
callq 0x80450
movq %rax, -0x1b0(%rbp)
leaq -0x1a8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x80420
testb $0x1, %al
jne 0x748b2
jmp 0x765e3
leaq -0x1a8(%rbp), %rdi
callq 0x80480
movq %rax, %rcx
movq -0x3c0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x1b8(%rbp)
movq -0x1b8(%rbp), %rcx
movq 0x78(%rcx), %rcx
movq %rcx, -0x1c0(%rbp)
cmpl $0x2, 0x60(%rax)
jle 0x74974
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x11277(%rip), %rsi     # 0x85b77
callq 0x9530
movq %rax, -0x490(%rbp)
jmp 0x7490e
movq -0x490(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x9930
movq %rax, -0x498(%rbp)
jmp 0x74926
movq -0x498(%rbp), %rdi
leaq 0x11269(%rip), %rsi     # 0x85b9d
callq 0x9530
movq %rax, -0x4a0(%rbp)
jmp 0x74942
movq -0x4a0(%rbp), %rdi
movl -0x108(%rbp), %esi
callq 0x9930
movq %rax, -0x4a8(%rbp)
jmp 0x7495d
movq -0x4a8(%rbp), %rdi
leaq 0x10950(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x74972
jmp 0x74974
movl $0x0, -0x1c4(%rbp)
movl -0x1c4(%rbp), %eax
movq -0x1c0(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x765c1
movq -0x3c0(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, -0x1d0(%rbp)
cmpl $0x2, 0x60(%rax)
jle 0x74a03
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x111e9(%rip), %rsi     # 0x85bac
callq 0x9530
movq %rax, -0x4b0(%rbp)
jmp 0x749d1
movq -0x4b0(%rbp), %rdi
movl -0x1c4(%rbp), %esi
callq 0x9930
movq %rax, -0x4b8(%rbp)
jmp 0x749ec
movq -0x4b8(%rbp), %rdi
leaq 0x111c5(%rip), %rsi     # 0x85bbf
callq 0x9530
jmp 0x74a01
jmp 0x74a03
movl $0x0, -0x1d4(%rbp)
movl -0x1d4(%rbp), %eax
movq -0x170(%rbp), %rcx
movq 0x68(%rcx), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x7659c
movq -0x3c0(%rbp), %rax
cmpl $0x3, 0x60(%rax)
jle 0x74ac6
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x11183(%rip), %rsi     # 0x85bd2
callq 0x9530
movq %rax, -0x4c0(%rbp)
jmp 0x74a5d
movq -0x4c0(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x9930
movq %rax, -0x4c8(%rbp)
jmp 0x74a78
movq -0x4c8(%rbp), %rdi
leaq 0x1112d(%rip), %rsi     # 0x85bb3
callq 0x9530
movq %rax, -0x4d0(%rbp)
jmp 0x74a94
movq -0x4d0(%rbp), %rdi
movl -0x1c4(%rbp), %esi
callq 0x9930
movq %rax, -0x4d8(%rbp)
jmp 0x74aaf
movq -0x4d8(%rbp), %rdi
leaq 0x107fe(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x74ac4
jmp 0x74ac6
movl $0x0, -0x1d8(%rbp)
cmpl $0x4, -0x1d8(%rbp)
jge 0x76586
movq -0x3c0(%rbp), %rax
movq $0x0, -0x58(%rbp)
movl $0x0, -0x1dc(%rbp)
cmpl $0x0, 0x64(%rax)
je 0x74b39
movq -0x1b8(%rbp), %rax
cmpl $0x0, 0x80(%rax)
je 0x74b39
movq -0x170(%rbp), %rax
movq 0x88(%rax), %rdi
movl -0x1d4(%rbp), %esi
movl -0x1d8(%rbp), %edx
movl -0x19c(%rbp), %ecx
leaq -0x58(%rbp), %r8
callq 0x5a250
jmp 0x74b37
jmp 0x74b39
cmpl $0x0, -0x1dc(%rbp)
jge 0x74d08
movq -0x3c0(%rbp), %rax
movq 0x2b0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x2b0(%rax)
cmpl $0x2, 0x60(%rax)
jle 0x74d03
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x10b86(%rip), %rsi     # 0x85701
callq 0x9530
movq %rax, -0x4e0(%rbp)
jmp 0x74b89
movq -0x4e0(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x9930
movq %rax, -0x4e8(%rbp)
jmp 0x74ba1
movq -0x4e8(%rbp), %rdi
leaq 0x10e82(%rip), %rsi     # 0x85a31
callq 0x9530
movq %rax, -0x4f0(%rbp)
jmp 0x74bbd
movq -0x4f0(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x9930
movq %rax, -0x4f8(%rbp)
jmp 0x74bd8
movq -0x4f8(%rbp), %rdi
leaq 0x10fcd(%rip), %rsi     # 0x85bb3
callq 0x9530
movq %rax, -0x500(%rbp)
jmp 0x74bf4
movq -0x500(%rbp), %rdi
movl -0x1c4(%rbp), %esi
callq 0x9930
movq %rax, -0x508(%rbp)
jmp 0x74c0f
movq -0x508(%rbp), %rdi
leaq 0x10b02(%rip), %rsi     # 0x8571f
callq 0x9530
movq %rax, -0x510(%rbp)
jmp 0x74c2b
movq -0x510(%rbp), %rdi
movl -0x108(%rbp), %esi
callq 0x9930
movq %rax, -0x518(%rbp)
jmp 0x74c46
movq -0x518(%rbp), %rdi
leaq 0xf96a(%rip), %rsi      # 0x845be
callq 0x9530
movq %rax, -0x520(%rbp)
jmp 0x74c62
movq -0x520(%rbp), %rdi
movl -0x19c(%rbp), %esi
callq 0x9930
movq %rax, -0x528(%rbp)
jmp 0x74c7d
movq -0x528(%rbp), %rdi
leaq 0xe4d9(%rip), %rsi      # 0x83164
callq 0x9530
movq %rax, -0x530(%rbp)
jmp 0x74c99
movq -0x530(%rbp), %rdi
leaq 0x10ac1(%rip), %rsi     # 0x85768
callq 0x9530
movq %rax, -0x538(%rbp)
jmp 0x74cb5
movq -0x1c0(%rbp), %rdi
movl -0x1c4(%rbp), %esi
callq 0x7ff40
movq %rax, -0x540(%rbp)
jmp 0x74cd0
movq -0x540(%rbp), %rsi
movq -0x538(%rbp), %rdi
callq 0x80760
movq %rax, -0x548(%rbp)
jmp 0x74cec
movq -0x548(%rbp), %rdi
leaq 0x105c1(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x74d01
jmp 0x74d03
jmp 0x76549
cmpl $0x0, -0x1dc(%rbp)
jne 0x751bb
movq -0x3c0(%rbp), %rax
movq 0x2a0(%rax), %rcx
incq %rcx
movq %rcx, 0x2a0(%rax)
movq 0x280(%rax), %rcx
incq %rcx
movq %rcx, 0x280(%rax)
movq $0x0, -0x1d0(%rbp)
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
movl -0x1d4(%rbp), %esi
movq -0x1c0(%rbp), %rdx
movl -0x1c4(%rbp), %ecx
movl -0x1d8(%rbp), %r8d
leaq -0x1d0(%rbp), %r9
callq 0x6dc40
movb %al, -0x549(%rbp)
jmp 0x74d82
movq -0x3c0(%rbp), %rax
movb -0x549(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x1e0(%rbp)
cmpl $0x3, 0x60(%rax)
jle 0x74e81
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x10e30(%rip), %rsi     # 0x85be7
callq 0x9530
movq %rax, -0x558(%rbp)
jmp 0x74dc5
movq -0x558(%rbp), %rdi
movl -0x1d8(%rbp), %esi
callq 0x9930
movq %rax, -0x560(%rbp)
jmp 0x74de0
movq -0x560(%rbp), %rdi
leaq 0x10e00(%rip), %rsi     # 0x85bee
callq 0x9530
movq %rax, -0x568(%rbp)
jmp 0x74dfc
movsd -0x1d0(%rbp), %xmm0
movsd 0xf3ac(%rip), %xmm1     # 0x841b8
mulsd %xmm1, %xmm0
movsd 0xd200(%rip), %xmm1     # 0x82018
divsd %xmm1, %xmm0
callq 0x9220
movq -0x568(%rbp), %rdi
callq 0x9a30
jmp 0x74e2f
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x10db5(%rip), %rsi     # 0x85bf6
callq 0x9530
movq %rax, -0x570(%rbp)
jmp 0x74e4f
movq -0x570(%rbp), %rdi
movl -0x1e0(%rbp), %esi
callq 0x9930
movq %rax, -0x578(%rbp)
jmp 0x74e6a
movq -0x578(%rbp), %rdi
leaq 0x10443(%rip), %rsi     # 0x852bb
callq 0x9530
jmp 0x74e7f
jmp 0x74e81
cmpl $0x0, -0x1e0(%rbp)
jne 0x750c2
movq -0x3c0(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x74ed9
movq -0x1b8(%rbp), %rax
cmpl $0x0, 0x80(%rax)
je 0x74ed9
movq -0x170(%rbp), %rax
movq 0x88(%rax), %rdi
movl -0x1d4(%rbp), %esi
movl -0x1d8(%rbp), %edx
movl -0x19c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x5a2e0
jmp 0x74ed7
jmp 0x74ed9
movq -0x3c0(%rbp), %rax
cmpl $0x2, 0x60(%rax)
jle 0x750bd
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x10d16(%rip), %rsi     # 0x85c12
callq 0x9530
movq %rax, -0x580(%rbp)
jmp 0x74f0a
movq -0x580(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x9930
movq %rax, -0x588(%rbp)
jmp 0x74f22
movq -0x588(%rbp), %rdi
leaq 0x10b01(%rip), %rsi     # 0x85a31
callq 0x9530
movq %rax, -0x590(%rbp)
jmp 0x74f3e
movq -0x590(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x9930
movq %rax, -0x598(%rbp)
jmp 0x74f59
movq -0x598(%rbp), %rdi
leaq 0x10b46(%rip), %rsi     # 0x85aad
callq 0x9530
movq %rax, -0x5a0(%rbp)
jmp 0x74f75
movq -0x5a0(%rbp), %rdi
movsd -0x1d0(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x5a8(%rbp)
jmp 0x74f92
movq -0x5a8(%rbp), %rdi
leaq 0xf61e(%rip), %rsi      # 0x845be
callq 0x9530
movq %rax, -0x5b0(%rbp)
jmp 0x74fae
movq -0x5b0(%rbp), %rdi
movl -0x1d8(%rbp), %esi
callq 0x9930
movq %rax, -0x5b8(%rbp)
jmp 0x74fc9
movq -0x5b8(%rbp), %rdi
leaq 0xe18d(%rip), %rsi      # 0x83164
callq 0x9530
movq %rax, -0x5c0(%rbp)
jmp 0x74fe5
movq -0x5c0(%rbp), %rdi
leaq 0x10bc0(%rip), %rsi     # 0x85bb3
callq 0x9530
movq %rax, -0x5c8(%rbp)
jmp 0x75001
movq -0x5c8(%rbp), %rdi
movl -0x1c4(%rbp), %esi
callq 0x9930
movq %rax, -0x5d0(%rbp)
jmp 0x7501c
movq -0x5d0(%rbp), %rdi
leaq 0x106f5(%rip), %rsi     # 0x8571f
callq 0x9530
movq %rax, -0x5d8(%rbp)
jmp 0x75038
movq -0x5d8(%rbp), %rdi
movl -0x108(%rbp), %esi
callq 0x9930
movq %rax, -0x5e0(%rbp)
jmp 0x75053
movq -0x5e0(%rbp), %rdi
leaq 0x10706(%rip), %rsi     # 0x85767
callq 0x9530
movq %rax, -0x5e8(%rbp)
jmp 0x7506f
movq -0x1c0(%rbp), %rdi
movl -0x1c4(%rbp), %esi
callq 0x7ff40
movq %rax, -0x5f0(%rbp)
jmp 0x7508a
movq -0x5f0(%rbp), %rsi
movq -0x5e8(%rbp), %rdi
callq 0x80760
movq %rax, -0x5f8(%rbp)
jmp 0x750a6
movq -0x5f8(%rbp), %rdi
leaq 0x106c0(%rip), %rsi     # 0x85774
callq 0x9530
jmp 0x750bb
jmp 0x750bd
jmp 0x76549
cmpq $0x0, -0x50(%rbp)
je 0x750e9
movq -0x50(%rbp), %rax
movq %rax, -0x600(%rbp)
cmpq $0x0, %rax
je 0x750e7
movq -0x600(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x750e9
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
movsd -0x1d0(%rbp), %xmm0
callq 0x61ed0
movq %rax, -0x608(%rbp)
jmp 0x7510a
movq -0x3c0(%rbp), %rax
movq -0x608(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq 0x278(%rax), %rcx
incq %rcx
movq %rcx, 0x278(%rax)
movq -0x50(%rbp), %rdi
callq 0x62930
jmp 0x75138
movq -0x50(%rbp), %rdi
callq 0x63030
jmp 0x75143
movq -0x50(%rbp), %rax
movq %rax, -0x618(%rbp)
movq -0x1c0(%rbp), %rdi
movl -0x1c4(%rbp), %esi
callq 0x7ff40
movq %rax, -0x610(%rbp)
jmp 0x75169
movq -0x610(%rbp), %rsi
movq -0x618(%rbp), %rdi
movl -0x1d4(%rbp), %edx
callq 0x61b20
movq %rax, -0x620(%rbp)
jmp 0x7518b
movq -0x3c0(%rbp), %rax
movq -0x620(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq 0x270(%rax), %rcx
incq %rcx
movq %rcx, 0x270(%rax)
movq -0x58(%rbp), %rdi
callq 0x63030
jmp 0x751b9
jmp 0x751f6
movq -0x3c0(%rbp), %rax
movq 0x2a8(%rax), %rcx
incq %rcx
movq %rcx, 0x2a8(%rax)
movq -0x58(%rbp), %rdi
callq 0x7fd60
movsd %xmm0, -0x628(%rbp)
jmp 0x751e6
movsd -0x628(%rbp), %xmm0
movsd %xmm0, -0x1d0(%rbp)
jmp 0x751f8
movq -0x170(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
leaq -0x1f0(%rbp), %rdi
callq 0x5b520
jmp 0x75216
movups -0x1f0(%rbp), %xmm0
movaps %xmm0, -0x120(%rbp)
movsd -0x1d0(%rbp), %xmm0
movsd %xmm0, -0x640(%rbp)
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x615a0
movsd %xmm1, -0x638(%rbp)
movsd %xmm0, -0x630(%rbp)
jmp 0x75256
movsd -0x638(%rbp), %xmm0
movsd -0x630(%rbp), %xmm1
movsd %xmm1, -0x200(%rbp)
movsd %xmm0, -0x1f8(%rbp)
movq -0x58(%rbp), %rdi
callq 0x7fd80
movsd %xmm1, -0x650(%rbp)
movsd %xmm0, -0x648(%rbp)
jmp 0x75291
movsd -0x640(%rbp), %xmm0
movsd -0x650(%rbp), %xmm1
movsd -0x648(%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 0x752e7
movq -0x3c8(%rbp), %rsi
movq -0x58(%rbp), %rax
movq %rax, -0x658(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x805c0
jmp 0x75307
movq -0x658(%rbp), %rsi
movq -0x3c0(%rbp), %rdi
movl -0x1dc(%rbp), %r9d
leaq -0x228(%rbp), %rdx
leaq -0x100(%rbp), %rcx
leaq -0x120(%rbp), %r8
callq 0x72690
movl %eax, -0x65c(%rbp)
jmp 0x7533e
movl -0x65c(%rbp), %eax
movl %eax, -0x104(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x7fd40
movl -0x65c(%rbp), %eax
cmpl $0x0, %eax
je 0x755ea
movq -0x3c0(%rbp), %rax
cmpl $0x2, 0x60(%rax)
jle 0x75517
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x1089f(%rip), %rsi     # 0x85c27
callq 0x9530
movq %rax, -0x668(%rbp)
jmp 0x75396
movq -0x668(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x9930
movq %rax, -0x670(%rbp)
jmp 0x753ae
movq -0x670(%rbp), %rdi
leaq 0x10675(%rip), %rsi     # 0x85a31
callq 0x9530
movq %rax, -0x678(%rbp)
jmp 0x753ca
movq -0x678(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x9930
movq %rax, -0x680(%rbp)
jmp 0x753e5
movq -0x680(%rbp), %rdi
leaq 0x107c0(%rip), %rsi     # 0x85bb3
callq 0x9530
movq %rax, -0x688(%rbp)
jmp 0x75401
movq -0x688(%rbp), %rdi
movl -0x1c4(%rbp), %esi
callq 0x9930
movq %rax, -0x690(%rbp)
jmp 0x7541c
movq -0x690(%rbp), %rdi
leaq 0x102f5(%rip), %rsi     # 0x8571f
callq 0x9530
movq %rax, -0x698(%rbp)
jmp 0x75438
movq -0x698(%rbp), %rdi
movl -0x108(%rbp), %esi
callq 0x9930
movq %rax, -0x6a0(%rbp)
jmp 0x75453
movq -0x6a0(%rbp), %rdi
leaq 0x10306(%rip), %rsi     # 0x85767
callq 0x9530
movq %rax, -0x6a8(%rbp)
jmp 0x7546f
movq -0x1c0(%rbp), %rdi
movl -0x1c4(%rbp), %esi
callq 0x7ff40
movq %rax, -0x6b0(%rbp)
jmp 0x7548a
movq -0x6b0(%rbp), %rsi
movq -0x6a8(%rbp), %rdi
callq 0x80760
movq %rax, -0x6b8(%rbp)
jmp 0x754a6
movq -0x6b8(%rbp), %rdi
leaq 0x102d9(%rip), %rsi     # 0x8578d
callq 0x9530
movq %rax, -0x6c0(%rbp)
jmp 0x754c2
movq -0x6c0(%rbp), %rdi
movl -0x104(%rbp), %esi
callq 0x9930
movq %rax, -0x6c8(%rbp)
jmp 0x754dd
movq -0x6c8(%rbp), %rdi
leaq 0xfdd0(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x754f2
jmp 0x75517
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x7fd40
jmp 0x76fa8
movq -0x1b8(%rbp), %rax
cmpl $0x0, 0x80(%rax)
je 0x75596
movl -0x104(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x75596
movq -0x3c0(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x75570
movq -0x170(%rbp), %rax
movq 0x88(%rax), %rdi
movl -0x1d4(%rbp), %esi
movl -0x1d8(%rbp), %edx
movl -0x19c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x5a2e0
jmp 0x7556e
jmp 0x75570
movq -0x58(%rbp), %rax
movq %rax, -0x6d0(%rbp)
cmpq $0x0, %rax
je 0x7558e
movq -0x6d0(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x58(%rbp)
cmpl $0x0, -0x1dc(%rbp)
jne 0x755cc
cmpq $0x0, -0x58(%rbp)
je 0x755cc
movq -0x58(%rbp), %rax
movq %rax, -0x6d8(%rbp)
cmpq $0x0, %rax
je 0x755c4
movq -0x6d8(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x58(%rbp)
movq -0x3c0(%rbp), %rax
movq 0x298(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x298(%rax)
jmp 0x76549
movq -0x1b8(%rbp), %rax
cmpl $0x0, 0x80(%rax)
je 0x75647
cmpl $0x0, -0x1dc(%rbp)
jne 0x75647
movq -0x3c0(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x75645
movq -0x170(%rbp), %rax
movq 0x88(%rax), %rdi
movl -0x1d4(%rbp), %esi
movl -0x1d8(%rbp), %edx
movl -0x19c(%rbp), %ecx
movq -0x58(%rbp), %r8
callq 0x5a2e0
jmp 0x7563b
movl $0x1, -0x1dc(%rbp)
jmp 0x75647
movq -0x58(%rbp), %rsi
leaq -0x258(%rbp), %rdi
callq 0x80730
jmp 0x75659
leaq -0x240(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x258(%rbp), %rdx
callq 0x5a8f0
jmp 0x75672
leaq -0x258(%rbp), %rdi
callq 0x5b3f0
leaq -0x240(%rbp), %rdi
callq 0x5aa10
movsd %xmm0, -0x6e0(%rbp)
jmp 0x75694
movq -0x3c0(%rbp), %rax
movsd -0x6e0(%rbp), %xmm0
movsd %xmm0, -0x260(%rbp)
cmpl $0x1, 0x60(%rax)
jle 0x7582d
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x102a2(%rip), %rsi     # 0x85969
callq 0x9530
movq %rax, -0x6e8(%rbp)
jmp 0x756d5
movq -0x6e8(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x9930
movq %rax, -0x6f0(%rbp)
jmp 0x756f0
movq -0x6f0(%rbp), %rdi
leaq 0x10099(%rip), %rsi     # 0x85797
callq 0x9530
movq %rax, -0x6f8(%rbp)
jmp 0x7570c
movq -0x6f8(%rbp), %rdi
movl -0x1c4(%rbp), %esi
callq 0x9930
movq %rax, -0x700(%rbp)
jmp 0x75727
movq -0x700(%rbp), %rdi
leaq 0x10067(%rip), %rsi     # 0x8579c
callq 0x9530
movq %rax, -0x708(%rbp)
jmp 0x75743
movq -0x708(%rbp), %rdi
movl -0x108(%rbp), %esi
callq 0x9930
movq %rax, -0x710(%rbp)
jmp 0x7575e
movq -0x710(%rbp), %rdi
leaq 0x1003d(%rip), %rsi     # 0x857a9
callq 0x9530
movq %rax, -0x718(%rbp)
jmp 0x7577a
movq -0x718(%rbp), %rdi
movsd -0x260(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x720(%rbp)
jmp 0x75797
movq -0x720(%rbp), %rdi
leaq 0x10017(%rip), %rsi     # 0x857bc
callq 0x9530
movq %rax, -0x728(%rbp)
jmp 0x757b3
movq -0x728(%rbp), %rdi
movsd -0x260(%rbp), %xmm0
movsd -0x178(%rbp), %xmm1
subsd %xmm1, %xmm0
callq 0x9a30
movq %rax, -0x730(%rbp)
jmp 0x757dc
movq -0x730(%rbp), %rdi
leaq 0xfad1(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x757f1
jmp 0x7582d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x5b3f0
jmp 0x76fa8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x76575
movq -0x3d0(%rbp), %rsi
leaq -0x278(%rbp), %rdi
callq 0x805c0
jmp 0x75842
movq -0x3c8(%rbp), %rsi
leaq -0x290(%rbp), %rdi
callq 0x805c0
jmp 0x75857
leaq -0x290(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0x7ff70
jmp 0x7586c
movq -0x170(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x758cf
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x738(%rbp)
cmpq $0x0, %rax
je 0x7589f
movq -0x738(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x758cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x76569
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x7655d
movq -0x170(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x75904
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x740(%rbp)
cmpq $0x0, %rax
je 0x75902
movq -0x740(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x75904
movq -0x58(%rbp), %rdi
callq 0x7fd80
movsd %xmm1, -0x750(%rbp)
movsd %xmm0, -0x748(%rbp)
jmp 0x7591f
movsd -0x750(%rbp), %xmm0
movsd -0x748(%rbp), %xmm1
movsd %xmm1, -0x2a0(%rbp)
movsd %xmm0, -0x298(%rbp)
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
movsd -0x1d0(%rbp), %xmm0
leaq -0x2a0(%rbp), %rsi
callq 0x623c0
movq %rax, -0x758(%rbp)
jmp 0x75967
movq -0x758(%rbp), %rcx
movq -0x170(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x62930
jmp 0x7598b
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x63030
jmp 0x7599d
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x768(%rbp)
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x5ed10
movsd %xmm0, -0x760(%rbp)
jmp 0x759c4
movsd -0x760(%rbp), %xmm1
movsd -0x768(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x2a8(%rbp)
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rsi
leaq -0x2d8(%rbp), %rdi
callq 0x80730
jmp 0x759f9
leaq -0x2c0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x2d8(%rbp), %rdx
callq 0x5a8f0
jmp 0x75a12
leaq -0x88(%rbp), %rdi
leaq -0x2c0(%rbp), %rsi
movq %rsi, -0x778(%rbp)
callq 0x64270
movq -0x778(%rbp), %rdi
callq 0x5b3f0
leaq -0x2d8(%rbp), %rdi
callq 0x5b3f0
movl $0xc0, %edi
callq 0x9550
movq %rax, -0x770(%rbp)
jmp 0x75a57
movq -0x770(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5e780
jmp 0x75a6c
movq -0x770(%rbp), %rcx
movq -0x170(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x612f0
jmp 0x75a90
movq -0x3c0(%rbp), %rax
cmpl $0x1, 0x60(%rax)
jle 0x75b9d
leaq -0x278(%rbp), %rdi
callq 0x806e0
testb $0x1, %al
jne 0x75b9d
movsd -0x260(%rbp), %xmm0
ucomisd -0x40(%rbp), %xmm0
jb 0x75b9d
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x10160(%rip), %rsi     # 0x85c3a
callq 0x9530
movq %rax, -0x780(%rbp)
jmp 0x75ae8
movq -0x780(%rbp), %rdi
movsd -0x260(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x788(%rbp)
jmp 0x75b05
movq -0x788(%rbp), %rdi
leaq 0xfcc7(%rip), %rsi      # 0x857da
callq 0x9530
movq %rax, -0x790(%rbp)
jmp 0x75b21
movq -0x790(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x798(%rbp)
jmp 0x75b3b
movq -0x798(%rbp), %rdi
leaq 0xfcb3(%rip), %rsi      # 0x857fc
callq 0x9530
jmp 0x75b50
jmp 0x75b9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x2d8(%rbp), %rdi
callq 0x5b3f0
jmp 0x7655d
movq -0x770(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
movl $0xc0, %esi
callq 0x9560
jmp 0x7655d
movq -0x3c0(%rbp), %rax
cmpl $0x1, 0x60(%rax)
jle 0x75c65
leaq -0x278(%rbp), %rdi
callq 0x806e0
testb $0x1, %al
jne 0x75c65
movsd -0x260(%rbp), %xmm0
ucomisd -0x90(%rbp), %xmm0
jb 0x75c65
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0x10050(%rip), %rsi     # 0x85c3a
callq 0x9530
movq %rax, -0x7a0(%rbp)
jmp 0x75bf8
movq -0x7a0(%rbp), %rdi
movsd -0x260(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x7a8(%rbp)
jmp 0x75c15
movq -0x7a8(%rbp), %rdi
leaq 0xfc06(%rip), %rsi      # 0x85829
callq 0x9530
movq %rax, -0x7b0(%rbp)
jmp 0x75c31
movq -0x7b0(%rbp), %rdi
movsd -0x90(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x7b8(%rbp)
jmp 0x75c4e
movq -0x7b8(%rbp), %rdi
leaq 0xfba0(%rip), %rsi      # 0x857fc
callq 0x9530
jmp 0x75c63
jmp 0x75c65
leaq -0x278(%rbp), %rdi
callq 0x806e0
testb $0x1, %al
jne 0x7608c
movsd -0x260(%rbp), %xmm1
movsd -0x40(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x7608c
movsd -0x260(%rbp), %xmm1
movsd -0x90(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x7608c
movq -0x3c0(%rbp), %rax
cmpl $0x1, 0x60(%rax)
jle 0x75ea2
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xfb80(%rip), %rsi      # 0x8584d
callq 0x9530
movq %rax, -0x7c0(%rbp)
jmp 0x75cdb
movq -0x7c0(%rbp), %rdi
leaq -0x2a0(%rbp), %rsi
callq 0x80760
movq %rax, -0x7c8(%rbp)
jmp 0x75cf7
movq -0x7c8(%rbp), %rdi
leaq 0xfd13(%rip), %rsi      # 0x85a18
callq 0x9530
movq %rax, -0x7d0(%rbp)
jmp 0x75d13
movq -0x7d0(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x9930
movq %rax, -0x7d8(%rbp)
jmp 0x75d2b
movq -0x7d8(%rbp), %rdi
leaq 0xf582(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x75d40
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xfb1d(%rip), %rsi      # 0x8586f
callq 0x9530
movq %rax, -0x7e0(%rbp)
jmp 0x75d60
leaq -0x70(%rbp), %rdi
callq 0x5add0
movq -0x7e0(%rbp), %rdi
movq %rax, %rsi
callq 0x9150
movq %rax, -0x7e8(%rbp)
jmp 0x75d81
movq -0x7e8(%rbp), %rdi
leaq 0xfaf1(%rip), %rsi      # 0x85880
callq 0x9530
movq %rax, -0x7f0(%rbp)
jmp 0x75d9d
leaq -0x70(%rbp), %rdi
callq 0x5aa10
movsd %xmm0, -0x7f8(%rbp)
jmp 0x75db0
movsd -0x7f8(%rbp), %xmm0
movq -0x7f0(%rbp), %rdi
callq 0x9a30
movq %rax, -0x800(%rbp)
jmp 0x75dcd
movq -0x800(%rbp), %rdi
leaq 0xfab6(%rip), %rsi      # 0x85891
callq 0x9530
movq %rax, -0x808(%rbp)
jmp 0x75de9
movq -0x808(%rbp), %rdi
movsd -0x2a8(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x810(%rbp)
jmp 0x75e06
movq -0x810(%rbp), %rdi
leaq 0xf4a7(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x75e1b
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xfa79(%rip), %rsi      # 0x858a6
callq 0x9530
movq %rax, -0x818(%rbp)
jmp 0x75e3b
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x5ed10
movsd %xmm0, -0x820(%rbp)
jmp 0x75e55
movsd -0x820(%rbp), %xmm0
movq -0x818(%rbp), %rdi
callq 0x9a30
movq %rax, -0x828(%rbp)
jmp 0x75e72
movq -0x828(%rbp), %rdi
leaq 0xf43b(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x75e87
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xfa26(%rip), %rsi      # 0x858bf
callq 0x9530
jmp 0x75ea0
jmp 0x75ea2
leaq -0x2f8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x5abd0
jmp 0x75eb4
movups -0x2f8(%rbp), %xmm0
movups -0x2e8(%rbp), %xmm1
movaps %xmm1, -0xf0(%rbp)
movaps %xmm0, -0x100(%rbp)
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x830(%rbp)
leaq -0x318(%rbp), %rdi
leaq -0x290(%rbp), %rsi
callq 0x805c0
jmp 0x75ef7
leaq -0x330(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x805c0
jmp 0x75f0c
movq -0x830(%rbp), %rsi
movq -0x3c0(%rbp), %rdi
movsd -0x2a8(%rbp), %xmm0
movsd -0x90(%rbp), %xmm1
movl -0x44(%rbp), %r9d
incl %r9d
movl 0x10(%rbp), %ecx
movl 0x18(%rbp), %edx
decl %edx
movq %rsp, %rax
movl %edx, 0x8(%rax)
movl %ecx, (%rax)
leaq -0x318(%rbp), %rdx
leaq -0x330(%rbp), %rcx
leaq -0x260(%rbp), %r8
callq 0x742a0
movq %rax, -0x838(%rbp)
jmp 0x75f64
leaq -0x330(%rbp), %rdi
callq 0x7fd40
leaq -0x318(%rbp), %rdi
callq 0x7fd40
movq -0x838(%rbp), %rax
movq %rax, -0x300(%rbp)
cmpq $0x0, -0x300(%rbp)
jne 0x75ff1
movsd 0xc06c(%rip), %xmm0     # 0x82008
addsd -0x90(%rbp), %xmm0
movsd %xmm0, -0x260(%rbp)
jmp 0x75ff1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x75fe0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x330(%rbp), %rdi
callq 0x7fd40
leaq -0x318(%rbp), %rdi
callq 0x7fd40
jmp 0x7655d
movq -0x3c0(%rbp), %rax
cmpl $0x1, 0x60(%rax)
jle 0x7608a
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xf8d0(%rip), %rsi      # 0x858e4
callq 0x9530
movq %rax, -0x840(%rbp)
jmp 0x76022
movq -0x840(%rbp), %rdi
movl 0x18(%rbp), %esi
callq 0x9930
movq %rax, -0x848(%rbp)
jmp 0x7603a
movq -0x848(%rbp), %rdi
leaq 0xf8b8(%rip), %rsi      # 0x85900
callq 0x9530
movq %rax, -0x850(%rbp)
jmp 0x76056
movq -0x850(%rbp), %rdi
movsd -0x260(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x858(%rbp)
jmp 0x76073
movq -0x858(%rbp), %rdi
leaq 0xf23a(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x76088
jmp 0x7608a
jmp 0x7608c
movsd -0x260(%rbp), %xmm1
movsd -0x90(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x76436
movsd -0x260(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x1d0(%rbp), %xmm0
movsd %xmm0, -0xa8(%rbp)
movq -0x58(%rbp), %rdi
callq 0x7fd80
movsd %xmm1, -0x868(%rbp)
movsd %xmm0, -0x860(%rbp)
jmp 0x760e1
movq -0x3c0(%rbp), %rax
movsd -0x868(%rbp), %xmm0
movsd -0x860(%rbp), %xmm1
movsd %xmm1, -0x340(%rbp)
movsd %xmm0, -0x338(%rbp)
movq -0x340(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
movq -0x338(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movl -0x1c4(%rbp), %ecx
movl %ecx, -0x94(%rbp)
movl -0x1d4(%rbp), %ecx
movl %ecx, -0x98(%rbp)
movl -0x108(%rbp), %ecx
movl %ecx, -0x9c(%rbp)
cmpl $0x1, 0x60(%rax)
jle 0x76434
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xfae5(%rip), %rsi      # 0x85c49
callq 0x9530
movq %rax, -0x870(%rbp)
jmp 0x76172
movq -0x870(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x9930
movq %rax, -0x878(%rbp)
jmp 0x7618a
movq -0x878(%rbp), %rdi
leaq 0xf123(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x7619f
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xf7b8(%rip), %rsi      # 0x85969
callq 0x9530
movq %rax, -0x880(%rbp)
jmp 0x761bf
movq -0x880(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x9930
movq %rax, -0x888(%rbp)
jmp 0x761da
movq -0x888(%rbp), %rdi
leaq 0xf9cb(%rip), %rsi      # 0x85bb3
callq 0x9530
movq %rax, -0x890(%rbp)
jmp 0x761f6
movq -0x890(%rbp), %rdi
movl -0x1c4(%rbp), %esi
callq 0x9930
movq %rax, -0x898(%rbp)
jmp 0x76211
movq -0x898(%rbp), %rdi
leaq 0xf57d(%rip), %rsi      # 0x8579c
callq 0x9530
movq %rax, -0x8a0(%rbp)
jmp 0x7622d
movq -0x8a0(%rbp), %rdi
movl -0x108(%rbp), %esi
callq 0x9930
movq %rax, -0x8a8(%rbp)
jmp 0x76248
movq -0x8a8(%rbp), %rdi
leaq 0xf065(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x7625d
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xf709(%rip), %rsi      # 0x85978
callq 0x9530
movq %rax, -0x8b0(%rbp)
jmp 0x7627d
movsd -0x1d0(%rbp), %xmm0
movsd 0xdf2b(%rip), %xmm1     # 0x841b8
mulsd %xmm1, %xmm0
movsd 0xbd7f(%rip), %xmm1     # 0x82018
divsd %xmm1, %xmm0
callq 0x9220
movq -0x8b0(%rbp), %rdi
callq 0x9a30
movq %rax, -0x8b8(%rbp)
jmp 0x762b7
movq -0x8b8(%rbp), %rdi
leaq 0xf6be(%rip), %rsi      # 0x85983
callq 0x9530
movq %rax, -0x8c0(%rbp)
jmp 0x762d3
movq -0x8c0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x80760
movq %rax, -0x8c8(%rbp)
jmp 0x762ef
movq -0x8c8(%rbp), %rdi
leaq 0xf694(%rip), %rsi      # 0x85991
callq 0x9530
movq %rax, -0x8d0(%rbp)
jmp 0x7630b
movq -0x50(%rbp), %rdi
movl -0x1d4(%rbp), %esi
callq 0x7ff40
movq %rax, -0x8d8(%rbp)
jmp 0x76323
movq -0x8d8(%rbp), %rsi
movq -0x8d0(%rbp), %rdi
callq 0x80760
movq %rax, -0x8e0(%rbp)
jmp 0x7633f
movq -0x8e0(%rbp), %rdi
leaq 0xefb5(%rip), %rsi      # 0x85302
callq 0x9530
movq %rax, -0x8e8(%rbp)
jmp 0x7635b
movq -0x1c0(%rbp), %rdi
movl -0x1c4(%rbp), %esi
callq 0x7ff40
movq %rax, -0x8f0(%rbp)
jmp 0x76376
movq -0x8f0(%rbp), %rsi
movq -0x8e8(%rbp), %rdi
callq 0x80760
movq %rax, -0x8f8(%rbp)
jmp 0x76392
movq -0x8f8(%rbp), %rdi
leaq 0xef1b(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x763a7
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xf5e3(%rip), %rsi      # 0x8599c
callq 0x9530
movq %rax, -0x900(%rbp)
jmp 0x763c7
movq -0x900(%rbp), %rdi
movsd -0x260(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x908(%rbp)
jmp 0x763e4
movq -0x908(%rbp), %rdi
leaq 0xf5bf(%rip), %rsi      # 0x859b1
callq 0x9530
movq %rax, -0x910(%rbp)
jmp 0x76400
movq -0x910(%rbp), %rdi
movsd -0x178(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x918(%rbp)
jmp 0x7641d
movq -0x918(%rbp), %rdi
leaq 0xee90(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x76432
jmp 0x76434
jmp 0x76436
cmpl $0x0, -0x1dc(%rbp)
jne 0x76525
movq -0x58(%rbp), %rax
movq %rax, -0x920(%rbp)
cmpq $0x0, %rax
je 0x76461
movq -0x920(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x50(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x76523
movq 0x41b72(%rip), %rdi     # 0xb7fe8
leaq 0xf2af(%rip), %rsi      # 0x8572c
callq 0x9530
movq %rax, -0x928(%rbp)
jmp 0x7648b
movq -0x928(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x9450
movq %rax, -0x930(%rbp)
jmp 0x764a4
movq -0x930(%rbp), %rdi
leaq 0xf283(%rip), %rsi      # 0x85735
callq 0x9530
movq %rax, -0x938(%rbp)
jmp 0x764c0
movq -0x938(%rbp), %rdi
movl 0x18(%rbp), %esi
callq 0x9930
movq %rax, -0x940(%rbp)
jmp 0x764d8
movq -0x940(%rbp), %rdi
leaq 0xf272(%rip), %rsi      # 0x85758
callq 0x9530
movq %rax, -0x948(%rbp)
jmp 0x764f4
movq -0x948(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x9930
movq %rax, -0x950(%rbp)
jmp 0x7650c
movq -0x950(%rbp), %rdi
leaq 0xeda1(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x76521
jmp 0x76523
jmp 0x76525
leaq -0x290(%rbp), %rdi
callq 0x7fd40
leaq -0x278(%rbp), %rdi
callq 0x7fd40
leaq -0x240(%rbp), %rdi
callq 0x5b3f0
movl -0x1d8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d8(%rbp)
jmp 0x74ad0
leaq -0x290(%rbp), %rdi
callq 0x7fd40
leaq -0x278(%rbp), %rdi
callq 0x7fd40
leaq -0x240(%rbp), %rdi
callq 0x5b3f0
jmp 0x76fa8
jmp 0x76588
movl -0x1d4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d4(%rbp)
jmp 0x74a0d
jmp 0x7659e
movl -0x19c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x19c(%rbp)
movl -0x1c4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c4(%rbp)
jmp 0x7497e
jmp 0x765c3
leaq -0x1a8(%rbp), %rdi
callq 0x80570
movl -0x108(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x108(%rbp)
jmp 0x74883
cmpq $0x0, -0x50(%rbp)
je 0x7660a
movq -0x50(%rbp), %rax
movq %rax, -0x958(%rbp)
cmpq $0x0, %rax
je 0x76608
movq -0x958(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x7660a
movq $0x0, -0x50(%rbp)
movsd 0xdbc6(%rip), %xmm0     # 0x841e0
ucomisd -0xa8(%rbp), %xmm0
jbe 0x7664b
movq -0x38(%rbp), %rax
movsd 0xdb90(%rip), %xmm0     # 0x841c0
movsd %xmm0, (%rax)
movq $0x0, -0x8(%rbp)
movl $0x1, -0x344(%rbp)
jmp 0x76f86
movsd -0x90(%rbp), %xmm0
ucomisd -0x40(%rbp), %xmm0
jbe 0x7671e
movq -0x3c0(%rbp), %rax
movsd -0x90(%rbp), %xmm0
movq -0x38(%rbp), %rcx
movsd %xmm0, (%rcx)
cmpl $0x1, 0x60(%rax)
jle 0x76704
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xf32f(%rip), %rsi      # 0x859c0
callq 0x9530
movq %rax, -0x960(%rbp)
jmp 0x7669f
movq -0x960(%rbp), %rdi
movl 0x18(%rbp), %esi
callq 0x9930
movq %rax, -0x968(%rbp)
jmp 0x766b7
movq -0x968(%rbp), %rdi
leaq 0xf302(%rip), %rsi      # 0x859c7
callq 0x9530
movq %rax, -0x970(%rbp)
jmp 0x766d3
movq -0x970(%rbp), %rdi
movsd -0x40(%rbp), %xmm0
callq 0x9a30
movq %rax, -0x978(%rbp)
jmp 0x766ed
movq -0x978(%rbp), %rdi
leaq 0xf2e2(%rip), %rsi      # 0x859dd
callq 0x9530
jmp 0x76702
jmp 0x76704
movq -0x170(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x344(%rbp)
jmp 0x76f86
movq -0x170(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x76753
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x980(%rbp)
cmpq $0x0, %rax
je 0x76751
movq -0x980(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x76753
movq -0x170(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x76788
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x988(%rbp)
cmpq $0x0, %rax
je 0x76786
movq -0x988(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x76788
movq -0x170(%rbp), %rax
movq 0x68(%rax), %rdi
movsd -0xa8(%rbp), %xmm0
leaq -0xb8(%rbp), %rsi
callq 0x623c0
movq %rax, -0x990(%rbp)
jmp 0x767b0
movq -0x990(%rbp), %rcx
movq -0x170(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x62930
jmp 0x767d4
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x63030
jmp 0x767e6
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x5ed10
movsd %xmm0, -0x998(%rbp)
jmp 0x76800
movsd -0x998(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x170(%rbp), %rax
movq 0x78(%rax), %rsi
leaq -0x378(%rbp), %rdi
callq 0x80730
jmp 0x7682f
leaq -0x360(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x378(%rbp), %rdx
callq 0x5a8f0
jmp 0x76848
leaq -0x70(%rbp), %rdi
leaq -0x360(%rbp), %rsi
movq %rsi, -0x9a8(%rbp)
callq 0x64270
movq -0x9a8(%rbp), %rdi
callq 0x5b3f0
leaq -0x378(%rbp), %rdi
callq 0x5b3f0
movl $0xc0, %edi
callq 0x9550
movq %rax, -0x9a0(%rbp)
jmp 0x7688a
movq -0x9a0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x5e780
jmp 0x7689c
movq -0x9a0(%rbp), %rcx
movq -0x170(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x612f0
jmp 0x768c0
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x615a0
movsd %xmm1, -0x9b8(%rbp)
movsd %xmm0, -0x9b0(%rbp)
jmp 0x768e2
movq -0x3c0(%rbp), %rax
movsd -0x9b8(%rbp), %xmm0
movsd -0x9b0(%rbp), %xmm1
movsd %xmm1, -0x388(%rbp)
movsd %xmm0, -0x380(%rbp)
movsd -0x90(%rbp), %xmm0
movq -0x38(%rbp), %rcx
movsd %xmm0, (%rcx)
cmpl $0x0, 0x60(%rax)
jle 0x76f71
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xf08b(%rip), %rsi      # 0x859c0
callq 0x9530
movq %rax, -0x9c0(%rbp)
jmp 0x76943
movq -0x9c0(%rbp), %rdi
movl 0x18(%rbp), %esi
callq 0x9930
movq %rax, -0x9c8(%rbp)
jmp 0x7695b
movq -0x9c8(%rbp), %rdi
leaq 0xf093(%rip), %rsi      # 0x859fc
callq 0x9530
movq %rax, -0x9d0(%rbp)
jmp 0x76977
movq -0x9d0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x80760
movq %rax, -0x9d8(%rbp)
jmp 0x76993
movq -0x9d8(%rbp), %rdi
leaq 0xf073(%rip), %rsi      # 0x85a14
callq 0x9530
movq %rax, -0x9e0(%rbp)
jmp 0x769af
movsd -0xa8(%rbp), %xmm0
movsd 0xd7f9(%rip), %xmm1     # 0x841b8
mulsd %xmm1, %xmm0
movsd 0xb64d(%rip), %xmm1     # 0x82018
divsd %xmm1, %xmm0
callq 0x9220
movq -0x9e0(%rbp), %rdi
callq 0x9a30
movq %rax, -0x9e8(%rbp)
jmp 0x769e9
movq -0x9e8(%rbp), %rdi
leaq 0xf01f(%rip), %rsi      # 0x85a16
callq 0x9530
movq %rax, -0x9f0(%rbp)
jmp 0x76a05
movq -0x9f0(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x9930
movq %rax, -0x9f8(%rbp)
jmp 0x76a1d
movq -0x9f8(%rbp), %rdi
leaq 0xeffb(%rip), %rsi      # 0x85a26
callq 0x9530
movq %rax, -0xa00(%rbp)
jmp 0x76a39
movq -0xa00(%rbp), %rdi
movl -0x98(%rbp), %esi
callq 0x9930
movq %rax, -0xa08(%rbp)
jmp 0x76a54
movq -0xa08(%rbp), %rdi
leaq 0xf151(%rip), %rsi      # 0x85bb3
callq 0x9530
movq %rax, -0xa10(%rbp)
jmp 0x76a70
movq -0xa10(%rbp), %rdi
movl -0x94(%rbp), %esi
callq 0x9930
movq %rax, -0xa18(%rbp)
jmp 0x76a8b
movq -0xa18(%rbp), %rdi
leaq 0xed03(%rip), %rsi      # 0x8579c
callq 0x9530
movq %rax, -0xa20(%rbp)
jmp 0x76aa7
movq -0xa20(%rbp), %rdi
movl -0x9c(%rbp), %esi
callq 0x9930
movq %rax, -0xa28(%rbp)
jmp 0x76ac2
movq -0xa28(%rbp), %rdi
leaq 0xe7eb(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x76ad7
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xed86(%rip), %rsi      # 0x8586f
callq 0x9530
movq %rax, -0xa30(%rbp)
jmp 0x76af7
leaq -0x70(%rbp), %rdi
callq 0x5add0
movq -0xa30(%rbp), %rdi
movq %rax, %rsi
callq 0x9150
movq %rax, -0xa38(%rbp)
jmp 0x76b18
movq -0xa38(%rbp), %rdi
leaq 0xed5a(%rip), %rsi      # 0x85880
callq 0x9530
movq %rax, -0xa40(%rbp)
jmp 0x76b34
leaq -0x70(%rbp), %rdi
callq 0x5aa10
movsd %xmm0, -0xa48(%rbp)
jmp 0x76b47
movsd -0xa48(%rbp), %xmm0
movq -0xa40(%rbp), %rdi
callq 0x9a30
movq %rax, -0xa50(%rbp)
jmp 0x76b64
movq -0xa50(%rbp), %rdi
leaq 0xed1f(%rip), %rsi      # 0x85891
callq 0x9530
movq %rax, -0xa58(%rbp)
jmp 0x76b80
movq -0xa58(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x9a30
movq %rax, -0xa60(%rbp)
jmp 0x76b9a
movq -0xa60(%rbp), %rdi
leaq 0xe713(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x76baf
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xece5(%rip), %rsi      # 0x858a6
callq 0x9530
movq %rax, -0xa68(%rbp)
jmp 0x76bcf
movq -0x170(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x5ed10
movsd %xmm0, -0xa70(%rbp)
jmp 0x76be9
movsd -0xa70(%rbp), %xmm0
movq -0xa68(%rbp), %rdi
callq 0x9a30
movq %rax, -0xa78(%rbp)
jmp 0x76c06
movq -0xa78(%rbp), %rdi
leaq 0xee26(%rip), %rsi      # 0x85a3a
callq 0x9530
movq %rax, -0xa80(%rbp)
jmp 0x76c22
movq -0xa80(%rbp), %rdi
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
callq 0x9a30
movq %rax, -0xa88(%rbp)
jmp 0x76c3f
movq -0xa88(%rbp), %rdi
leaq 0xe66e(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x76c54
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xeddc(%rip), %rsi      # 0x85a42
callq 0x9530
movq %rax, -0xa90(%rbp)
jmp 0x76c74
movq -0x3d0(%rbp), %rdi
callq 0x7ffb0
movq -0xa90(%rbp), %rdi
movq %rax, %rsi
callq 0x9150
movq %rax, -0xa98(%rbp)
jmp 0x76c98
movq -0xa98(%rbp), %rdi
leaq 0xe615(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x76cad
movq -0x3d0(%rbp), %rdi
movl $0x1, -0x38c(%rbp)
callq 0x803f0
movq %rax, -0x398(%rbp)
movq -0x3d0(%rbp), %rdi
callq 0x80450
movq %rax, -0x3a0(%rbp)
leaq -0x398(%rbp), %rdi
leaq -0x3a0(%rbp), %rsi
callq 0x80420
testb $0x1, %al
jne 0x76cf9
jmp 0x76f6f
leaq -0x398(%rbp), %rdi
callq 0x80480
movq (%rax), %rax
movq %rax, -0x3a8(%rbp)
movq -0x3a8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x76dc1
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xed24(%rip), %rsi      # 0x85a57
callq 0x9530
movq %rax, -0xaa0(%rbp)
jmp 0x76d41
movq -0xaa0(%rbp), %rdi
movl -0x38c(%rbp), %esi
callq 0x9930
movq %rax, -0xaa8(%rbp)
jmp 0x76d5c
movq -0xaa8(%rbp), %rdi
leaq 0xeeff(%rip), %rsi      # 0x85c69
callq 0x9530
jmp 0x76d71
jmp 0x76f4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x378(%rbp), %rdi
callq 0x5b3f0
jmp 0x76fa8
movq -0x9a0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
movl $0xc0, %esi
callq 0x9560
jmp 0x76fa8
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xec83(%rip), %rsi      # 0x85a56
callq 0x9530
movq %rax, -0xab0(%rbp)
jmp 0x76de1
movq -0xab0(%rbp), %rdi
movl -0x38c(%rbp), %esi
callq 0x9930
movq %rax, -0xab8(%rbp)
jmp 0x76dfc
movq -0xab8(%rbp), %rdi
leaq 0xec56(%rip), %rsi      # 0x85a60
callq 0x9530
movq %rax, -0xac0(%rbp)
jmp 0x76e18
movq -0x3a8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x7fd80
movsd %xmm1, -0xad0(%rbp)
movsd %xmm0, -0xac8(%rbp)
jmp 0x76e3a
movq -0xac0(%rbp), %rdi
movsd -0xad0(%rbp), %xmm0
movsd -0xac8(%rbp), %xmm1
movsd %xmm1, -0x3b8(%rbp)
movsd %xmm0, -0x3b0(%rbp)
leaq -0x3b8(%rbp), %rsi
callq 0x80760
movq %rax, -0xad8(%rbp)
jmp 0x76e76
movq -0xad8(%rbp), %rdi
leaq 0xebeb(%rip), %rsi      # 0x85a6f
callq 0x9530
movq %rax, -0xae0(%rbp)
jmp 0x76e92
movq -0x3a8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x7fd60
movsd %xmm0, -0xae8(%rbp)
jmp 0x76eac
movsd -0xae8(%rbp), %xmm0
movsd 0xd2fc(%rip), %xmm1     # 0x841b8
mulsd %xmm1, %xmm0
movsd 0xb150(%rip), %xmm1     # 0x82018
divsd %xmm1, %xmm0
callq 0x9220
movq -0xae0(%rbp), %rdi
callq 0x9a30
jmp 0x76edf
movq -0x3c0(%rbp), %rdi
addq $0x68, %rdi
leaq 0xeb84(%rip), %rsi      # 0x85a75
callq 0x9530
movq %rax, -0xaf0(%rbp)
jmp 0x76eff
movq -0x3a8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x5ed10
movsd %xmm0, -0xaf8(%rbp)
jmp 0x76f19
movsd -0xaf8(%rbp), %xmm0
movq -0xaf0(%rbp), %rdi
callq 0x9a30
movq %rax, -0xb00(%rbp)
jmp 0x76f36
movq -0xb00(%rbp), %rdi
leaq 0xe377(%rip), %rsi      # 0x852bb
callq 0x9530
jmp 0x76f4b
jmp 0x76f4d
jmp 0x76f4f
leaq -0x398(%rbp), %rdi
callq 0x80570
movl -0x38c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38c(%rbp)
jmp 0x76cca
jmp 0x76f71
movq -0x170(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x344(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5b3f0
leaq -0x70(%rbp), %rdi
callq 0x5b3f0
movq -0x8(%rbp), %rax
addq $0xb10, %rsp            # imm = 0xB10
popq %rbp
retq
leaq -0x88(%rbp), %rdi
callq 0x5b3f0
leaq -0x70(%rbp), %rdi
callq 0x5b3f0
movq -0xc0(%rbp), %rdi
callq 0x9960
nopl (%rax)