// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp            # imm = 0x2B8
movsd %xmm2, 0xc0(%rsp)
movq %r9, %rbp
movsd %xmm1, 0xf0(%rsp)
movsd %xmm0, 0x178(%rsp)
movl %r8d, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %rdx, 0xd8(%rsp)
movq %rsi, %rbx
movq %rdi, %r12
xorl %eax, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x80(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x70(%rsp)
movq %rax, 0x150(%rsp)
movapd %xmm0, 0x140(%rsp)
movapd %xmm0, 0x1c0(%rsp)
movapd %xmm0, 0x250(%rsp)
movapd %xmm0, 0x240(%rsp)
movapd %xmm0, 0x160(%rsp)
cmpl $0x2, 0x60(%rdi)
jl 0x330c5
leaq 0x68(%r12), %r14
leaq 0xd5d4(%rip), %rsi      # 0x40553
movl $0x17, %edx
movq %r14, %rdi
callq 0x74d0
movq %r14, %rdi
movl 0x300(%rsp), %esi
callq 0x7710
movq %rax, %r15
leaq 0xd5c6(%rip), %rsi      # 0x4056b
movl $0x11, %edx
movq %rax, %rdi
callq 0x74d0
movq %rbx, %rdi
callq 0x26926
movq %r15, %rdi
callq 0x7680
movq %rax, %r15
leaq 0xd5b1(%rip), %rsi      # 0x4057d
movl $0xc, %edx
movq %rax, %rdi
callq 0x74d0
movq %r15, %rdi
movsd 0xf0(%rsp), %xmm0
callq 0x7680
leaq 0xd599(%rip), %rsi      # 0x4058a
movl $0xa, %edx
movq %r14, %rdi
callq 0x74d0
movsd (%rbp), %xmm0
movq %r14, %rdi
callq 0x7680
movq %rax, %r15
leaq 0xd580(%rip), %rsi      # 0x40595
movl $0xd, %edx
movq %rax, %rdi
callq 0x74d0
movq %r15, %rdi
movsd 0xc0(%rsp), %xmm0
callq 0x7680
leaq 0xd1f6(%rip), %rsi      # 0x40230
movl $0x1, %edx
movq %rax, %rdi
callq 0x74d0
leaq 0xd555(%rip), %rsi      # 0x405a3
movl $0x11, %edx
movq %r14, %rdi
callq 0x74d0
movq 0x88(%rsp), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x72f0
movq %rax, %r14
leaq 0xd53c(%rip), %rsi      # 0x405b5
movl $0xa, %edx
movq %rax, %rdi
callq 0x74d0
movq 0x88(%rsp), %rax
movq (%rax), %rax
movl $0x90, %r15d
addq 0x10(%rax), %r15
movq %r15, %rdi
callq 0x71d0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x74d0
leaq 0xd178(%rip), %rsi      # 0x40230
movl $0x1, %edx
movq %r14, %rdi
callq 0x74d0
leaq 0x10(%rbx), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x25bd8
movq 0x70(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0xa0(%rsp), %rax
movq %rax, 0x70(%rsp)
movupd 0xa8(%rsp), %xmm0
movupd %xmm0, 0x78(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0xa0(%rsp)
movq $0x0, 0xb0(%rsp)
testq %rdi, %rdi
je 0x33125
subq %rdi, %rsi
callq 0x7440
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x33142
movq 0xb0(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
movq %rbx, %rdi
callq 0x283b4
movq %r12, %r13
leaq 0xa0(%rsp), %rdi
movq %rbx, %rsi
callq 0x2822c
movupd 0xa0(%rsp), %xmm0
movupd 0xb0(%rsp), %xmm1
movapd %xmm1, 0x250(%rsp)
movapd %xmm0, 0x240(%rsp)
movq 0x88(%rsp), %rax
movq (%rax), %rbx
movq 0x10(%rbx), %r12
decq 0x10(%rax)
movq %rbx, %rdi
callq 0x76a0
movl $0x18, %esi
movq %rbx, %rdi
callq 0x7440
movq 0x68(%r12), %rdi
callq 0x26926
movsd %xmm0, 0xd0(%rsp)
movq %rbp, 0x1d8(%rsp)
leaq 0x2a0(%rsp), %r14
movq %r14, %rdi
movq 0xd8(%rsp), %rsi
callq 0x3c91c
movq 0x2a0(%rsp), %rdi
xorl %ebx, %ebx
cmpq %r14, %rdi
je 0x33204
movq %rdi, %rax
movq 0x10(%rax), %rcx
movq (%rax), %rdx
movq 0x68(%rcx), %rax
addl 0x8(%rax), %ebx
movq %rdx, %rax
cmpq %r14, %rdx
jne 0x331ee
cmpq %r14, %rdi
je 0x3321e
movq (%rdi), %r15
movl $0x18, %esi
callq 0x7440
movq %r15, %rdi
cmpq %r14, %r15
jne 0x33209
cmpl $0x2, 0x60(%r13)
jl 0x33293
leaq 0x68(%r13), %r14
leaq 0xd390(%rip), %rsi      # 0x405c0
movl $0x17, %edx
movq %r14, %rdi
callq 0x74d0
leaq 0x90(%r12), %r15
movq %r15, %rdi
callq 0x71d0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x74d0
leaq 0xd376(%rip), %rsi      # 0x405d8
movl $0x6, %edx
movq %r14, %rdi
callq 0x74d0
movq 0x68(%r12), %rax
movl 0x8(%rax), %esi
movq %r14, %rdi
callq 0x7710
leaq 0xd359(%rip), %rsi      # 0x405df
movl $0xb, %edx
movq %rax, %rdi
callq 0x74d0
movl 0x64(%r13), %eax
testl %eax, %eax
je 0x332a6
cmpq $0x0, 0x88(%r12)
je 0x33300
testl %eax, %eax
je 0x333b1
cmpl $0x2, 0x60(%r13)
jl 0x333b1
leaq 0x68(%r13), %rbx
leaq 0xd35b(%rip), %rsi      # 0x4061f
movl $0x19, %edx
movq %rbx, %rdi
callq 0x74d0
leaq 0x90(%r12), %r14
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74d0
movl $0x16, %edx
leaq 0xd33e(%rip), %rsi      # 0x40639
jmp 0x333a9
movl $0x38, %edi
callq 0x7430
movq %rax, %r15
movq 0x68(%r12), %rax
movl 0x8(%rax), %esi
movq %r15, %rdi
movl 0x90(%rsp), %edx
movl %ebx, %ecx
callq 0x253e4
movq %r15, 0x88(%r12)
cmpl $0x2, 0x60(%r13)
jl 0x333b1
leaq 0x68(%r13), %r14
leaq 0xd2ab(%rip), %rsi      # 0x405eb
movl $0x20, %edx
movq %r14, %rdi
callq 0x74d0
leaq 0x90(%r12), %r15
movq %r15, %rdi
callq 0x71d0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x74d0
leaq 0xd29a(%rip), %rsi      # 0x4060c
movl $0x7, %edx
movq %r14, %rdi
callq 0x74d0
movq 0x68(%r12), %rax
imull 0x90(%rsp), %ebx
imull 0x8(%rax), %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x7710
movq %rax, %rbx
movl $0xa, %edx
leaq 0xd26b(%rip), %rsi      # 0x40614
movq %rbx, %rdi
callq 0x74d0
movq %r12, 0x20(%rsp)
movl 0x2f0(%rsp), %ecx
movsd 0xd0(%rsp), %xmm0
addsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0xd0(%rsp)
movq %r13, %rbp
leaq 0x68(%r13), %rax
movq %rax, 0x8(%rsp)
leal 0x1(%rcx), %eax
movq %rax, 0x1f8(%rsp)
movl 0x300(%rsp), %eax
decl %eax
movq %rax, 0x1f0(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x58(%rsp)
xorl %ebx, %ebx
movsd 0xbd34(%rip), %xmm0     # 0x3f148
movsd %xmm0, 0xc8(%rsp)
movl $0xffffffff, 0x9c(%rsp) # imm = 0xFFFFFFFF
movsd 0xbdb0(%rip), %xmm0     # 0x3f1e0
movsd %xmm0, 0x50(%rsp)
movl $0xffffffff, 0x94(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x98(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x3c(%rsp)
movq %r13, 0x1e8(%rsp)
cmpl $0x2, 0x60(%rbp)
jl 0x334d7
movl $0x1, %edx
movq 0x8(%rsp), %rdi
leaq 0xab81(%rip), %rsi      # 0x3dff4
callq 0x74d0
movq 0x8(%rsp), %rdi
movl 0x300(%rsp), %esi
callq 0x7710
movq %rax, %r14
movl $0x12, %edx
movq %rax, %rdi
leaq 0xd1b5(%rip), %rsi      # 0x40650
callq 0x74d0
movsd 0x58(%rsp), %xmm0
mulsd 0xbcca(%rip), %xmm0     # 0x3f178
divsd 0x9b6a(%rip), %xmm0     # 0x3d020
callq 0x71c0
movq %r14, %rdi
callq 0x7680
movl $0x1, %edx
movq %rax, %rdi
leaq 0xcd5e(%rip), %rsi      # 0x40230
callq 0x74d0
testq %rbx, %rbx
je 0x334e5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x68(%rax), %rdi
movsd 0x58(%rsp), %xmm0
callq 0x28904
movq %rax, %rbx
incq 0x278(%rbp)
movq %rax, %rdi
callq 0x28f26
movq %rbx, %rdi
callq 0x297a6
movq 0xd8(%rsp), %rax
movq (%rax), %r14
cmpq %rax, %r14
movq %rbx, 0x18(%rsp)
je 0x34b51
movsd 0x58(%rsp), %xmm0
mulsd 0xbc3e(%rip), %xmm0     # 0x3f178
divsd 0x9ade(%rip), %xmm0     # 0x3d020
callq 0x71c0
movsd %xmm0, 0x1e0(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x38(%rsp)
movq 0x10(%r14), %rax
movq %rax, 0xf8(%rsp)
movq 0x78(%rax), %rax
movq %rax, 0x68(%rsp)
cmpl $0x2, 0x8(%rax)
jl 0x34b3c
xorl %r15d, %r15d
movq %r14, 0x200(%rsp)
cmpl $0x0, 0x60(%rbp)
jle 0x3359a
movq 0x8(%rsp), %rdi
callq 0x7300
movq %r15, 0x28(%rsp)
cmpl $0x2, 0x8(%rbx)
jl 0x34b0e
xorl %r12d, %r12d
movq $0x0, 0x30(%rsp)
xorl %r14d, %r14d
cmpl $0x0, 0x64(%rbp)
je 0x335f3
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x80(%rax)
je 0x335f3
movq 0x20(%rsp), %rax
movq 0x88(%rax), %rdi
movl %r12d, %esi
movl 0x3c(%rsp), %edx
movl 0x38(%rsp), %ecx
leaq 0x30(%rsp), %r8
callq 0x2550a
movl %eax, %r14d
testl %r14d, %r14d
js 0x339c3
je 0x33add
incq 0x2a8(%rbp)
movq 0x20(%rsp), %rax
movupd (%rax), %xmm0
movapd %xmm0, 0x160(%rsp)
movq 0x68(%rax), %rdi
callq 0x283b4
movq 0x30(%rsp), %rax
movsd 0xb0(%rax), %xmm2
movsd %xmm2, 0xe0(%rsp)
movsd %xmm0, 0x1b0(%rsp)
movsd 0xb8(%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm1, 0x208(%rsp)
callq 0x7790
movsd %xmm0, 0x60(%rsp)
movsd 0x58(%rsp), %xmm0
callq 0x70f0
movapd %xmm0, %xmm3
movsd 0x160(%rsp), %xmm0
movsd 0x168(%rsp), %xmm1
movsd 0x1b0(%rsp), %xmm5
subsd %xmm5, %xmm0
movsd 0x208(%rsp), %xmm4
subsd %xmm4, %xmm1
movapd %xmm3, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm0, %xmm3
movsd 0x60(%rsp), %xmm6
mulsd %xmm6, %xmm0
subsd %xmm2, %xmm0
addsd %xmm5, %xmm0
addsd 0xe0(%rsp), %xmm0
mulsd %xmm6, %xmm1
addsd %xmm1, %xmm3
addsd %xmm4, %xmm3
addsd 0x40(%rsp), %xmm3
movsd %xmm3, 0x40(%rsp)
movsd 0xb9db(%rip), %xmm1     # 0x3f0c8
divsd %xmm1, %xmm0
callq 0x71c0
movsd 0xb9ca(%rip), %xmm1     # 0x3f0c8
mulsd %xmm1, %xmm0
movsd %xmm0, 0xe0(%rsp)
movsd 0x40(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0x71c0
mulsd 0xb9a6(%rip), %xmm0     # 0x3f0c8
movsd 0xe0(%rsp), %xmm1
movsd %xmm1, 0x160(%rsp)
movsd %xmm0, 0x168(%rsp)
movq 0x30(%rsp), %rbx
leaq 0x228(%rsp), %rdi
movq 0xd8(%rsp), %rsi
callq 0x3c91c
movq %rbp, %rdi
movq %rbx, %rsi
leaq 0x228(%rsp), %rbx
movq %rbx, %rdx
leaq 0x240(%rsp), %rcx
leaq 0x160(%rsp), %r8
movl %r14d, %r9d
callq 0x354b6
movl %eax, %r15d
movq 0x228(%rsp), %rdi
cmpq %rbx, %rdi
je 0x337ad
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x7440
movq %rbx, %rdi
leaq 0x228(%rsp), %rax
cmpq %rax, %rbx
jne 0x33790
testl %r15d, %r15d
je 0x33b9f
cmpl $0x3, 0x60(%rbp)
jl 0x338b7
movl $0x12, %edx
movq 0x8(%rsp), %rdi
leaq 0xd3b8(%rip), %rsi      # 0x40b89
callq 0x74d0
movq 0x8(%rsp), %rdi
movl 0x2f0(%rsp), %esi
callq 0x7710
movq %rax, %rbx
movl $0x8, %edx
movq %rax, %rdi
leaq 0xd19a(%rip), %rsi      # 0x40993
callq 0x74d0
movq %rbx, %rdi
movl %r12d, %esi
callq 0x7710
movq %rax, %rbx
movl $0xb, %edx
movq %rax, %rdi
leaq 0xd2fa(%rip), %rsi      # 0x40b15
callq 0x74d0
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
callq 0x7710
movq %rax, %rbx
movl $0xc, %edx
movq %rax, %rdi
leaq 0xce42(%rip), %rsi      # 0x40681
callq 0x74d0
movq %rbx, %rdi
movl 0x14(%rsp), %esi
callq 0x7710
movq %rax, %rbx
movl $0xc, %edx
movq %rax, %rdi
leaq 0xce67(%rip), %rsi      # 0x406c9
callq 0x74d0
movq 0x28(%rsp), %rsi
shlq $0x4, %rsi
movq 0x68(%rsp), %rax
addq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x3c96c
movq %rax, %rbx
movl $0x9, %edx
movq %rax, %rdi
leaq 0xce5c(%rip), %rsi      # 0x406ef
callq 0x74d0
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7710
movl $0x1, %edx
movq %rax, %rdi
leaq 0xc97e(%rip), %rsi      # 0x40230
callq 0x74d0
testb $0x10, %r15b
je 0x3390c
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x80(%rax)
je 0x3390c
cmpl $0x0, 0x64(%rbp)
je 0x338f3
movq 0x20(%rsp), %rax
movq 0x88(%rax), %rdi
movl %r12d, %esi
movl 0x3c(%rsp), %edx
movl 0x38(%rsp), %ecx
xorl %r8d, %r8d
callq 0x25564
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x33903
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x30(%rsp)
testl %r14d, %r14d
sete %al
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x33933
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x30(%rsp)
incq 0x298(%rbp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x33e79
movl $0x8, %edx
movq 0x1e68b(%rip), %rdi     # 0x51fe0
leaq 0xcd32(%rip), %rsi      # 0x4068e
callq 0x74d0
movq 0x1e678(%rip), %rdi     # 0x51fe0
movq 0x18(%rsp), %rsi
callq 0x7350
movq %rax, %rbx
movl $0x22, %edx
movq %rax, %rdi
leaq 0xcd13(%rip), %rsi      # 0x40697
callq 0x74d0
movq %rbx, %rdi
movl 0x300(%rsp), %esi
callq 0x7710
movq %rax, %rbx
movl $0xe, %edx
movq %rax, %rdi
leaq 0xcd10(%rip), %rsi      # 0x406ba
callq 0x74d0
movq %rbx, %rdi
movl 0x2f0(%rsp), %esi
callq 0x7710
jmp 0x33acc
incq 0x2b0(%rbp)
cmpl $0x3, 0x60(%rbp)
jl 0x33e79
movl $0x1d, %edx
movq 0x8(%rsp), %rdi
leaq 0xcc7e(%rip), %rsi      # 0x40663
callq 0x74d0
movq 0x8(%rsp), %rdi
movl 0x2f0(%rsp), %esi
callq 0x7710
movq %rax, %rbx
movl $0x8, %edx
movq %rax, %rdi
leaq 0xcf86(%rip), %rsi      # 0x40993
callq 0x74d0
movq %rbx, %rdi
movl %r12d, %esi
callq 0x7710
movq %rax, %rbx
movl $0xb, %edx
movq %rax, %rdi
leaq 0xd0e6(%rip), %rsi      # 0x40b15
callq 0x74d0
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
callq 0x7710
movq %rax, %rbx
movl $0xc, %edx
movq %rax, %rdi
leaq 0xcc2e(%rip), %rsi      # 0x40681
callq 0x74d0
movq %rbx, %rdi
movl 0x14(%rsp), %esi
callq 0x7710
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
leaq 0xbac0(%rip), %rsi      # 0x3f536
callq 0x74d0
movq %rbx, %rdi
movl 0x38(%rsp), %esi
callq 0x7710
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
leaq 0xa65f(%rip), %rsi      # 0x3e0f8
callq 0x74d0
movl $0xb, %edx
movq %r14, %rdi
leaq 0xcc1d(%rip), %rsi      # 0x406ca
callq 0x74d0
movq 0x28(%rsp), %rsi
shlq $0x4, %rsi
movq 0x68(%rsp), %rax
addq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x3c96c
movl $0x1, %edx
leaq 0xc758(%rip), %rsi      # 0x40230
jmp 0x33e71
incq 0x2a0(%rbp)
incq 0x280(%rbp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x33b83
movl $0x8, %edx
movq 0x1e4da(%rip), %rdi     # 0x51fe0
leaq 0xcb81(%rip), %rsi      # 0x4068e
callq 0x74d0
movq 0x1e4c7(%rip), %rdi     # 0x51fe0
movq 0x18(%rsp), %rsi
callq 0x7350
movq %rax, %rbx
movl $0x22, %edx
movq %rax, %rdi
leaq 0xcb62(%rip), %rsi      # 0x40697
callq 0x74d0
movq %rbx, %rdi
movl 0x300(%rsp), %esi
callq 0x7710
movq %rax, %rbx
movl $0xe, %edx
movq %rax, %rdi
leaq 0xcb5f(%rip), %rsi      # 0x406ba
callq 0x74d0
movq %rbx, %rdi
movl 0x2f0(%rsp), %esi
callq 0x7710
movl $0x1, %edx
movq %rax, %rdi
leaq 0xc6b2(%rip), %rsi      # 0x40230
callq 0x74d0
testq %r12, %r12
je 0x33bf3
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rcx
leaq (%rcx,%r12,8), %rax
leaq (%rcx,%r12,8), %rcx
addq $-0x8, %rcx
jmp 0x33c08
testl %r14d, %r14d
jne 0x33e99
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x80(%rax)
je 0x33e99
cmpl $0x0, 0x64(%rbp)
je 0x33e96
movq 0x20(%rsp), %rax
movq 0x88(%rax), %rdi
movq 0x30(%rsp), %r8
movl $0x1, %r14d
movl %r12d, %esi
movl 0x3c(%rsp), %edx
movl 0x38(%rsp), %ecx
callq 0x25564
jmp 0x33e99
movq 0x18(%rsp), %rax
movslq 0x8(%rax), %rcx
movq 0x40(%rax), %rax
leaq (%rax,%rcx,8), %rcx
addq $-0x10, %rcx
movsd (%rcx), %xmm0
addsd 0x940c(%rip), %xmm0     # 0x3d020
movapd %xmm0, %xmm1
addsd 0xb5b0(%rip), %xmm1     # 0x3f1d0
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x33c41
movq 0x68(%rsp), %rcx
movq 0x40(%rcx), %rdx
leaq (%rdx,%rsi,8), %rcx
leaq (%rdx,%rsi,8), %rdx
addq $-0x8, %rdx
jmp 0x33c56
movq 0x68(%rsp), %rcx
movslq 0x8(%rcx), %rdx
movq 0x40(%rcx), %rcx
leaq (%rcx,%rdx,8), %rdx
addq $-0x10, %rdx
movsd 0x93c2(%rip), %xmm3     # 0x3d020
movapd %xmm3, %xmm2
cmpltsd %xmm0, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
movsd (%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd (%rdx), %xmm0
addsd %xmm3, %xmm0
movapd %xmm0, %xmm1
addsd 0xb53f(%rip), %xmm1     # 0x3f1d0
cmpltsd %xmm0, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
movsd (%rcx), %xmm1
movapd %xmm3, 0xe0(%rsp)
movapd %xmm3, %xmm0
movsd %xmm1, 0x60(%rsp)
movapd %xmm2, 0x1b0(%rsp)
callq 0x31bd5
testb %al, %al
je 0x33d64
movapd 0xe0(%rsp), %xmm0
movsd 0x60(%rsp), %xmm1
movsd 0x40(%rsp), %xmm2
callq 0x31bd5
testb %al, %al
je 0x33d64
movapd 0x1b0(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
movapd 0xe0(%rsp), %xmm2
callq 0x31bd5
testb %al, %al
je 0x33d64
movapd 0x1b0(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
movsd 0x60(%rsp), %xmm2
callq 0x31bd5
testb %al, %al
je 0x33d64
movq 0x28(%rsp), %rsi
shlq $0x4, %rsi
movq 0x68(%rsp), %rax
addq 0x10(%rax), %rsi
movq 0x18(%rsp), %rdi
movl %r12d, %edx
callq 0x2869e
movq %rax, 0x30(%rsp)
incq 0x270(%rbp)
movq %rax, %rdi
callq 0x297a6
jmp 0x33609
cmpl $0x0, 0x64(%rbp)
je 0x33d9a
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x80(%rax)
je 0x33d9a
movq 0x20(%rsp), %rax
movq 0x88(%rax), %rdi
movl %r12d, %esi
movl 0x3c(%rsp), %edx
movl 0x38(%rsp), %ecx
xorl %r8d, %r8d
callq 0x25564
cmpl $0x3, 0x60(%rbp)
jl 0x33e79
movl $0x12, %edx
movq 0x8(%rsp), %rdi
leaq 0xcdd4(%rip), %rsi      # 0x40b89
callq 0x74d0
movq 0x8(%rsp), %rdi
movl 0x2f0(%rsp), %esi
callq 0x7710
movq %rax, %rbx
movl $0x8, %edx
movq %rax, %rdi
leaq 0xcbb6(%rip), %rsi      # 0x40993
callq 0x74d0
movq %rbx, %rdi
movl %r12d, %esi
callq 0x7710
movq %rax, %rbx
movl $0xb, %edx
movq %rax, %rdi
leaq 0xcd16(%rip), %rsi      # 0x40b15
callq 0x74d0
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
callq 0x7710
movq %rax, %rbx
movl $0xc, %edx
movq %rax, %rdi
leaq 0xc85e(%rip), %rsi      # 0x40681
callq 0x74d0
movq %rbx, %rdi
movl 0x14(%rsp), %esi
callq 0x7710
movq %rax, %r14
movl $0xc, %edx
movq %rax, %rdi
leaq 0xc883(%rip), %rsi      # 0x406c9
callq 0x74d0
movq 0x28(%rsp), %rsi
shlq $0x4, %rsi
movq 0x68(%rsp), %rax
addq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x3c96c
movl $0x18, %edx
leaq 0xc865(%rip), %rsi      # 0x406d6
movq %rax, %rdi
callq 0x74d0
incq %r12
movq 0x18(%rsp), %rax
movslq 0x8(%rax), %rax
decq %rax
cmpq %rax, %r12
jl 0x335ac
jmp 0x34b0e
xorl %r14d, %r14d
movq 0x30(%rsp), %rsi
addq $0x10, %rsi
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0x25bd8
leaq 0x210(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movq %rbx, %rdx
callq 0x2598b
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x33ee4
movq 0xb0(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
leaq 0x210(%rsp), %rdi
callq 0x25a4b
movsd %xmm0, 0xe0(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x25ac8
movsd 0xb0(%rsp), %xmm0
movsd 0xb8(%rsp), %xmm1
subsd 0xa0(%rsp), %xmm0
subsd 0xa8(%rsp), %xmm1
mulsd %xmm0, %xmm1
andpd 0xb0f4(%rip), %xmm1     # 0x3f030
mulsd 0x38(%rbp), %xmm1
addsd 0xe0(%rsp), %xmm1
movapd %xmm1, 0x40(%rsp)
movsd %xmm1, 0x100(%rsp)
cmpl $0x2, 0x60(%rbp)
jl 0x3405c
movl $0x9, %edx
movq 0x8(%rsp), %rdi
leaq 0xc957(%rip), %rsi      # 0x408cb
callq 0x74d0
movq 0x8(%rsp), %rdi
movl %r12d, %esi
callq 0x7710
movq %rax, %rbx
movl $0x4, %edx
movq %rax, %rdi
leaq 0xc761(%rip), %rsi      # 0x406f9
callq 0x74d0
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
callq 0x7710
movq %rax, %rbx
movl $0xc, %edx
movq %rax, %rdi
leaq 0xc742(%rip), %rsi      # 0x406fe
callq 0x74d0
movq %rbx, %rdi
movl 0x14(%rsp), %esi
callq 0x7710
movq %rax, %rbx
movl $0xb, %edx
movq %rax, %rdi
leaq 0xc72c(%rip), %rsi      # 0x4070b
callq 0x74d0
movq %rbx, %rdi
movsd 0xe0(%rsp), %xmm0
callq 0x7680
movq %rax, %rbx
movl $0x6, %edx
movq %rax, %rdi
leaq 0xc710(%rip), %rsi      # 0x40717
callq 0x74d0
movq %rbx, %rdi
movapd 0x40(%rsp), %xmm0
callq 0x7680
movq %rax, %rbx
movl $0xd, %edx
movq %rax, %rdi
leaq 0xc6f2(%rip), %rsi      # 0x4071e
callq 0x74d0
movapd 0x40(%rsp), %xmm0
subsd 0xd0(%rsp), %xmm0
movq %rbx, %rdi
callq 0x7680
movl $0x1, %edx
movq %rax, %rdi
leaq 0xc1d9(%rip), %rsi      # 0x40230
callq 0x74d0
leaq 0x108(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x3c91c
leaq 0x180(%rsp), %rdi
movq 0xd8(%rsp), %rsi
callq 0x3c91c
movl $0x18, %edi
callq 0x7430
movq 0x20(%rsp), %rbx
movq %rbx, 0x10(%rax)
movq %rax, %rdi
leaq 0x180(%rsp), %rsi
callq 0x7080
incq 0x190(%rsp)
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x340c0
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x70(%rax), %rdi
testq %rdi, %rdi
je 0x340d4
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rsp), %rax
movups 0xb0(%rax), %xmm0
movups %xmm0, 0x278(%rsp)
movq 0x20(%rsp), %rbx
movq 0x68(%rbx), %rdi
movsd 0x58(%rsp), %xmm0
leaq 0x278(%rsp), %rsi
callq 0x28c08
movq %rax, 0x78(%rbx)
movq %rax, %rdi
callq 0x28f26
movq 0x78(%rbx), %rdi
callq 0x297a6
movq 0x68(%rbx), %rdi
callq 0x26926
movsd %xmm0, 0x60(%rsp)
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rsi
addq $0x10, %rsi
leaq 0x260(%rsp), %rbx
movq %rbx, %rdi
callq 0x25bd8
leaq 0x120(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movq %rbx, %rdx
callq 0x2598b
movq 0x140(%rsp), %rdi
movq 0x150(%rsp), %rsi
movq 0x120(%rsp), %rax
movq %rax, 0x140(%rsp)
movupd 0x128(%rsp), %xmm0
movupd %xmm0, 0x148(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x120(%rsp)
movq $0x0, 0x130(%rsp)
testq %rdi, %rdi
je 0x341b2
subq %rdi, %rsi
callq 0x7440
movq 0x120(%rsp), %rdi
testq %rdi, %rdi
je 0x341cf
movq 0x130(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
movq 0x260(%rsp), %rdi
testq %rdi, %rdi
je 0x341ec
movq 0x270(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
movl $0xc0, %edi
callq 0x7430
movq %rax, %r15
movq %rax, %rdi
leaq 0x140(%rsp), %rsi
callq 0x2658a
movq 0x20(%rsp), %rax
movq %r15, 0x70(%rax)
movq %r15, %rdi
callq 0x2821c
cmpl $0x2, 0x60(%rbp)
jl 0x342d7
leaq 0x108(%rsp), %rax
cmpq %rax, 0x108(%rsp)
je 0x342d7
movapd 0x40(%rsp), %xmm0
ucomisd 0xc0(%rsp), %xmm0
jb 0x342d7
movl $0x1, %edx
movq 0x8(%rsp), %rdi
leaq 0x9d94(%rip), %rsi      # 0x3dff4
callq 0x74d0
movq 0x8(%rsp), %rdi
movl 0x300(%rsp), %esi
callq 0x7710
movq %rax, %rbx
movl $0xf, %edx
movq %rax, %rdi
leaq 0xc4a4(%rip), %rsi      # 0x4072c
callq 0x74d0
movq %rbx, %rdi
movapd 0x40(%rsp), %xmm0
callq 0x7680
movq %rax, %rbx
movl $0x21, %edx
movq %rax, %rdi
leaq 0xc48f(%rip), %rsi      # 0x4073c
callq 0x74d0
movq %rbx, %rdi
movsd 0xc0(%rsp), %xmm0
callq 0x7680
movl $0x2c, %edx
movq %rax, %rdi
leaq 0xc48c(%rip), %rsi      # 0x4075e
callq 0x74d0
cmpl $0x2, 0x60(%rbp)
jl 0x3438e
leaq 0x108(%rsp), %rax
cmpq %rax, 0x108(%rsp)
je 0x3438e
movapd 0x40(%rsp), %xmm0
ucomisd 0x50(%rsp), %xmm0
jb 0x3438e
movl $0x1, %edx
movq 0x8(%rsp), %rdi
leaq 0x9cda(%rip), %rsi      # 0x3dff4
callq 0x74d0
movq 0x8(%rsp), %rdi
movl 0x300(%rsp), %esi
callq 0x7710
movq %rax, %rbx
movl $0xf, %edx
movq %rax, %rdi
leaq 0xc3ea(%rip), %rsi      # 0x4072c
callq 0x74d0
movq %rbx, %rdi
movapd 0x40(%rsp), %xmm0
callq 0x7680
movq %rax, %rbx
movl $0x23, %edx
movq %rax, %rdi
leaq 0xc424(%rip), %rsi      # 0x4078b
callq 0x74d0
movq %rbx, %rdi
movsd 0x50(%rsp), %xmm0
callq 0x7680
movl $0x2c, %edx
movq %rax, %rdi
leaq 0xc3d5(%rip), %rsi      # 0x4075e
callq 0x74d0
leaq 0x108(%rsp), %rax
cmpq %rax, 0x108(%rsp)
je 0x346d8
movsd 0xc0(%rsp), %xmm0
ucomisd 0x40(%rsp), %xmm0
jb 0x346d8
movsd 0x50(%rsp), %xmm0
ucomisd 0x40(%rsp), %xmm0
jb 0x346d8
movsd 0x60(%rsp), %xmm0
addsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
cmpl $0x2, 0x60(%rbp)
jl 0x34534
movl $0x21, %edx
movq 0x8(%rsp), %rdi
leaq 0xc3b4(%rip), %rsi      # 0x407af
callq 0x74d0
movq 0x8(%rsp), %rdi
leaq 0x278(%rsp), %rsi
callq 0x3c96c
movq %rax, %rbx
movl $0xc, %edx
movq %rax, %rdi
leaq 0xc556(%rip), %rsi      # 0x4097a
callq 0x74d0
movq %rbx, %rdi
movl 0x2f0(%rsp), %esi
callq 0x7710
movl $0x1, %edx
movq %rax, %rdi
leaq 0xbde9(%rip), %rsi      # 0x40230
callq 0x74d0
movl $0x10, %edx
movq 0x8(%rsp), %rdi
leaq 0xc374(%rip), %rsi      # 0x407d1
callq 0x74d0
movq 0x78(%rsp), %rsi
subq 0x70(%rsp), %rsi
sarq $0x4, %rsi
movq 0x8(%rsp), %rdi
callq 0x72f0
movq %rax, %r15
movl $0x10, %edx
movq %rax, %rdi
leaq 0xc356(%rip), %rsi      # 0x407e2
callq 0x74d0
leaq 0x70(%rsp), %rdi
callq 0x25a4b
movq %r15, %rdi
callq 0x7680
movq %rax, %rbx
movl $0x14, %edx
movq %rax, %rdi
leaq 0xc33e(%rip), %rsi      # 0x407f3
callq 0x74d0
movq %rbx, %rdi
movsd 0x60(%rsp), %xmm0
callq 0x7680
movl $0x1, %edx
movq %rax, %rdi
leaq 0xbd59(%rip), %rsi      # 0x40230
callq 0x74d0
movl $0x18, %edx
movq 0x8(%rsp), %rdi
leaq 0xc31b(%rip), %rsi      # 0x40808
callq 0x74d0
movq 0x20(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x26926
movq 0x8(%rsp), %rdi
callq 0x7680
movl $0x1, %edx
movq %rax, %rdi
leaq 0xbd17(%rip), %rsi      # 0x40230
callq 0x74d0
movl $0x24, %edx
movq 0x8(%rsp), %rdi
leaq 0xc2f2(%rip), %rsi      # 0x40821
callq 0x74d0
leaq 0x120(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x25ac8
movupd 0x120(%rsp), %xmm0
movupd 0x130(%rsp), %xmm1
movapd %xmm1, 0x250(%rsp)
movapd %xmm0, 0x240(%rsp)
movq 0x20(%rsp), %rax
movq 0x70(%rax), %rbx
leaq 0x198(%rsp), %rdi
leaq 0x180(%rsp), %rsi
callq 0x3c91c
leaq 0x288(%rsp), %r13
movq %r13, %rdi
leaq 0x108(%rsp), %rsi
callq 0x3c91c
subq $0x8, %rsp
movq %rbp, %rdi
movq %rbx, %rsi
leaq 0x1a0(%rsp), %rdx
movq %r13, %rcx
movl 0x98(%rsp), %r8d
movsd 0x180(%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
leaq 0x108(%rsp), %r9
movsd 0x58(%rsp), %xmm2
pushq 0x1f8(%rsp)
movl 0x308(%rsp), %eax
pushq %rax
pushq 0x210(%rsp)
callq 0x32ece
addq $0x20, %rsp
movq %rax, %r15
movq 0x288(%rsp), %rdi
cmpq %r13, %rdi
je 0x3461e
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x7440
movq %rbx, %rdi
cmpq %r13, %rbx
jne 0x34609
movq 0x198(%rsp), %rdi
leaq 0x198(%rsp), %r13
cmpq %r13, %rdi
je 0x34648
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x7440
movq %rbx, %rdi
cmpq %r13, %rbx
jne 0x34633
testq %r15, %r15
jne 0x34664
movsd 0x50(%rsp), %xmm0
addsd 0x89bd(%rip), %xmm0     # 0x3d018
movsd %xmm0, 0x100(%rsp)
movq 0x1e8(%rsp), %rax
movq %rax, %rbp
cmpl $0x2, 0x60(%rax)
jl 0x346d8
movl $0x1b, %edx
movq 0x8(%rsp), %rdi
leaq 0xc1c0(%rip), %rsi      # 0x40846
callq 0x74d0
movq 0x8(%rsp), %rdi
movl 0x300(%rsp), %esi
callq 0x7710
movq %rax, %rbx
movl $0xb, %edx
movq %rax, %rdi
leaq 0xc1b4(%rip), %rsi      # 0x40862
callq 0x74d0
movsd 0x100(%rsp), %xmm0
movq %rbx, %rdi
callq 0x7680
movl $0x1, %edx
movq %rax, %rdi
leaq 0xbb5d(%rip), %rsi      # 0x40230
callq 0x74d0
movsd 0x100(%rsp), %xmm1
movsd 0x50(%rsp), %xmm0
movsd %xmm1, 0x40(%rsp)
ucomisd %xmm1, %xmm0
jbe 0x349e3
movsd 0xd0(%rsp), %xmm0
ucomisd 0x40(%rsp), %xmm0
jbe 0x34720
movl $0x36, %edx
movq 0x1d8cc(%rip), %rdi     # 0x51fe0
leaq 0xc153(%rip), %rsi      # 0x4086e
callq 0x74d0
movq 0x30(%rsp), %rax
movupd 0xb0(%rax), %xmm0
movapd %xmm0, 0x1c0(%rsp)
cmpl $0x2, 0x60(%rbp)
jl 0x349a9
movl $0x1, %edx
movq 0x8(%rsp), %rdi
leaq 0x98a3(%rip), %rsi      # 0x3dff4
callq 0x74d0
movq 0x8(%rsp), %rdi
movl 0x300(%rsp), %esi
callq 0x7710
movq %rax, %rbx
movl $0x21, %edx
movq %rax, %rdi
leaq 0xc12c(%rip), %rsi      # 0x408a5
callq 0x74d0
movq %rbx, %rdi
movl 0x2f0(%rsp), %esi
callq 0x7710
movl $0x1, %edx
movq %rax, %rdi
leaq 0xba94(%rip), %rsi      # 0x40230
callq 0x74d0
movl $0xd, %edx
movq 0x8(%rsp), %rdi
leaq 0xc115(%rip), %rsi      # 0x408c7
callq 0x74d0
movq 0x8(%rsp), %rdi
movl %r12d, %esi
callq 0x7710
movq %rax, %rbx
movl $0xb, %edx
movq %rax, %rdi
leaq 0xc33f(%rip), %rsi      # 0x40b15
callq 0x74d0
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
callq 0x7710
movq %rax, %rbx
movl $0xc, %edx
movq %rax, %rdi
leaq 0xbf04(%rip), %rsi      # 0x406fe
callq 0x74d0
movq %rbx, %rdi
movl 0x14(%rsp), %esi
callq 0x7710
movl $0x1, %edx
movq %rax, %rdi
leaq 0xba16(%rip), %rsi      # 0x40230
callq 0x74d0
movl $0xf, %edx
movq 0x8(%rsp), %rdi
leaq 0xc0a5(%rip), %rsi      # 0x408d5
callq 0x74d0
movq 0x8(%rsp), %rdi
movsd 0x1e0(%rsp), %xmm0
callq 0x7680
movq %rax, %rbx
movl $0xd, %edx
movq %rax, %rdi
leaq 0xc08b(%rip), %rsi      # 0x408e5
callq 0x74d0
movq %rbx, %rdi
leaq 0x1c0(%rsp), %rsi
callq 0x3c96c
movq %rax, %rbx
movl $0x6, %edx
movq %rax, %rdi
leaq 0xc072(%rip), %rsi      # 0x408f3
callq 0x74d0
movq %r12, %rsi
shlq $0x4, %rsi
movq 0x18(%rsp), %rax
addq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x3c96c
movq %rax, %rbx
movl $0x4, %edx
movq %rax, %rdi
leaq 0xb9b4(%rip), %rsi      # 0x40264
callq 0x74d0
movq 0x28(%rsp), %rsi
shlq $0x4, %rsi
movq 0x68(%rsp), %rax
addq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x3c96c
movl $0x1, %edx
movq %rax, %rdi
leaq 0xb952(%rip), %rsi      # 0x40230
callq 0x74d0
movl $0x10, %edx
movq 0x8(%rsp), %rdi
leaq 0xc006(%rip), %rsi      # 0x408fa
callq 0x74d0
movq 0x8(%rsp), %rdi
movsd 0xe0(%rsp), %xmm0
callq 0x7680
movq %rax, %rbx
movl $0x7, %edx
movq %rax, %rdi
leaq 0xbfed(%rip), %rsi      # 0x4090b
callq 0x74d0
movq %rbx, %rdi
movsd 0x40(%rsp), %xmm0
callq 0x7680
movq %rax, %rbx
movl $0xe, %edx
movq %rax, %rdi
leaq 0xbfd0(%rip), %rsi      # 0x40913
callq 0x74d0
movq %rbx, %rdi
movsd 0xd0(%rsp), %xmm0
callq 0x7680
movl $0x1, %edx
movq %rax, %rdi
leaq 0xb8c8(%rip), %rsi      # 0x40230
callq 0x74d0
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0xc8(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x98(%rsp)
movl %r12d, 0x94(%rsp)
movq 0x28(%rsp), %rax
movl %eax, 0x9c(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x349e3
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0xc8(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x98(%rsp)
movl %r12d, 0x94(%rsp)
movq 0x28(%rsp), %rax
movl %eax, 0x9c(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
testl %r14d, %r14d
jne 0x34a94
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x349fc
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x34a94
movl $0x8, %edx
movq 0x1d5c9(%rip), %rdi     # 0x51fe0
leaq 0xbc70(%rip), %rsi      # 0x4068e
callq 0x74d0
movq 0x1d5b6(%rip), %rdi     # 0x51fe0
movq 0x18(%rsp), %rsi
callq 0x7350
movq %rax, %rbx
movl $0x22, %edx
movq %rax, %rdi
leaq 0xbc51(%rip), %rsi      # 0x40697
callq 0x74d0
movq %rbx, %rdi
movl 0x300(%rsp), %esi
callq 0x7710
movq %rax, %rbx
movl $0xe, %edx
movq %rax, %rdi
leaq 0xbc4e(%rip), %rsi      # 0x406ba
callq 0x74d0
movq %rbx, %rdi
movl 0x2f0(%rsp), %esi
callq 0x7710
movl $0x1, %edx
movq %rax, %rdi
leaq 0xb7a1(%rip), %rsi      # 0x40230
callq 0x74d0
movq 0x180(%rsp), %rdi
leaq 0x180(%rsp), %r14
cmpq %r14, %rdi
je 0x34abe
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x7440
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x34aa9
movq 0x108(%rsp), %rdi
leaq 0x108(%rsp), %r14
cmpq %r14, %rdi
je 0x34ae8
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x7440
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x34ad3
movq 0x210(%rsp), %rdi
testq %rdi, %rdi
je 0x33e79
movq 0x220(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
jmp 0x33e79
incl 0x38(%rsp)
movq 0x28(%rsp), %r15
incq %r15
movq 0x68(%rsp), %rax
movslq 0x8(%rax), %rax
decq %rax
cmpq %rax, %r15
movq 0x18(%rsp), %rbx
movq 0x200(%rsp), %r14
jl 0x3358a
incl 0x14(%rsp)
movq (%r14), %r14
cmpq 0xd8(%rsp), %r14
jne 0x33560
movsd 0x58(%rsp), %xmm0
addsd 0x178(%rsp), %xmm0
incl 0x3c(%rsp)
movsd %xmm0, 0x58(%rsp)
movsd 0xa666(%rip), %xmm1     # 0x3f1d8
ucomisd %xmm0, %xmm1
ja 0x3345c
cmpl $0x0, 0x8(%rbx)
movq 0x20(%rsp), %r15
movq 0x1d8(%rsp), %r12
jne 0x34c1c
movq 0x1d446(%rip), %rdi     # 0x51fe0
leaq 0xbaed(%rip), %rsi      # 0x4068e
movl $0x8, %edx
callq 0x74d0
movq 0x1d42e(%rip), %rdi     # 0x51fe0
movq 0x18(%rsp), %rsi
callq 0x7350
movq %rax, %rbx
leaq 0xbad1(%rip), %rsi      # 0x40697
movl $0x22, %edx
movq %rax, %rdi
callq 0x74d0
movq %rbx, %rdi
movl 0x300(%rsp), %esi
callq 0x7710
movq %rax, %rbx
leaq 0xbace(%rip), %rsi      # 0x406ba
movl $0xe, %edx
movq %rax, %rdi
callq 0x74d0
movq %rbx, %rdi
movl 0x2f0(%rsp), %esi
callq 0x7710
leaq 0xb621(%rip), %rsi      # 0x40230
movl $0x1, %edx
movq %rax, %rdi
callq 0x74d0
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
xorpd %xmm0, %xmm0
ucomisd 0xc8(%rsp), %xmm0
jbe 0x34c93
movabsq $0x4a511b0ec57e649a, %rax # imm = 0x4A511B0EC57E649A
movq %rax, (%r12)
xorl %r15d, %r15d
movq 0x140(%rsp), %rdi
testq %rdi, %rdi
je 0x34c64
movq 0x150(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x34c7e
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
movq %r15, %rax
addq $0x2b8, %rsp            # imm = 0x2B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsd 0x50(%rsp), %xmm0
ucomisd 0xc0(%rsp), %xmm0
jbe 0x34d18
movsd %xmm0, (%r12)
cmpl $0x2, 0x60(%rbp)
jl 0x34c47
leaq 0xbc6b(%rip), %rsi      # 0x40922
movl $0x6, %edx
movq 0x8(%rsp), %rdi
callq 0x74d0
movq 0x8(%rsp), %rdi
movl 0x300(%rsp), %esi
callq 0x7710
movq %rax, %rbx
leaq 0xbc48(%rip), %rsi      # 0x40929
movl $0x15, %edx
movq %rax, %rdi
callq 0x74d0
movq %rbx, %rdi
movsd 0xc0(%rsp), %xmm0
callq 0x7680
leaq 0xbc39(%rip), %rsi      # 0x4093f
movl $0x1e, %edx
movq %rax, %rdi
callq 0x74d0
jmp 0x34c47
movq 0x78(%r15), %rdi
testq %rdi, %rdi
je 0x34d27
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x70(%r15), %rdi
testq %rdi, %rdi
je 0x34d36
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x68(%r15), %rdi
leaq 0x1c0(%rsp), %rsi
movsd 0xc8(%rsp), %xmm0
callq 0x28c08
movq %rax, 0x78(%r15)
movq %rax, %rdi
callq 0x28f26
movq 0x78(%r15), %rdi
callq 0x297a6
movq 0x78(%r15), %rdi
callq 0x26926
movsd %xmm0, 0x18(%rsp)
movq 0x78(%r15), %rsi
addq $0x10, %rsi
leaq 0x120(%rsp), %rdi
callq 0x25bd8
leaq 0xa0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x120(%rsp), %rdx
callq 0x2598b
movq 0x70(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0xa0(%rsp), %rax
movq %rax, 0x70(%rsp)
movupd 0xa8(%rsp), %xmm0
movupd %xmm0, 0x78(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0xa0(%rsp)
movq $0x0, 0xb0(%rsp)
testq %rdi, %rdi
je 0x34df2
subq %rdi, %rsi
callq 0x7440
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x34e0f
movq 0xb0(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
movq 0x120(%rsp), %rdi
testq %rdi, %rdi
je 0x34e2c
movq 0x130(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
movl $0xc0, %edi
callq 0x7430
movq %rax, %rbx
leaq 0x70(%rsp), %rsi
movq %rax, %rdi
callq 0x2658a
movq %rbx, 0x70(%r15)
movq %rbx, %rdi
callq 0x2821c
movq 0x70(%r15), %rdi
callq 0x283b4
movsd 0x50(%rsp), %xmm0
movsd %xmm0, (%r12)
cmpl $0x0, 0x60(%rbp)
jle 0x34c47
leaq 0xbaaa(%rip), %rsi      # 0x40922
movl $0x6, %edx
movq 0x8(%rsp), %rdi
callq 0x74d0
movq 0x8(%rsp), %rdi
movl 0x300(%rsp), %esi
callq 0x7710
movq %rax, %rbx
leaq 0xbabc(%rip), %rsi      # 0x4095e
movl $0x17, %edx
movq %rax, %rdi
callq 0x74d0
leaq 0x1c0(%rsp), %rsi
movq %rbx, %rdi
callq 0x3c96c
movq %rax, %rbx
leaq 0xbaad(%rip), %rsi      # 0x40976
movl $0x1, %edx
movq %rax, %rdi
callq 0x74d0
movsd 0xc8(%rsp), %xmm0
mulsd 0xa291(%rip), %xmm0     # 0x3f178
divsd 0x8131(%rip), %xmm0     # 0x3d020
callq 0x71c0
movq %rbx, %rdi
callq 0x7680
movq %rax, %rbx
leaq 0xba72(%rip), %rsi      # 0x40978
movl $0xe, %edx
movq %rax, %rdi
callq 0x74d0
movq %rbx, %rdi
movl 0x2f0(%rsp), %esi
callq 0x7710
movq %rax, %rbx
leaq 0xa60a(%rip), %rsi      # 0x3f536
movl $0x1, %edx
movq %rax, %rdi
callq 0x74d0
leaq 0x90(%r15), %r14
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x74d0
leaq 0xba2a(%rip), %rsi      # 0x40987
movl $0x14, %edx
movq %rbx, %rdi
callq 0x74d0
movq %rbx, %rdi
movl 0x94(%rsp), %esi
callq 0x7710
movq %rax, %rbx
leaq 0xbb92(%rip), %rsi      # 0x40b15
movl $0xb, %edx
movq %rax, %rdi
callq 0x74d0
movq %rbx, %rdi
movl 0x9c(%rsp), %esi
callq 0x7710
movq %rax, %rbx
leaq 0xb755(%rip), %rsi      # 0x406fe
movl $0xc, %edx
movq %rax, %rdi
callq 0x74d0
movq %rbx, %rdi
movl 0x98(%rsp), %esi
callq 0x7710
leaq 0xb264(%rip), %rsi      # 0x40230
movl $0x1, %edx
movq %rax, %rdi
callq 0x74d0
leaq 0xb7f1(%rip), %rsi      # 0x407d1
movl $0x10, %edx
movq 0x8(%rsp), %rdi
callq 0x74d0
movq 0x78(%rsp), %rsi
subq 0x70(%rsp), %rsi
sarq $0x4, %rsi
movq 0x8(%rsp), %rdi
callq 0x72f0
movq %rax, %rbx
leaq 0xb7d1(%rip), %rsi      # 0x407e2
movl $0x10, %edx
movq %rax, %rdi
callq 0x74d0
leaq 0x70(%rsp), %rdi
callq 0x25a4b
movq %rbx, %rdi
callq 0x7680
movq %rax, %rbx
leaq 0xb7b9(%rip), %rsi      # 0x407f3
movl $0x14, %edx
movq %rax, %rdi
callq 0x74d0
movsd 0x18(%rsp), %xmm0
addsd 0xf0(%rsp), %xmm0
movq %rbx, %rdi
callq 0x7680
leaq 0xb1cb(%rip), %rsi      # 0x40230
movl $0x1, %edx
movq %rax, %rdi
callq 0x74d0
leaq 0xb78f(%rip), %rsi      # 0x40808
movl $0x18, %edx
movq 0x8(%rsp), %rdi
callq 0x74d0
movq 0x70(%r15), %rdi
callq 0x26926
movq 0x8(%rsp), %rdi
callq 0x7680
movq %rax, %rbx
leaq 0xb8f7(%rip), %rsi      # 0x4099c
movl $0x7, %edx
movq %rax, %rdi
callq 0x74d0
movsd (%r12), %xmm0
movq %rbx, %rdi
callq 0x7680
leaq 0xb169(%rip), %rsi      # 0x40230
movl $0x1, %edx
movq %rax, %rdi
callq 0x74d0
leaq 0xb8c9(%rip), %rsi      # 0x409a4
movl $0x13, %edx
movq 0x8(%rsp), %rdi
callq 0x74d0
movq 0x88(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rdi
callq 0x72f0
leaq 0xb129(%rip), %rsi      # 0x40230
movl $0x1, %edx
movq %rax, %rdi
callq 0x74d0
movq 0x88(%rsp), %rax
movq (%rax), %r12
cmpq %rax, %r12
je 0x34c47
movl $0x1, %ebx
leaq 0xb8a3(%rip), %rbp      # 0x409d7
leaq 0xb0f5(%rip), %r14      # 0x40230
movq 0x10(%r12), %r13
movl $0x9, %edx
movq 0x8(%rsp), %rdi
leaq 0xb867(%rip), %rsi      # 0x409b8
callq 0x74d0
movq 0x8(%rsp), %rdi
movl %ebx, %esi
callq 0x7710
movq %rax, %r15
movl $0xe, %edx
movq %rax, %rdi
leaq 0xb84e(%rip), %rsi      # 0x409c2
callq 0x74d0
movq 0x78(%r13), %rax
movupd 0xb0(%rax), %xmm0
movupd %xmm0, 0xa0(%rsp)
movq %r15, %rdi
leaq 0xa0(%rsp), %rsi
callq 0x3c96c
movq %rax, %r15
movl $0x5, %edx
movq %rax, %rdi
leaq 0xb821(%rip), %rsi      # 0x409d1
callq 0x74d0
movq 0x78(%r13), %rax
movsd 0xa8(%rax), %xmm0
mulsd 0x9faf(%rip), %xmm0     # 0x3f178
divsd 0x7e4f(%rip), %xmm0     # 0x3d020
callq 0x71c0
movq %r15, %rdi
callq 0x7680
movl $0xb, %edx
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x74d0
movq 0x70(%r13), %rdi
callq 0x26926
movq 0x8(%rsp), %rdi
callq 0x7680
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x74d0
incl %ebx
movq (%r12), %r12
cmpq 0x88(%rsp), %r12
jne 0x3513b
movq 0x20(%rsp), %r15
jmp 0x34c47
movq %rax, %r14
movl $0xc0, %esi
movq %rbx, %rdi
jmp 0x3544a
movq %rax, %r14
movq 0x120(%rsp), %rdi
testq %rdi, %rdi
je 0x35454
movq 0x130(%rsp), %rsi
jmp 0x35447
jmp 0x35451
movq %rax, %r14
movl $0x38, %esi
movq %r15, %rdi
jmp 0x3544a
jmp 0x35451
jmp 0x35451
jmp 0x35451
jmp 0x35451
jmp 0x35451
jmp 0x35451
jmp 0x35451
jmp 0x35451
jmp 0x35451
jmp 0x35451
jmp 0x35451
movq %rax, %r14
movq 0x288(%rsp), %rdi
cmpq %r13, %rdi
je 0x352e0
leaq 0x198(%rsp), %r15
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x7440
movq %rbx, %rdi
cmpq %r13, %rbx
jne 0x352c6
jmp 0x352e8
movq %rax, %r14
leaq 0x198(%rsp), %r15
movq 0x198(%rsp), %rdi
cmpq %r15, %rdi
je 0x353ce
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x7440
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0x352f9
jmp 0x353ce
jmp 0x353cb
jmp 0x353c6
movq %rax, %r14
movq 0x260(%rsp), %rdi
testq %rdi, %rdi
je 0x353ce
movq 0x270(%rsp), %rsi
subq %rdi, %rsi
jmp 0x3535b
jmp 0x353c6
jmp 0x353cb
movq %rax, %r14
jmp 0x35400
movq %rax, %r14
movl $0xc0, %esi
movq %r15, %rdi
callq 0x7440
jmp 0x353ce
jmp 0x353cb
movq %rax, %r14
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x35454
movq 0xb0(%rsp), %rsi
jmp 0x35447
jmp 0x353c6
jmp 0x35451
jmp 0x353cb
movq %rax, %r14
movq 0x228(%rsp), %rdi
cmpq %rbx, %rdi
je 0x35454
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x7440
movq %rbx, %rdi
leaq 0x228(%rsp), %rax
cmpq %rax, %rbx
jne 0x353a2
jmp 0x35454
jmp 0x353cb
movq %rax, %r14
jmp 0x35432
movq %rax, %r14
movq 0x180(%rsp), %rdi
leaq 0x180(%rsp), %rax
cmpq %rax, %rdi
je 0x35400
leaq 0x180(%rsp), %r15
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x7440
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0x353eb
movq 0x108(%rsp), %rdi
leaq 0x108(%rsp), %rax
cmpq %rax, %rdi
je 0x35432
leaq 0x108(%rsp), %r15
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x7440
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0x3541d
movq 0x210(%rsp), %rdi
testq %rdi, %rdi
je 0x35454
movq 0x220(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
jmp 0x35454
movq %rax, %r14
movq 0x140(%rsp), %rdi
testq %rdi, %rdi
je 0x35471
movq 0x150(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x3548b
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
movq %r14, %rdi
callq 0x7730
nop