LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::GetBoundingBox()
Rectangle Polygon::GetBoundingBox()
{
Rectangle Ret;

    Ret.A.x = BoundingBox.A.x - precision/3;      //    Avoid rounding errors, enlarge slightly bounding box
    Ret.A.y = BoundingBox.A.y - precision/3;      //    Avoid rounding errors, enlarge slightly bounding box
    Ret.B.x = BoundingBox.B.x + precision/3;      //    Avoid rounding errors, enlarge slightly bounding box
    Ret.B.y = BoundingBox.B.y + precision/3;      //    Avoid rounding errors, enlarge slightly bounding box
    return Ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x5b4e0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x58(%rcx), %xmm0
movsd 0xa0(%rcx), %xmm1
movsd 0x22d9b(%rip), %xmm2    # 0x84100
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd 0x60(%rcx), %xmm0
movsd 0xa0(%rcx), %xmm1
movsd 0x22d7a(%rip), %xmm2    # 0x84100
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x68(%rcx), %xmm0
movsd 0xa0(%rcx), %xmm1
movsd 0x22d58(%rip), %xmm2    # 0x84100
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x70(%rcx), %xmm0
movsd 0xa0(%rcx), %xmm1
movsd 0x22d36(%rip), %xmm2    # 0x84100
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::ConvexHull()
Polygon * Polygon::ConvexHull()
{
Polygon *Hull = new Polygon;

    Hull->_Vertices = makeConvexHull(_Vertices);
    Hull->nVertices = Hull->_Vertices.size();
    Hull->CheckClosed();
    if ( Hull->poly_closed == 0 )
    {
        //  Not closed, close it
        Hull->addVertice(Hull->_Vertices[0]);
    }
    Hull->ReCalcBoundingBox();
    Hull->ReCalcArea();
    return Hull;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0xc0, %edi
callq 0x9550
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x5e600
jmp 0x614cf
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
addq $0x10, %rsi
leaq -0x38(%rbp), %rdi
callq 0x5a850
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq -0x38(%rbp), %rsi
callq 0x64270
leaq -0x38(%rbp), %rdi
callq 0x5b3f0
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x5add0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x64020
movq -0x10(%rbp), %rax
cmpl $0x0, 0x98(%rax)
jne 0x61571
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x63990
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x5e960
jmp 0x61571
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0xc0, %esi
callq 0x9560
jmp 0x6158d
movq -0x10(%rbp), %rdi
callq 0x60860
movq -0x10(%rbp), %rdi
callq 0x612f0
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x9960
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::ComputeAngles()
void Polygon::ComputeAngles()
{
    _Angles.resize(nVertices, 0.0);
    for ( int i = 0; i < nVertices-1; i++)
    {
        double a = atan2(_Vertices[i+1].y - _Vertices[i].y, _Vertices[i+1].x - _Vertices[i].x );
        //  Beware of rounding errors
//        _Angles[i] = round(a/angle_precision)*angle_precision;
        _Angles[i] = a;
    }
    //  Last value is not defined as Pt n-1 = Pt 0
    _Angles[nVertices-1] = 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rdi
addq $0x40, %rdi
movslq 0x8(%rax), %rsi
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x10(%rbp), %rdx
callq 0x64740
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x62a36
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x63990
movq -0x28(%rbp), %rdi
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0x63990
movsd -0x48(%rbp), %xmm0
movq -0x28(%rbp), %rdi
subsd 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0x10, %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x63990
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0x63990
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
subsd (%rax), %xmm1
callq 0x90b0
movq -0x28(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0x40, %rdi
movslq -0x14(%rbp), %rsi
callq 0x647f0
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x62967
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x40, %rdi
movl 0x8(%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x647f0
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::Poly_in_Poly(Polygon*)
int Polygon::Poly_in_Poly(Polygon *Big)
{
    //  First check bounding box, this will save time in most cases.
    if ( BoundingBox.A.x < Big->BoundingBox.A.x ) return false;     //  Impossible, bounding box not included
    if ( BoundingBox.A.y < Big->BoundingBox.A.y ) return false;     //  Impossible, bounding box not included
    if ( BoundingBox.B.x > Big->BoundingBox.B.x ) return false;     //  Impossible, bounding box not included
    if ( BoundingBox.B.y > Big->BoundingBox.B.y ) return false;     //  Impossible, bounding box not included
    //  True algoritm, check all vertices
    for ( int i = 0; i < nVertices; i++)
    {
        if ( ! (Big->isInPoly(&_Vertices[i]) > 0) )
            return false;           //  Vertex i is not in Big, not included !
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd 0x58(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x58(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x62f68
movl $0x0, -0x4(%rbp)
jmp 0x63024
movq -0x28(%rbp), %rax
movsd 0x60(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x60(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x62f8c
movl $0x0, -0x4(%rbp)
jmp 0x63024
movq -0x28(%rbp), %rax
movsd 0x68(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x68(%rax), %xmm0
jbe 0x62fa9
movl $0x0, -0x4(%rbp)
jmp 0x63024
movq -0x28(%rbp), %rax
movsd 0x70(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x70(%rax), %xmm0
jbe 0x62fc6
movl $0x0, -0x4(%rbp)
jmp 0x63024
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x6301d
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x63990
movq -0x30(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x60a10
cmpl $0x0, %eax
jg 0x63010
movl $0x0, -0x4(%rbp)
jmp 0x63024
jmp 0x63012
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x62fcd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/include/Geometry.h
// Function: Segment::Segment(Point&, Point&)
Segment(Point &A, Point &B)
        {
            xA = A.x;
            xB = B.x;
            yA = A.y;
            yB = B.y;
            xm = fmin(xA, xB) - my_Default_Precision;
            xM = fmax(xA, xB) + my_Default_Precision;
            ym = fmin(yA, yB) - my_Default_Precision;
            yM = fmax(yA, yB) + my_Default_Precision;
            a = A.y - B.y;
            b = B.x - A.x;
            c = A.x * B.y - B.x * A.y;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x650c0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x28(%rax)
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x30(%rax)
movsd 0x18(%rax), %xmm3
movsd 0x20(%rax), %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordsd %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
minsd %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movsd 0x2069d(%rip), %xmm1    # 0x840d8
subsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rax)
movsd 0x18(%rax), %xmm3
movsd 0x20(%rax), %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordsd %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
maxsd %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movsd 0x20664(%rip), %xmm1    # 0x840d8
addsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rax)
movsd 0x28(%rax), %xmm3
movsd 0x30(%rax), %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordsd %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
minsd %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movsd 0x2062b(%rip), %xmm1    # 0x840d8
subsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rax)
movsd 0x28(%rax), %xmm3
movsd 0x30(%rax), %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordsd %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
maxsd %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movsd 0x205f2(%rip), %xmm1    # 0x840d8
addsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movq -0x18(%rbp), %rcx
subsd 0x8(%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
movq -0x10(%rbp), %rcx
subsd (%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm2
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm1
movq -0x10(%rbp), %rcx
mulsd 0x8(%rcx), %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/Geometry.h
// Function: Line::Intersect(Line const&) const
inline Point Intersect(const Line &Line2) const
        {
            double det = Line2.a * b - a*Line2.b;
            if ( fabs(det) < my_Default_Precision )       //  Line are parallel
            {
                return(Point(nan(""), nan("")));
            }
            return(Point((Line2.b*c - Line2.c*b)/det, (a*Line2.c - Line2.a*c)/det));
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movsd (%rcx), %xmm0
movsd 0x8(%rax), %xmm2
movsd (%rax), %xmm1
movq -0x20(%rbp), %rax
mulsd 0x8(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movaps 0x2049e(%rip), %xmm0    # 0x840b0
pand %xmm0, %xmm1
movsd 0x204ba(%rip), %xmm0    # 0x840d8
ucomisd %xmm1, %xmm0
jbe 0x63c57
leaq 0x21691(%rip), %rdi     # 0x852bc
callq 0x90d0
movsd %xmm0, -0x38(%rbp)
leaq 0x21680(%rip), %rdi     # 0x852bc
callq 0x90d0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
leaq -0x10(%rbp), %rdi
callq 0x5b520
jmp 0x63ce2
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd 0x10(%rax), %xmm2
movq -0x20(%rbp), %rcx
movsd 0x10(%rcx), %xmm1
mulsd 0x8(%rax), %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x28(%rbp), %xmm0
movsd (%rax), %xmm1
movq -0x20(%rbp), %rcx
movsd 0x10(%rcx), %xmm3
movq -0x20(%rbp), %rcx
movsd (%rcx), %xmm2
mulsd 0x10(%rax), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd -0x28(%rbp), %xmm1
leaq -0x10(%rbp), %rdi
callq 0x5b520
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: thierry7100[P]CutOptim/include/Geometry.h
// Function: Segment::InSegment(Point&) const
inline int InSegment(Point &p) const
        {
            if ( p.x < xm ) return 0;     //  Impossible lower than xmin
            if ( p.x > xM ) return 0;     //  Impossible greater than xmax
            if ( p.y < ym) return 0;     //  Impossible lower than ymin
            if ( p.y > yM ) return 0;     //  Impossible greater than ymax
            return(1);      //  OK
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm1
movsd 0x38(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x63e80
movl $0x0, -0x4(%rbp)
jmp 0x63ee1
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
ucomisd 0x40(%rax), %xmm0
jbe 0x63e9c
movl $0x0, -0x4(%rbp)
jmp 0x63ee1
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
movsd 0x48(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x63ebd
movl $0x0, -0x4(%rbp)
jmp 0x63ee1
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
ucomisd 0x50(%rax), %xmm0
jbe 0x63eda
movl $0x0, -0x4(%rbp)
jmp 0x63ee1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/Geometry.h
// Function: Line::hasIntersect(Line const*, Point&) const
inline bool hasIntersect(const Line *Line2, Point &ResIntersect) const
        {
            double det = Line2->a * b - a*Line2->b;
            if ( fabs(det) < my_Default_Precision )       //  Line are parallel
            {
                return(0);          //  Parallel lines, no intersection
            }
            ResIntersect = Point((Line2->b*c - Line2->c*b)/det, (a*Line2->c - Line2->a*c)/det);
            return 1;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
movsd 0x8(%rax), %xmm2
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
mulsd 0x8(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movaps 0x2015a(%rip), %xmm0    # 0x840b0
pand %xmm0, %xmm1
movsd 0x20176(%rip), %xmm0    # 0x840d8
ucomisd %xmm1, %xmm0
jbe 0x63f71
movb $0x0, -0x1(%rbp)
jmp 0x64013
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd 0x10(%rax), %xmm2
movq -0x18(%rbp), %rcx
movsd 0x10(%rcx), %xmm1
mulsd 0x8(%rax), %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd -0x28(%rbp), %xmm0
movsd (%rax), %xmm1
movq -0x18(%rbp), %rcx
movsd 0x10(%rcx), %xmm3
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm2
mulsd 0x10(%rax), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd -0x28(%rbp), %xmm1
leaq -0x38(%rbp), %rdi
callq 0x5b520
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: thierry7100[P]CutOptim/include/Geometry.h
// Function: Segment::isCrossing(Segment const*, Point*, bool*)
inline int isCrossing(const Segment *s1, Point *ResIntersect, bool *IncludedSegment=nullptr)
        {
            Point Ai;
            if ( IncludedSegment != nullptr ) *IncludedSegment = false;     //  Set default answer
            if ( !hasIntersect(s1, Ai) )
            {
                //  Check if same segment (same line...)
                if ( IncludedSegment != nullptr && fabs(s1->a - a) < my_Default_Precision && fabs(s1->b - b) < my_Default_Precision && fabs(s1->c - c) < my_Default_Precision )
                    *IncludedSegment = true;
                return 0;     // No intersection,
            }
            if ( ResIntersect != NULL) *ResIntersect = Ai;
            return InSegment(Ai) && s1->InSegment(Ai);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
cmpq $0x0, -0x28(%rbp)
je 0x640ed
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x63ef0
testb $0x1, %al
jne 0x641a0
cmpq $0x0, -0x28(%rbp)
je 0x64197
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm1
subsd (%rax), %xmm1
movaps 0x1ff88(%rip), %xmm0    # 0x840b0
pand %xmm0, %xmm1
movsd 0x1ffa4(%rip), %xmm0    # 0x840d8
ucomisd %xmm1, %xmm0
jbe 0x64197
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
subsd 0x8(%rax), %xmm1
movaps 0x1ff5d(%rip), %xmm0    # 0x840b0
pand %xmm0, %xmm1
movsd 0x1ff79(%rip), %xmm0    # 0x840d8
ucomisd %xmm1, %xmm0
jbe 0x64197
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x10(%rcx), %xmm1
subsd 0x10(%rax), %xmm1
movaps 0x1ff32(%rip), %xmm0    # 0x840b0
pand %xmm0, %xmm1
movsd 0x1ff4e(%rip), %xmm0    # 0x840d8
ucomisd %xmm1, %xmm0
jbe 0x64197
movq -0x28(%rbp), %rax
movb $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x641f4
cmpq $0x0, -0x20(%rbp)
je 0x641ba
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x63e50
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
je 0x641e9
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x63e50
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/include/Geometry.h
// Function: Segment::isCrossingNoEnd(Segment const*, Point*, bool*) const
inline int isCrossingNoEnd(const Segment *s1, Point *ResIntersect, bool *IncludedSegment=nullptr) const
        {
            Point Ai;
            if ( IncludedSegment != nullptr ) *IncludedSegment = false;     //  Set default answer
            if ( !hasIntersect(s1, Ai) )
            {
                //  Check if same segment (same line...), that is A point of this is on s1
                if ( IncludedSegment != nullptr && fabs(s1->a*xA + s1->b*yA  + s1->c) < my_Default_Precision )
                    *IncludedSegment = true;
                return 0;     // No intersection,
            }
            if ( ResIntersect != NULL) *ResIntersect = Ai;
            return InSegmentNoEnd(Ai) && s1->InSegmentNoEnd(Ai);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
cmpq $0x0, -0x28(%rbp)
je 0x6486d
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x63ef0
testb $0x1, %al
jne 0x648e2
cmpq $0x0, -0x28(%rbp)
je 0x648d9
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm1
movsd 0x18(%rax), %xmm2
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
mulsd 0x28(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x18(%rbp), %rax
addsd 0x10(%rax), %xmm1
movaps 0x1f7f0(%rip), %xmm0    # 0x840b0
pand %xmm0, %xmm1
movsd 0x1f80c(%rip), %xmm0    # 0x840d8
ucomisd %xmm1, %xmm0
jbe 0x648d9
movq -0x28(%rbp), %rax
movb $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x64936
cmpq $0x0, -0x20(%rbp)
je 0x648fc
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x649c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
je 0x6492b
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x649c0
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: thierry7100[P]CutOptim/include/Geometry.h
// Function: Segment::InSegmentNoEnd(Point&) const
inline int InSegmentNoEnd(Point &p) const
        {
            if ( p.x < xm ) return 0;     //  Impossible lower than xmin
            if ( p.x > xM ) return 0;     //  Impossible greater than xmax
            if ( p.y < ym) return 0;     //  Impossible lower than ymin
            if ( p.y > yM ) return 0;     //  Impossible greater than ymax
            //  Now checks if p is an end of the segment
            double d1 = fabs(p.x - xA) + fabs(p.y - yA);
            if ( d1 < 2*my_Default_Precision) return 0;                       //  End of segment return 0
            double d2 = fabs(p.x - xB) + fabs(p.y - yB);
            if ( d2 < 2*my_Default_Precision) return 0;                       //  End of segment return 0
            return(1);      //  OK
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm1
movsd 0x38(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x649f3
movl $0x0, -0x4(%rbp)
jmp 0x64b09
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
ucomisd 0x40(%rax), %xmm0
jbe 0x64a12
movl $0x0, -0x4(%rbp)
jmp 0x64b09
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
movsd 0x48(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x64a36
movl $0x0, -0x4(%rbp)
jmp 0x64b09
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
ucomisd 0x50(%rax), %xmm0
jbe 0x64a56
movl $0x0, -0x4(%rbp)
jmp 0x64b09
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
subsd 0x18(%rax), %xmm0
movaps 0x1f642(%rip), %xmm1    # 0x840b0
pand %xmm1, %xmm0
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
subsd 0x28(%rax), %xmm1
movaps 0x1f629(%rip), %xmm2    # 0x840b0
pand %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x1f684(%rip), %xmm0    # 0x84120
ucomisd -0x20(%rbp), %xmm0
jbe 0x64aac
movl $0x0, -0x4(%rbp)
jmp 0x64b09
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
subsd 0x20(%rax), %xmm0
movaps 0x1f5ec(%rip), %xmm1    # 0x840b0
pand %xmm1, %xmm0
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
subsd 0x30(%rax), %xmm1
movaps 0x1f5d3(%rip), %xmm2    # 0x840b0
pand %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x1f62e(%rip), %xmm0    # 0x84120
ucomisd -0x28(%rbp), %xmm0
jbe 0x64b02
movl $0x0, -0x4(%rbp)
jmp 0x64b09
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: thierry7100[P]CutOptim/include/Geometry.h
// Function: Segment::sqrDistancePoint(Point const&) const
inline double sqrDistancePoint(const Point &p) const
        {
            //  If dot product AB.AC si < 0 return distance(A, C)
            //  Indeed, if this is the case C is in the half plane which is outer segment
            if ( (xB - xA)*(p.x - xA) + (yB-yA)*(p.y-yA) < 0 )
                return( (p.x - xA)*(p.x- xA) + (p.y-yA)*(p.y-yA));
            //  If dot product BA.BC si > 0 return distance(A, C)
            if ( (xA - xB)*(p.x - xB) + (yA-yB)*(p.y-yB) < 0 )
                return( (p.x - xB)*(p.x- xB) + (p.y-yB)*(p.y-yB));
            //  Distance point to line is a * p.x + b * p.y + c)*(a * p.x + b * p.y + c)/(a*a + b*b
            double d1 = (a * p.x + b * p.y + c)*(a * p.x + b * p.y + c)/(a*a + b*b);
            return d1;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd 0x20(%rax), %xmm1
subsd 0x18(%rax), %xmm1
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm2
subsd 0x18(%rax), %xmm2
movsd 0x30(%rax), %xmm0
subsd 0x28(%rax), %xmm0
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm3
subsd 0x28(%rax), %xmm3
mulsd %xmm3, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x64bb8
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
subsd 0x18(%rax), %xmm0
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm2
subsd 0x18(%rax), %xmm2
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
subsd 0x28(%rax), %xmm1
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm3
subsd 0x28(%rax), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x64cd3
movq -0x28(%rbp), %rax
movsd 0x18(%rax), %xmm1
subsd 0x20(%rax), %xmm1
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm2
subsd 0x20(%rax), %xmm2
movsd 0x28(%rax), %xmm0
subsd 0x30(%rax), %xmm0
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm3
subsd 0x30(%rax), %xmm3
mulsd %xmm3, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x64c50
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
subsd 0x20(%rax), %xmm0
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm2
subsd 0x20(%rax), %xmm2
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm1
subsd 0x30(%rax), %xmm1
movq -0x18(%rbp), %rcx
movsd 0x8(%rcx), %xmm3
subsd 0x30(%rax), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x64cd3
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm2
movsd 0x8(%rax), %xmm1
movq -0x18(%rbp), %rcx
mulsd 0x8(%rcx), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd 0x10(%rax), %xmm0
movsd (%rax), %xmm1
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm3
movsd 0x8(%rax), %xmm2
movq -0x18(%rbp), %rcx
mulsd 0x8(%rcx), %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
addsd 0x10(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd (%rax), %xmm1
movsd (%rax), %xmm3
movsd 0x8(%rax), %xmm2
mulsd 0x8(%rax), %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseXML(char*, void (*)(void*, char const*, char const**), void (*)(void*, char const*), void (*)(void*, char const*), void*)
int nsvg__parseXML(char* input,
				   void (*startelCb)(void* ud, const char* el, const char** attr),
				   void (*endelCb)(void* ud, const char* el),
				   void (*contentCb)(void* ud, const char* s),
				   void* ud)
{
	char* s = input;
	char* mark = s;
	int state = NSVG_XML_CONTENT;
	while (*s) {
		if (*s == '<' && state == NSVG_XML_CONTENT) {
			// Start of a tag
			*s++ = '\0';
			nsvg__parseContent(mark, contentCb, ud);
			mark = s;
			state = NSVG_XML_TAG;
		} else if (*s == '>' && state == NSVG_XML_TAG) {
			// Start of a content or new tag.
			*s++ = '\0';
			nsvg__parseElement(mark, startelCb, endelCb, ud);
			mark = s;
			state = NSVG_XML_CONTENT;
		} else {
			s++;
		}
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x2, -0x3c(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0x68253
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
jne 0x681f6
cmpl $0x2, -0x3c(%rbp)
jne 0x681f6
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x0, (%rax)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x68260
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0x6824e
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3e, %eax
jne 0x68240
cmpl $0x1, -0x3c(%rbp)
jne 0x68240
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x0, (%rax)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x682e0
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x2, -0x3c(%rbp)
jmp 0x6824c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6824e
jmp 0x681a3
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseContent(char*, void (*)(void*, char const*), void*)
static void nsvg__parseContent(char* s,
							   void (*contentCb)(void* ud, const char* s),
							   void* ud)
{
	// Trim start white spaces
	while (*s && nsvg__isspace(*s)) s++;
	if (!*s) return;

	if (contentCb)
		(*contentCb)(ud, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x68297
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x76fd0
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x682a0
jmp 0x682ae
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x68274
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x682b9
jmp 0x682ce
cmpq $0x0, -0x10(%rbp)
je 0x682ce
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvgParse
NSVGimage* nsvgParse(char* input, const char* units, double dpi)
{
	NSVGparser* p;
	NSVGimage* ret = 0;

	p = nsvg__createParser();
	if (p == NULL) {
		return NULL;
	}
	p->dpi = dpi;

	nsvg__parseXML(input, nsvg__startElement, nsvg__endElement, nsvg__content, p);

	ret = p->image;
	p->image = NULL;

	nsvg__deleteParser(p);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
callq 0x687f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x68777
movq $0x0, -0x8(%rbp)
jmp 0x687d9
movsd -0x20(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0xd080(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %r8
leaq 0x1f9(%rip), %rsi       # 0x68990
leaq 0x5c2(%rip), %rdx       # 0x68d60
leaq 0x64b(%rip), %rcx       # 0x68df0
callq 0x68170
movq -0x28(%rbp), %rax
movq 0xd038(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, 0xd038(%rax)
movq -0x28(%rbp), %rdi
callq 0x68e10
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__createParser()
static NSVGparser* nsvg__createParser()
{
	NSVGparser* p;
	p = (NSVGparser*)malloc(sizeof(NSVGparser));
	if (p == NULL) goto error;
	memset(p, 0, sizeof(NSVGparser));

	p->image = (NSVGimage*)malloc(sizeof(NSVGimage));
	if (p->image == NULL) goto error;
	memset(p->image, 0, sizeof(NSVGimage));

	// Init style
	nsvg__xformIdentity(p->attr[0].xform);
	memset(p->attr[0].id, 0, sizeof p->attr[0].id);
	p->attr[0].fillColor = NSVG_RGB(0,0,0);
	p->attr[0].strokeColor = NSVG_RGB(0,0,0);
	p->attr[0].opacity = 1;
	p->attr[0].fillOpacity = 1;
	p->attr[0].strokeOpacity = 1;
	p->attr[0].stopOpacity = 1;
	p->attr[0].strokeWidth = 1;
	p->attr[0].strokeLineJoin = NSVG_JOIN_MITER;
	p->attr[0].strokeLineCap = NSVG_CAP_BUTT;
	p->attr[0].miterLimit = 4;
	p->attr[0].fillRule = NSVG_FILLRULE_NONZERO;
	p->attr[0].hasFill = 1;
	p->attr[0].visible = 1;

	return p;

error:
	if (p) {
		if (p->image) free(p->image);
		free(p);
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xd090, %edi           # imm = 0xD090
callq 0x9730
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x68812
jmp 0x6894d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0xd090, %edx           # imm = 0xD090
callq 0x92f0
movl $0x18, %edi
callq 0x9730
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xd038(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd038(%rax)
jne 0x6884d
jmp 0x6894d
movq -0x10(%rbp), %rax
movq 0xd038(%rax), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x92f0
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x77000
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x92f0
movq -0x10(%rbp), %rax
movl $0x0, 0x70(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x74(%rax)
movq -0x10(%rbp), %rax
movsd 0x1b855(%rip), %xmm0    # 0x840f8
movsd %xmm0, 0x78(%rax)
movq -0x10(%rbp), %rax
movsd 0x1b844(%rip), %xmm0    # 0x840f8
movsd %xmm0, 0x80(%rax)
movq -0x10(%rbp), %rax
movsd 0x1b830(%rip), %xmm0    # 0x840f8
movsd %xmm0, 0x88(%rax)
movq -0x10(%rbp), %rax
movsd 0x1b81c(%rip), %xmm0    # 0x840f8
movsd %xmm0, 0x188(%rax)
movq -0x10(%rbp), %rax
movsd 0x1b808(%rip), %xmm0    # 0x840f8
movsd %xmm0, 0x110(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x164(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x165(%rax)
movq -0x10(%rbp), %rax
movsd 0x1b84e(%rip), %xmm0    # 0x84168
movsd %xmm0, 0x168(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x170(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x198(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x19a(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x68983
cmpq $0x0, -0x10(%rbp)
je 0x6897b
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd038(%rax)
je 0x68972
movq -0x10(%rbp), %rax
movq 0xd038(%rax), %rdi
callq 0x9690
movq -0x10(%rbp), %rdi
callq 0x9690
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__endElement(void*, char const*)
static void nsvg__endElement(void* ud, const char* el)
{
	NSVGparser* p = (NSVGparser*)ud;

	if (strcmp(el, "g") == 0) {
		nsvg__popAttr(p);
	} else if (strcmp(el, "path") == 0) {
		p->pathFlag = 0;
	} else if (strcmp(el, "defs") == 0) {
		p->defsFlag = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x197b7(%rip), %rsi     # 0x8253a
callq 0x9770
cmpl $0x0, %eax
jne 0x68d98
movq -0x18(%rbp), %rdi
callq 0x78240
jmp 0x68dde
movq -0x10(%rbp), %rdi
leaq 0x1bc05(%rip), %rsi     # 0x849a8
callq 0x9770
cmpl $0x0, %eax
jne 0x68dba
movq -0x18(%rbp), %rax
movb $0x0, 0xd088(%rax)
jmp 0x68ddc
movq -0x10(%rbp), %rdi
leaq 0x1ceff(%rip), %rsi     # 0x85cc4
callq 0x9770
cmpl $0x0, %eax
jne 0x68dda
movq -0x18(%rbp), %rax
movb $0x0, 0xd089(%rax)
jmp 0x68ddc
jmp 0x68dde
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__deleteParser(NSVGparser*)
static void nsvg__deleteParser(NSVGparser* p)
{
	if (p != NULL) {
		nsvg__deletePaths(p->plist);
		nsvg__deleteGradientData(p->gradients);
		nsvgDelete(p->image);
		nsvg__resetPath(p);
		free(p);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x68e65
movq -0x8(%rbp), %rax
movq 0xd030(%rax), %rdi
callq 0x69040
movq -0x8(%rbp), %rax
movq 0xd040(%rax), %rdi
callq 0x7fa30
movq -0x8(%rbp), %rax
movq 0xd038(%rax), %rdi
callq 0x68fb0
movq -0x8(%rbp), %rdi
callq 0x7c0d0
movq -0x8(%rbp), %rdi
callq 0x9690
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvgParseFromFile
NSVGimage* nsvgParseFromFile(const char* filename, const char* units, double dpi)
{
	FILE* fp = NULL;
	size_t size;
	char* data = NULL;
	NSVGimage* image = NULL;

	fp = fopen(filename, "rb");
	if (!fp) goto error;
	fseek(fp, 0, SEEK_END);
	size = ftell(fp);
	fseek(fp, 0, SEEK_SET);
	data = (char*)malloc(size+1);
	if (data == NULL) goto error;
	if (fread(data, 1, size, fp) != size) goto error;
	data[size] = '\0';	// Must be null terminated.
	fclose(fp);
	image = nsvgParse(data, units, dpi);
	free(data);

	return image;

error:
	if (fp) fclose(fp);
	if (data) free(data);
	if (image) nsvgDelete(image);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1b61d(%rip), %rsi     # 0x844c5
callq 0x9680
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x68ebd
jmp 0x68f61
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x9610
movq -0x28(%rbp), %rdi
callq 0x9030
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x9610
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
callq 0x9730
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x68f05
jmp 0x68f61
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x97f0
cmpq -0x30(%rbp), %rax
je 0x68f23
jmp 0x68f61
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rdi
callq 0x9540
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
callq 0x68740
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x9690
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x68f99
cmpq $0x0, -0x28(%rbp)
je 0x68f71
movq -0x28(%rbp), %rdi
callq 0x9540
cmpq $0x0, -0x38(%rbp)
je 0x68f81
movq -0x38(%rbp), %rdi
callq 0x9690
cmpq $0x0, -0x40(%rbp)
je 0x68f91
movq -0x40(%rbp), %rdi
callq 0x68fb0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvgDelete
void nsvgDelete(NSVGimage* image)
{
	NSVGshape *snext, *shape;
	if (image == NULL) return;
	shape = image->shapes;
	while (shape != NULL) {
		snext = shape->next;
		nsvg__deletePaths(shape->paths);
		nsvg__deletePaint(&shape->fill);
		nsvg__deletePaint(&shape->stroke);
		free(shape);
		shape = snext;
	}
	free(image);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x68fc5
jmp 0x6902d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x69024
movq -0x18(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0xf0(%rax), %rdi
callq 0x69040
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x69090
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x69090
movq -0x18(%rbp), %rdi
callq 0x9690
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x68fd1
movq -0x8(%rbp), %rdi
callq 0x9690
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__deletePaths(NSVGpath*)
static void nsvg__deletePaths(NSVGpath* path)
{
	while (path) {
		NSVGpath *next = path->next;
		if (path->PathElts != NULL)
			nsvg__deletePathElts(path->PathElts);
		free(path);
		path = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6908a
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x69077
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7e1f0
movq -0x8(%rbp), %rdi
callq 0x9690
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6904c
addq $0x10, %rsp
popq %rbp
retq
// File: thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: Path2Polygon(Polygon*, NSVGpath*)
static void Path2Polygon(Polygon *Poly, NSVGpath *path)
{
struct NSVGPathElt *Elt = path->PathElts;
Point p;

    p = Point(path->StartX, path->StartY);
    Poly->addVertice(p);
    for (int n = 0; n < path->nElts; n++)
    {
        p = Point(Elt->EndX, Elt->EndY);
        Poly->addVertice(p);
        Elt = Elt->next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm1
leaq -0x38(%rbp), %rdi
callq 0x5b520
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5e960
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x6a9c4
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm1
leaq -0x50(%rbp), %rdi
callq 0x5b520
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5e960
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6a969
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: SvgDoc::NbChildren(NSVGpath*)
int SvgDoc::NbChildren(NSVGpath *path)
{
int nb = 0;

    for ( NSVGpath *child = path->child; child != NULL; child = child->next)
    {
        nb++;
    }
    return nb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6ad4d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6ad2f
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: SvgDoc::SvgDoc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
SvgDoc::SvgDoc(string &FileName)
{

    StartClock = clock();
    Name = FileName;
    RectCostFactor = 0.0;
	// Load SVG
	SvgData = nsvgParseFromFile(FileName.c_str(), "mm", 25.4);
	if (SvgData )
	{
        SheetSizeX = round(SvgData->width * 100) / 100.0;
        SheetSizeY = round(SvgData->height * 100) / 100.0;
	}
    nbTranslation = 0;
    nbRotation = 0;
    nbCheckAngles = 0;
    nbPointInPoly = 0;
    nbIntersectPoly = 0;
    nbPlacementImpossible = 0;
    CacheMiss = 0;
    CacheHit_OK = 0;
    CacheHit_KO = 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x4c8c9(%rip), %rax     # 0xb7cd8
movq %rax, (%rdi)
addq $0x20, %rdi
movq %rdi, -0x40(%rbp)
callq 0x7fd20
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x38(%rbp)
callq 0x9760
movq -0x30(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x28(%rbp)
callq 0x98f0
jmp 0x6b443
callq 0x93c0
movq -0x30(%rbp), %rdi
movq %rax, 0x268(%rdi)
movq -0x10(%rbp), %rsi
addq $0x40, %rdi
callq 0x9070
jmp 0x6b462
movq -0x30(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rdi
callq 0x9200
movq %rax, %rdi
leaq 0x1951f(%rip), %rsi     # 0x849a0
movsd 0x18cff(%rip), %xmm0    # 0x84188
callq 0x68e70
movq %rax, -0x48(%rbp)
jmp 0x6b494
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
je 0x6b52e
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movsd 0x18cd5(%rip), %xmm0    # 0x84190
mulsd (%rax), %xmm0
callq 0x9220
movq -0x30(%rbp), %rax
movsd 0x18cc0(%rip), %xmm1    # 0x84190
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
movq 0x8(%rax), %rax
movsd 0x18cab(%rip), %xmm0    # 0x84190
mulsd 0x8(%rax), %xmm0
callq 0x9220
movq -0x30(%rbp), %rax
movsd 0x18c95(%rip), %xmm1    # 0x84190
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
jmp 0x6b52e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x6b59b
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x97e0
jmp 0x6b59b
movq -0x30(%rbp), %rax
movq $0x0, 0x270(%rax)
movq $0x0, 0x278(%rax)
movq $0x0, 0x280(%rax)
movq $0x0, 0x288(%rax)
movq $0x0, 0x290(%rax)
movq $0x0, 0x298(%rax)
movq $0x0, 0x2a0(%rax)
movq $0x0, 0x2a8(%rax)
movq $0x0, 0x2b0(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x9a98
movq -0x40(%rbp), %rdi
callq 0x7fd40
movq -0x18(%rbp), %rdi
callq 0x9960
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: SvgDoc::WriteOrginalLayer(std::ostream&)
void SvgDoc::WriteOrginalLayer(ostream& Out)
{
    //  Then the data, begin with original layer
    Out << "  <g\n";
    Out << "     inkscape:label=\"Orginal_Layer\"" << endl;
    Out << "     inkscape:groupmode=\"layer\"" << endl;
    Out << "     id=\"Orginal_Layer1\">" << endl;

    int nShape = 0;
    Out << std::fixed;
    Out << std::setprecision(6);
	for (NSVGshape *shape = SvgData->shapes; shape != NULL; shape = shape->next, nShape++)
	{
        //  Then for each path in the shape
        int iPath = 0;
        for (NSVGpath *path = shape->paths; path != NULL; path = path->next, iPath++)
        {
            WritePath(Out, path, shape);       //  Write path itself.
            for ( NSVGpath *path_child = path->child; path_child != NULL; path_child = path_child->next)
            {
                WritePath(Out, path_child, shape);
            }

        }
    }
    Out << "  </g>" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x18c94(%rip), %rsi     # 0x84d07
callq 0x9530
movq -0x10(%rbp), %rdi
leaq 0x189ad(%rip), %rsi     # 0x84a30
callq 0x9530
movq %rax, %rdi
movq 0x4beb6(%rip), %rsi     # 0xb7f48
callq 0x9590
movq -0x10(%rbp), %rdi
leaq 0x189b2(%rip), %rsi     # 0x84a54
callq 0x9530
movq %rax, %rdi
movq 0x4be97(%rip), %rsi     # 0xb7f48
callq 0x9590
movq -0x10(%rbp), %rdi
leaq 0x189b3(%rip), %rsi     # 0x84a74
callq 0x9530
movq %rax, %rdi
movq 0x4be78(%rip), %rsi     # 0xb7f48
callq 0x9590
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x13e09(%rip), %rsi     # 0x7fef0
callq 0x91a0
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x6, %edi
callq 0x7ff20
movq -0x48(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x9840
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6c1c8
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x6c1a9
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x6b670
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x6c190
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x6b670
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x6c166
jmp 0x6c192
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6c13e
jmp 0x6c1ab
movq -0x20(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6c11d
movq -0x10(%rbp), %rdi
leaq 0x188bb(%rip), %rsi     # 0x84a8e
callq 0x9530
movq %rax, %rdi
movq 0x4bd66(%rip), %rsi     # 0xb7f48
callq 0x9590
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: SvgDoc::WriteFile(std::ostream&, int)
void SvgDoc::WriteFile(ostream &Out, int output_layers)
{
    WriteHeader(Out);
    if ( output_layers & 1 )        //  Original layer
        WriteOrginalLayer(Out);
    if ( output_layers & 2 )        //  Close Polygon layer
        WritePolygonLayer(Out);
    if ( output_layers & 4 )        //  Large Polygon layer
        WriteLargePolygonLayer(Out);
    if ( output_layers & 8 )        //  Hull Placed layer
        WriteHullLargePolygonLayer(Out);
    if ( output_layers & 16 )        //  Placed Polygon layer
        WritePlacedPolygonLayer(Out);
    WritePlacedLayer(Out);
    Out << "</svg>" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x6d150
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6d54c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6c050
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x6d564
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6c1f0
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x6d57c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6c530
movl -0x14(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x6d594
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6c880
movl -0x14(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x6d5ac
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6cbd0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6cf20
movq -0x10(%rbp), %rdi
leaq 0x17c56(%rip), %rsi     # 0x8521a
callq 0x9530
movq %rax, %rdi
movq 0x4a975(%rip), %rsi     # 0xb7f48
callq 0x9590
addq $0x20, %rsp
popq %rbp
retq
nop