// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::enlarge(double)
Polygon *Polygon::enlarge(double Diff)
{
int First = 1;
Point OldA2 = Point(0, 0);
Point OldB2 = Point(0, 0);
Segment A2B2 = Segment(OldA2, OldB2);
Line OldLine(1, 1, 0);
Line FirstLine(1, 1, 0);
int newVertices = 0;
double a, b, c;

    //  Then create larger polygon.
    Polygon *LargePoly = new Polygon();

    for ( int i = 0; i < nVertices - 1; i++)
    {
        //  For each segment create a segment which is parallel to the original segment, but translated at distance Diff
        a = _Vertices[i].y - _Vertices[i+1].y;
        b = _Vertices[i+1].x - _Vertices[i].x;
        c = _Vertices[i].x * _Vertices[i+1].y - _Vertices[i+1].x * _Vertices[i].y;
        //  If equation of first segment is ax + by + c = 0, the translated segment has an equation like ax + by + C = 0 where C = c + Diff*sqrt(a*a + b*b)
        //  Here we will first build a segment which begins in A' and end in B' where A' is the point on the line perpendicular to the segment and which starts in A
        double C = c + Diff*sqrt(a*a+b*b);
        Line A1B1 = Line(a, b, C);
        //  Now the lines which are perpendicular in A or B to the segment
        Line AB_perpendicular_A = Line(-b, a, b*_Vertices[i].x - a*_Vertices[i].y);
        Line AB_perpendicular_B = Line(-b, a, b*_Vertices[i+1].x - a*_Vertices[i+1].y);
        // Compute intersection of AB_perpendicular_A and A1B1 (point A1)
        Point A1 = A1B1.Intersect(AB_perpendicular_A);
        Point B1 = A1B1.Intersect(AB_perpendicular_B);
        //  Now enlarge segment to reach A2 which is Diff further from A1 and B2 which is also Diff further from B1
        double distA1B1 = A1.Distance(B1);
        double Coeff = Diff/distA1B1;
        //  Now compute A2 and B2
        //  A2B1 = Coeff*A1B1
        Point A2 = A1 + Coeff*(A1-B1);
        Point B2 = B1 + Coeff*(B1-A1);
        A2B2 = Segment(A2, B2);
        //  Compute intersection between segment A2B2 and Old Segment A2B2 if not processing the first vertice
        if ( !First )
        {
            Point A3 = A1B1.Intersect(OldLine);
            //  If A3 is between A2 and B2, keep segment A3 - B2
            if (A2B2.InSegment(A3) )
            {
                //Change end of previous segment to A3, so change vertice of largePoly
                LargePoly->_Vertices[newVertices-1] = A3;
                //  And add new point B2
                LargePoly->addVertice(B2);
                newVertices = LargePoly->_Vertices.size();
#if DEBUG_CONSOLE > 1
                printf("Changing last point to A3 (%.3f,%.3f) and add one point (%d) B2 : (%.3f,%.3f)\n", A3.x, A3.y, newVertices, B2.x, B2.y);
#endif // DEBUG_CONSOLE
            }
            else
            {
                // Add vertice A2 and B2
                LargePoly->addVertice(A2);
                LargePoly->addVertice(B2);
                newVertices = LargePoly->_Vertices.size();
#if DEBUG_CONSOLE > 1
                printf("Add 2 points (%d and %d) A2 point (%.3f,%.3f) and B2 (%.3f,%.3f)\n", newVertices-1, newVertices, A2.x, A2.y, B2.x, B2.y);
#endif // DEBUG_CONSOLE
            }
        }
        else
        {
            LargePoly->addVertice(A2);
            LargePoly->addVertice(B2);
            newVertices = LargePoly->_Vertices.size();
            FirstLine = A1B1;
            First = 0;
#if DEBUG_CONSOLE > 1
            printf("Add First %d points : (%.3f, %.3f)   (%.3f,%.3f)\n", newVertices, A2.x, A2.y, B2.x, B2.y);
#endif // DEBUG_CONSOLE
        }
        OldA2 = A2;
        OldB2 = B2;
        OldLine = A1B1;
    }
    //  Now change first segment, compute intersection with OldLine
    Point A3;
    if ( OldLine.hasIntersect(&FirstLine, A3 ) )
    {
        //  If A3 is between A2 and B2, keep segment A3 - B2
        if (A2B2.InSegment(A3) )
        {
            //Change end of previous segment to A3, so change vertice of largePoly
            LargePoly->_Vertices[newVertices-1] = A3;
            //  And set First point of Poly to be the same
            LargePoly->_Vertices[0] = A3;
#if DEBUG_CONSOLE > 1
            printf("Changing first/last point (%d) A3 : (%.3f,%.3f)\n", newVertices, A3.x, A3.y);
    #endif // DEBUG_CONSOLE
        }
        else
        {
            // Add vertice between B2 and first point
            LargePoly->addVertice(LargePoly->_Vertices[0]);
            newVertices = LargePoly->_Vertices.size();
    #if DEBUG_CONSOLE > 1
            printf("Add 1 point (%d) (%3.f,%.3f) , closing polygon\n", newVertices, LargePoly->_Vertices[0].x, LargePoly->_Vertices[0].y);
    #endif // DEBUG_CONSOLE
        }
    }
    else
    {       //  No intersection, add point
            // Add vertice between B2 and first point
        LargePoly->addVertice(LargePoly->_Vertices[0]);
        newVertices = LargePoly->_Vertices.size();
#if DEBUG_CONSOLE > 1
        printf("NoIntersect, Add 1 point (%d) (%3.f,%.3f) , closing polygon\n", newVertices, LargePoly->_Vertices[0].x, LargePoly->_Vertices[0].y);
#endif // DEBUG_CONSOLE
    }
    LargePoly->CheckClosed();
    LargePoly->ReCalcBoundingBox();

    //  Now check that all edges of the enlarged polygon dont intersect
    //  If edge I (_Vertice[i] --> _Vertice[i+1]) intersect edge j (_Vertice[j] --> _Vertice[j+1] ) in point Ai with j > i
    //  1) Change _Vertice[i+1] to Ai
    //  2) Delete All vertices from i+2 to j
    //  The resulting polygon will have an edge from _Vertice[i] --> Ai and Ai --> Vertice[j] (with old indexes i and j).
#if DEBUG_CONSOLE > 0
    printf("Large Poly before post processing with %d (%zu) vertices\n", newVertices, LargePoly->_Vertices.size());
    for (int v = 0; v < newVertices; v++)
    {
        printf("Vertex %d : (%.3f,%.3f)\n", v, LargePoly->_Vertices[v].x, LargePoly->_Vertices[v].y);
    }
#endif
    //  After this step, remove vertices which are inside the polygon.
    //  The edges should never intersect
    int modified = true;
    Point Intersection;
    while ( modified )
    {
        modified = false;
        for (int i = 0; i < newVertices - 2; i++)
        {
            Segment AiBi = Segment(LargePoly->_Vertices[i], LargePoly->_Vertices[i+1]);
            for ( int j = i+2; j < newVertices - 1; j++)
            {
                if ( j == newVertices-2 && i == 0 ) break;      //  Do not check this case, last segment will always intersect first one !
                Segment AjBj = Segment(LargePoly->_Vertices[j],LargePoly->_Vertices[j+1]);
                if ( AiBi.isCrossing(&AjBj, &Intersection))
                {
                //  The two segments are crossing
                //  First change Bi to Intersection
#if DEBUG_CONSOLE > 0
                    printf("Intersection detected between segment %d (%.3f,%.3f -- %.3f,%.3f) and segment %d (%.3f,%.3f -- %.3f,%.3f)\n",
                                i, LargePoly->_Vertices[i].x, LargePoly->_Vertices[i].y, LargePoly->_Vertices[i+1].x, LargePoly->_Vertices[i+1].y,
                                j, LargePoly->_Vertices[j].x, LargePoly->_Vertices[j].y, LargePoly->_Vertices[j+1].x, LargePoly->_Vertices[j+1].y);
                    printf("Changing end of segment to intersection point (%.3f,%.3f)\n", Intersection.x, Intersection.y);
#endif
                //  Build 2 polygons, first one contains segments between i+1 (modified to intersection) and j also modified as intersection
                //  The second one contains all other points
                    Polygon *Poly1 = new Polygon;
                    Polygon *Poly2 = new Polygon;
                    for ( int k = 0; k < newVertices; k++)
                    {
                        if ( k < i || k > j )
                        {
                            Poly1->addVertice(LargePoly->_Vertices[k]);
                        }
                        else if ( k == i )
                        {
                            Poly1->addVertice(LargePoly->_Vertices[k]);
                            Poly1->addVertice(Intersection);
                        }
                        else if ( k == i+1 )
                        {
                            Poly2->addVertice(Intersection);
                            Poly2->addVertice(LargePoly->_Vertices[k]);
                        }
                        else if ( k < j )
                        {
                            Poly2->addVertice(LargePoly->_Vertices[k]);
                        }
                        else
                        {
                            Poly2->addVertice(LargePoly->_Vertices[k]);
                            Poly2->addVertice(Intersection);
                        }
                    }
                    //  Keep the largest one
                    double area1 = fabs(Poly1->area());
                    double area2 = fabs(Poly2->area());
                    if ( area1 > area2 )
                    {
#if DEBUG_CONSOLE > 0
                        printf("Area1 = %.3f, Area2 = %.3f, keep polygon1", area1, area2);
#endif
                        delete Poly2;
                        delete LargePoly;
                        LargePoly = Poly1;
                    }
                    else
                    {
#if DEBUG_CONSOLE > 0
                        printf("Area1 = %.3f, Area2 = %.3f, keep polygon2", area1, area2);
#endif
                        delete Poly1;
                        delete LargePoly;
                        LargePoly = Poly2;
                    }
                    newVertices = LargePoly->_Vertices.size();
                    modified = true;
                    break;
                }
            }
            if ( modified ) break;
        }

    }
    for (int i = 0; i < newVertices; i++)
    {
        if ( isInPoly(&LargePoly->_Vertices[i]) > 0 || distance(LargePoly->_Vertices[i]) < Diff - precision )
        {
            // Inside poly or too close, delete vertex
            LargePoly->delVertex(i);
            newVertices = LargePoly->nVertices;
        }
    }

    LargePoly->CheckClosed();
    LargePoly->ReCalcArea();
#if DEBUG_CONSOLE > 0
    Rectangle BBox = LargePoly->GetBoundingBox();
    printf("After postprocessing, %d vertices, area = %.3f, Bounding box (%.3f,%.3f) - (%.3f,%.3f), closed = %d\n",
        LargePoly->nVertices, LargePoly->area(), BBox.A.x, BBox.A.y, BBox.B.x, BBox.B.y, LargePoly->isClosed());
#endif
    return(LargePoly);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movsd %xmm0, 0x20(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x120(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x110(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x138(%rsp), %rdi
callq 0x24340
movapd 0x13a32(%rip), %xmm0    # 0x360d0
leaq 0xd0(%rsp), %rax
movapd %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movapd %xmm0, 0xb0(%rsp)
andq $0x0, 0xc0(%rsp)
movl $0xc0, %edi
callq 0x8440
movq %rax, (%rsp)
movq %rax, %rdi
callq 0x21f2c
xorl %edi, %edi
leaq 0xf0(%rsp), %r15
xorl %edx, %edx
xorl %ecx, %ecx
xorl %ebp, %ebp
movq %rbx, 0x18(%rsp)
movslq 0x8(%rbx), %rax
decq %rax
movslq %ecx, %r12
cmpq %rax, %rdx
jge 0x229ce
movq %rdx, 0x8(%rsp)
movq 0x10(%rbx), %rax
movsd 0x18(%rax,%rdi), %xmm0
movsd (%rax,%rdi), %xmm2
movq %rdi, 0x10(%rsp)
movupd 0x8(%rax,%rdi), %xmm4
movapd %xmm0, %xmm3
unpcklpd %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0]
movapd %xmm4, %xmm1
subpd %xmm3, %xmm1
movapd %xmm4, %xmm3
unpckhpd %xmm4, %xmm3            # xmm3 = xmm3[1],xmm4[1]
movapd %xmm4, %xmm5
mulsd %xmm3, %xmm5
movapd %xmm2, %xmm6
mulsd %xmm0, %xmm6
subsd %xmm5, %xmm6
movapd %xmm1, %xmm5
unpckhpd %xmm1, %xmm5            # xmm5 = xmm5[1],xmm1[1]
movapd %xmm5, %xmm7
mulsd %xmm5, %xmm7
movapd %xmm1, %xmm8
mulsd %xmm1, %xmm8
addsd %xmm7, %xmm8
sqrtsd %xmm8, %xmm7
mulsd 0x20(%rsp), %xmm7
addsd %xmm6, %xmm7
movapd %xmm1, 0x190(%rsp)
movsd %xmm7, 0x1a0(%rsp)
movapd %xmm5, %xmm6
xorpd 0x1392a(%rip), %xmm6    # 0x360c0
mulsd %xmm1, %xmm4
mulsd %xmm5, %xmm2
subsd %xmm4, %xmm2
unpcklpd %xmm1, %xmm6            # xmm6 = xmm6[0],xmm1[0]
movupd %xmm6, 0x50(%rsp)
movsd %xmm2, 0x60(%rsp)
mulsd %xmm0, %xmm1
mulsd %xmm3, %xmm5
subsd %xmm1, %xmm5
movupd %xmm6, 0x30(%rsp)
movsd %xmm5, 0x40(%rsp)
leaq 0x190(%rsp), %rbx
movq %rbx, %rdi
leaq 0x50(%rsp), %rsi
callq 0x24434
movapd %xmm0, 0x90(%rsp)
movapd %xmm1, 0x80(%rsp)
movq %rbx, %rdi
leaq 0x30(%rsp), %rsi
callq 0x24434
movapd 0x90(%rsp), %xmm2
unpcklpd 0x80(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movapd %xmm2, %xmm1
movapd %xmm2, %xmm4
subpd %xmm0, %xmm1
movapd %xmm1, %xmm2
mulpd %xmm1, %xmm2
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
sqrtsd %xmm3, %xmm2
movsd 0x20(%rsp), %xmm3
divsd %xmm2, %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm3, %xmm1
addpd %xmm4, %xmm1
movapd %xmm1, 0xf0(%rsp)
movapd %xmm0, %xmm1
subpd %xmm4, %xmm1
mulpd %xmm3, %xmm1
addpd %xmm0, %xmm1
movapd %xmm1, 0x70(%rsp)
leaq 0x1f0(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
leaq 0x70(%rsp), %r14
movq %r14, %rdx
callq 0x24340
pushq $0xb
popq %rcx
leaq 0x138(%rsp), %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
testb $0x1, %bpl
je 0x22907
movq %rbx, %rdi
leaq 0xd0(%rsp), %rsi
callq 0x24434
movsd 0x170(%rsp), %xmm2
ucomisd %xmm0, %xmm2
movq (%rsp), %rbx
ja 0x2294d
ucomisd 0x178(%rsp), %xmm0
ja 0x2294d
movsd 0x180(%rsp), %xmm2
ucomisd %xmm1, %xmm2
ja 0x2294d
ucomisd 0x188(%rsp), %xmm1
ja 0x2294d
movq 0x10(%rbx), %rax
shlq $0x4, %r12
movsd %xmm0, -0x10(%rax,%r12)
movsd %xmm1, -0x8(%rax,%r12)
jmp 0x22958
movq (%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22084
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22084
movq 0x18(%rbx), %rcx
subq 0x10(%rbx), %rcx
movq 0x1a0(%rsp), %rax
movq %rax, 0xc0(%rsp)
movapd 0x190(%rsp), %xmm0
movapd %xmm0, 0xb0(%rsp)
jmp 0x2296d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22084
movq %rbx, %rdi
leaq 0x70(%rsp), %rsi
callq 0x22084
movq 0x18(%rbx), %rcx
subq 0x10(%rbx), %rcx
movq 0x18(%rsp), %rbx
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rdi
shrq $0x4, %rcx
movaps 0xf0(%rsp), %xmm0
movaps %xmm0, 0x120(%rsp)
movaps 0x70(%rsp), %xmm0
movaps %xmm0, 0x110(%rsp)
movapd 0x190(%rsp), %xmm0
movapd %xmm0, 0xd0(%rsp)
movq 0x1a0(%rsp), %rax
movq %rax, 0xe0(%rsp)
addq $0x10, %rdi
incq %rdx
movb $0x1, %bpl
jmp 0x226ec
movq %rcx, %rbx
xorpd %xmm0, %xmm0
leaq 0x50(%rsp), %rdx
movapd %xmm0, (%rdx)
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x2451e
testb %al, %al
je 0x22a5e
movsd 0x50(%rsp), %xmm0
movsd 0x170(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq (%rsp), %r14
ja 0x22a62
ucomisd 0x178(%rsp), %xmm0
ja 0x22a62
movsd 0x58(%rsp), %xmm0
movsd 0x180(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x22a62
ucomisd 0x188(%rsp), %xmm0
ja 0x22a62
movq 0x10(%r14), %rax
shlq $0x4, %r12
movaps 0x50(%rsp), %xmm0
movups %xmm0, -0x10(%rax,%r12)
movq 0x10(%r14), %rax
movapd 0x50(%rsp), %xmm0
movupd %xmm0, (%rax)
jmp 0x22a7a
movq (%rsp), %r14
movq 0x10(%r14), %rsi
movq %r14, %rdi
callq 0x22084
movq 0x18(%r14), %rbx
subq 0x10(%r14), %rbx
shrq $0x4, %rbx
movq %r14, %rdi
callq 0x245a0
movq %r14, %rdi
callq 0x22da8
xorpd %xmm0, %xmm0
leaq 0x30(%rsp), %rax
movapd %xmm0, (%rax)
pushq $0x1
popq %r12
testl %r12d, %r12d
je 0x22d1a
movq $0x0, 0x10(%rsp)
pushq $0x2
popq %rbp
movq 0x10(%rsp), %r15
leal -0x2(%rbx), %eax
cltq
cmpq %rax, %r15
jge 0x22d12
movq 0x10(%r14), %rdx
movq %r15, %rax
shlq $0x4, %rax
movq %rax, 0x90(%rsp)
leaq (%rdx,%rax), %rsi
leaq 0x1(%r15), %rcx
movq %rcx, 0x10(%rsp)
shlq $0x4, %rcx
movq %rcx, 0x80(%rsp)
addq %rcx, %rdx
leaq 0x1f0(%rsp), %rdi
callq 0x24340
xorl %r12d, %r12d
movq %rbp, 0xa0(%rsp)
leal -0x1(%rbx), %eax
cltq
cmpq %rax, %rbp
jge 0x22cf9
testq %r15, %r15
jne 0x22b29
leal -0x2(%rbx), %eax
cmpq %rax, %rbp
je 0x22cf9
movq 0x10(%r14), %rax
movq %rbp, %rsi
shlq $0x4, %rsi
addq %rax, %rsi
leaq 0x1(%rbp), %rdx
movq %rdx, 0xa8(%rsp)
shlq $0x4, %rdx
addq %rax, %rdx
leaq 0x190(%rsp), %r13
movq %r13, %rdi
callq 0x24340
leaq 0x1f0(%rsp), %rdi
movq %r13, %rsi
leaq 0x30(%rsp), %rdx
xorl %ecx, %ecx
callq 0x245de
testl %eax, %eax
je 0x22ce9
movl %eax, 0x2c(%rsp)
movq %r14, (%rsp)
movl $0xc0, %edi
callq 0x8440
movq %rax, %r12
movq %rax, %rdi
callq 0x21f2c
movl $0xc0, %edi
callq 0x8440
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x21f2c
testl %ebx, %ebx
movl $0x0, %eax
cmovlel %eax, %ebx
movq %rbx, %r13
xorl %ebx, %ebx
cmpq %r13, %rbx
je 0x22c74
cmpq %r15, %rbx
setae %al
cmpq %rbp, %rbx
setbe %cl
testb %cl, %al
jne 0x22be9
movq %rbx, %rsi
shlq $0x4, %rsi
movq (%rsp), %rax
addq 0x10(%rax), %rsi
movq %r12, %rdi
jmp 0x22c42
cmpq %r15, %rbx
jne 0x22c10
movq (%rsp), %rax
movq 0x10(%rax), %rsi
addq 0x90(%rsp), %rsi
movq %r12, %rdi
callq 0x22084
movq %r12, %rdi
leaq 0x30(%rsp), %rsi
jmp 0x22c42
cmpq 0x10(%rsp), %rbx
jne 0x22c4f
movq %r15, %r14
movq 0x8(%rsp), %r15
movq %r15, %rdi
leaq 0x30(%rsp), %rsi
callq 0x22084
movq (%rsp), %rax
movq 0x10(%rax), %rsi
addq 0x80(%rsp), %rsi
movq %r15, %rdi
movq %r14, %r15
callq 0x22084
incq %rbx
jmp 0x22bbc
movq %rbx, %rsi
shlq $0x4, %rsi
movq (%rsp), %rax
addq 0x10(%rax), %rsi
movq 0x8(%rsp), %rdi
callq 0x22084
cmpq %rbp, %rbx
jb 0x22c47
movq 0x8(%rsp), %rdi
jmp 0x22c09
movq %r12, %rdi
callq 0x22296
movapd %xmm0, %xmm1
movapd 0x133a8(%rip), %xmm0    # 0x36030
andpd %xmm0, %xmm1
movapd %xmm1, 0x100(%rsp)
movq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x22296
andpd 0x13386(%rip), %xmm0    # 0x36030
movapd 0x100(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq %r12, %rdi
cmovaq %r13, %rdi
cmovaq %r12, %r13
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%r13), %rbx
subq 0x10(%r13), %rbx
shrq $0x4, %rbx
pushq $0x1
popq %r12
movq %r13, %r14
movl 0x2c(%rsp), %eax
movq 0xa8(%rsp), %rbp
testl %eax, %eax
je 0x22b0a
movq 0xa0(%rsp), %rbp
incq %rbp
testl %r12d, %r12d
je 0x22ab0
jmp 0x22a9b
xorl %r12d, %r12d
jmp 0x22a9b
movq %rbx, %rbp
movq %r14, %r13
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0x18(%rsp), %r12
movslq %ebp, %rax
cmpq %rax, %r14
jge 0x22d83
movq 0x10(%r13), %r15
addq %rbx, %r15
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x22e40
testl %eax, %eax
jg 0x22d6b
movq %r12, %rdi
movq %r15, %rsi
callq 0x2232e
movsd 0x20(%rsp), %xmm1
subsd 0xa0(%r12), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x22d7a
movq %r13, %rdi
movl %r14d, %esi
callq 0x2324a
movl 0x8(%r13), %ebp
incq %r14
addq $0x10, %rbx
jmp 0x22d2a
movq %r13, %rdi
callq 0x245a0
movq %r13, %rdi
callq 0x2328a
movq %r13, %rax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq