LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x40(%rdi), %rbx
movslq 0x8(%rdi), %rsi
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
movq %rbx, %rdi
callq 0x2488a
pushq $0x18
popq %r15
xorl %r12d, %r12d
movslq 0x8(%r14), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r12
jge 0x23c85
leaq 0x1(%r12), %r13
movq 0x10(%r14), %rax
movsd -0x8(%rax,%r15), %xmm1
movsd (%rax,%r15), %xmm0
subsd -0x10(%rax,%r15), %xmm0
subsd -0x18(%rax,%r15), %xmm1
callq 0x8080
movq 0x40(%r14), %rax
movsd %xmm0, (%rax,%r12,8)
addq $0x10, %r15
movq %r13, %r12
jmp 0x23c3c
movq (%rbx), %rcx
andq $0x0, -0x8(%rcx,%rax,8)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movsd 0x58(%rsi), %xmm0
xorl %eax, %eax
ucomisd 0x58(%rdi), %xmm0
ja 0x24049
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movsd 0x60(%rsi), %xmm0
ucomisd 0x60(%rdi), %xmm0
ja 0x24040
movsd 0x68(%rdi), %xmm0
ucomisd 0x68(%rbx), %xmm0
ja 0x24040
movsd 0x70(%rdi), %xmm0
ucomisd 0x70(%rbx), %xmm0
ja 0x24040
movslq 0x8(%rdi), %r15
movq 0x10(%rdi), %r14
xorl %ecx, %ecx
testl %r15d, %r15d
movl $0x0, %r12d
cmovgl %r15d, %r12d
movq %rcx, %r13
cmpq %rcx, %r12
je 0x24038
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x22e40
leaq 0x1(%r13), %rcx
addq $0x10, %r14
testl %eax, %eax
jg 0x24017
xorl %eax, %eax
cmpq %r15, %r13
setge %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movups (%rsi), %xmm0
movaps %xmm0, 0x10(%rsp)
movups (%rdx), %xmm1
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, %xmm2
movlhps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
movaps %xmm0, %xmm3
unpckhpd %xmm1, %xmm3            # xmm3 = xmm3[1],xmm1[1]
movups %xmm3, 0x28(%rdi)
movups %xmm2, 0x18(%rdi)
callq 0x8260
movaps %xmm0, (%rsp)
movapd 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
callq 0x8560
movapd (%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd 0x11d3e(%rip), %xmm1    # 0x360e0
movupd %xmm1, 0x38(%rbx)
movaps 0x10(%rsp), %xmm0
movhlps %xmm0, %xmm0            # xmm0 = xmm0[1,1]
movaps %xmm0, 0x30(%rsp)
movaps 0x20(%rsp), %xmm1
movhlps %xmm1, %xmm1            # xmm1 = xmm1[1,1]
movaps %xmm1, (%rsp)
callq 0x8260
movaps %xmm0, 0x40(%rsp)
movapd 0x30(%rsp), %xmm0
movaps (%rsp), %xmm1
callq 0x8560
movapd 0x40(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd 0x11cf5(%rip), %xmm1    # 0x360e0
movupd %xmm1, 0x48(%rbx)
movapd 0x10(%rsp), %xmm2
movapd %xmm2, %xmm0
movapd 0x20(%rsp), %xmm1
shufpd $0x1, %xmm1, %xmm0      # xmm0 = xmm0[1],xmm1[0]
movapd 0x30(%rsp), %xmm3
mulsd %xmm1, %xmm3
shufpd $0x1, %xmm2, %xmm1      # xmm1 = xmm1[1],xmm2[0]
subpd %xmm1, %xmm0
movupd %xmm0, (%rbx)
movapd (%rsp), %xmm0
mulsd %xmm2, %xmm0
subsd %xmm3, %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movsd (%rsi), %xmm4
movsd 0x8(%rsi), %xmm3
movsd (%rdi), %xmm2
movsd 0x8(%rdi), %xmm5
movapd %xmm3, %xmm1
mulsd %xmm2, %xmm1
movapd %xmm4, %xmm0
mulsd %xmm5, %xmm0
subsd %xmm1, %xmm0
movapd 0x11bce(%rip), %xmm1    # 0x36030
andpd %xmm0, %xmm1
movsd 0x11bf2(%rip), %xmm6    # 0x36060
ucomisd %xmm1, %xmm6
jbe 0x2448f
pushq %rax
leaq 0x12e11(%rip), %rdi     # 0x3728d
callq 0x80a0
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addq $0x8, %rsp
jmp 0x244bd
movsd 0x10(%rsi), %xmm1
unpcklpd %xmm1, %xmm4            # xmm4 = xmm4[0],xmm1[0]
movsd 0x10(%rdi), %xmm6
unpcklpd %xmm6, %xmm1            # xmm1 = xmm1[0],xmm6[0]
unpcklpd %xmm5, %xmm6            # xmm6 = xmm6[0],xmm5[0]
mulpd %xmm4, %xmm6
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
mulpd %xmm2, %xmm1
subpd %xmm6, %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
divpd %xmm0, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movsd (%rsi), %xmm4
movsd 0x8(%rsi), %xmm3
movsd (%rdi), %xmm5
movsd 0x8(%rdi), %xmm2
movapd %xmm3, %xmm1
mulsd %xmm5, %xmm1
movapd %xmm4, %xmm0
mulsd %xmm2, %xmm0
subsd %xmm1, %xmm0
movapd 0x11ae4(%rip), %xmm1    # 0x36030
andpd %xmm0, %xmm1
movsd 0x11b08(%rip), %xmm6    # 0x36060
ucomisd %xmm1, %xmm6
ja 0x24597
movsd 0x10(%rsi), %xmm7
movsd 0x10(%rdi), %xmm8
unpcklpd %xmm8, %xmm2            # xmm2 = xmm2[0],xmm8[0]
unpcklpd %xmm7, %xmm8            # xmm8 = xmm8[0],xmm7[0]
unpcklpd %xmm4, %xmm7            # xmm7 = xmm7[0],xmm4[0]
mulpd %xmm7, %xmm2
unpcklpd %xmm5, %xmm3            # xmm3 = xmm3[0],xmm5[0]
mulpd %xmm3, %xmm8
subpd %xmm2, %xmm8
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
divpd %xmm0, %xmm8
movupd %xmm8, (%rdx)
ucomisd %xmm1, %xmm6
setbe %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
testq %rcx, %rcx
je 0x24607
movb $0x0, (%r15)
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2451e
testb %al, %al
je 0x2464e
testq %r12, %r12
je 0x24629
movapd (%rsp), %xmm0
movupd %xmm0, (%r12)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x244ea
testl %eax, %eax
je 0x246ac
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x244ea
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x246ae
xorl %eax, %eax
testq %r15, %r15
je 0x246ae
movsd (%rbx), %xmm1
subsd (%r14), %xmm1
andpd 0x119ca(%rip), %xmm1    # 0x36030
movsd 0x119f2(%rip), %xmm0    # 0x36060
ucomisd %xmm1, %xmm0
jbe 0x246ae
movsd 0x8(%rbx), %xmm1
subsd 0x8(%r14), %xmm1
andpd 0x119a9(%rip), %xmm1    # 0x36030
ucomisd %xmm1, %xmm0
jbe 0x246ae
movsd 0x10(%rbx), %xmm1
subsd 0x10(%r14), %xmm1
andpd 0x11990(%rip), %xmm1    # 0x36030
ucomisd %xmm1, %xmm0
jbe 0x246ae
movb $0x1, (%r15)
jmp 0x246ae
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
testq %rcx, %rcx
je 0x248e7
movb $0x0, (%r14)
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2451e
testb %al, %al
je 0x2492e
testq %r12, %r12
je 0x24909
movapd (%rsp), %xmm0
movupd %xmm0, (%r12)
movq %rsp, %rsi
movq %r15, %rdi
callq 0x2497e
testl %eax, %eax
je 0x2496f
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2497e
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x24971
xorl %eax, %eax
testq %r14, %r14
je 0x24971
movsd 0x8(%rbx), %xmm0
mulsd 0x28(%r15), %xmm0
movsd (%rbx), %xmm1
mulsd 0x18(%r15), %xmm1
addsd %xmm0, %xmm1
addsd 0x10(%rbx), %xmm1
andpd 0x116d5(%rip), %xmm1    # 0x36030
movsd 0x116fd(%rip), %xmm0    # 0x36060
ucomisd %xmm1, %xmm0
jbe 0x24971
movb $0x1, (%r14)
jmp 0x24971
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movsd (%rsi), %xmm0
movsd 0x38(%rdi), %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
ja 0x24a0a
ucomisd 0x40(%rdi), %xmm0
ja 0x24a0a
movsd 0x8(%rsi), %xmm1
movsd 0x48(%rdi), %xmm2
ucomisd %xmm1, %xmm2
ja 0x24a0a
ucomisd 0x50(%rdi), %xmm1
ja 0x24a0a
movupd 0x18(%rdi), %xmm2
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movhpd 0x28(%rdi), %xmm2       # xmm2 = xmm2[0],mem[0]
movapd %xmm0, %xmm1
subpd %xmm2, %xmm1
andpd 0x11665(%rip), %xmm1    # 0x36030
pshufd $0xee, %xmm1, %xmm2     # xmm2 = xmm1[2,3,2,3]
addsd %xmm1, %xmm2
movsd 0x116bc(%rip), %xmm1    # 0x36098
ucomisd %xmm2, %xmm1
ja 0x24a0a
movupd 0x20(%rdi), %xmm2
movhpd 0x30(%rdi), %xmm2       # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm0
andpd 0x11638(%rip), %xmm0    # 0x36030
pshufd $0xee, %xmm0, %xmm2     # xmm2 = xmm0[2,3,2,3]
addsd %xmm0, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm1
setbe %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movsd 0x18(%rdi), %xmm3
movsd 0x20(%rdi), %xmm5
movapd %xmm5, %xmm9
subsd %xmm3, %xmm9
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm2
movapd %xmm0, %xmm1
subsd %xmm3, %xmm1
movsd 0x30(%rdi), %xmm6
movsd 0x28(%rdi), %xmm4
movapd %xmm6, %xmm7
subsd %xmm4, %xmm7
movapd %xmm2, %xmm8
subsd %xmm4, %xmm8
mulsd %xmm8, %xmm7
mulsd %xmm1, %xmm9
addsd %xmm7, %xmm9
xorpd %xmm7, %xmm7
ucomisd %xmm9, %xmm7
jbe 0x24a77
mulsd %xmm8, %xmm8
mulsd %xmm1, %xmm1
addsd %xmm8, %xmm1
jmp 0x24aad
subsd %xmm5, %xmm3
movapd %xmm0, %xmm1
subsd %xmm5, %xmm1
subsd %xmm6, %xmm4
movapd %xmm2, %xmm5
subsd %xmm6, %xmm5
mulsd %xmm5, %xmm4
mulsd %xmm1, %xmm3
addsd %xmm4, %xmm3
ucomisd %xmm3, %xmm7
jbe 0x24ab2
mulsd %xmm5, %xmm5
mulsd %xmm1, %xmm1
addsd %xmm5, %xmm1
movapd %xmm1, %xmm0
retq
movsd (%rdi), %xmm1
movsd 0x8(%rdi), %xmm3
mulsd %xmm3, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
addsd 0x10(%rdi), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm3, %xmm3
mulsd %xmm1, %xmm1
addsd %xmm3, %xmm1
divsd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdi, %r14
pushq $0x1
popq %rdi
movl $0xd090, %esi           # imm = 0xD090
callq 0x82f0
testq %rax, %rax
je 0x254f2
movq %rax, %rbx
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x82f0
movq %rax, 0xd038(%rbx)
testq %rax, %rax
je 0x254ea
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x40(%rbx)
movq %rax, 0x58(%rbx)
movaps 0x10cb0(%rip), %xmm0    # 0x360d0
movups %xmm0, 0x78(%rbx)
movq %rax, 0x88(%rbx)
movq %rax, 0x188(%rbx)
movq %rax, 0x110(%rbx)
movabsq $0x4010000000000000, %rax # imm = 0x4010000000000000
movq %rax, 0x168(%rbx)
movb $0x1, %al
movb %al, 0x198(%rbx)
movb %al, 0x19a(%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0xd080(%rbx)
leaq 0x98(%rip), %rsi        # 0x25504
leaq 0x1f58(%rip), %rdx      # 0x273cb
leaq 0x1fb9(%rip), %rcx      # 0x27433
movq %r14, %rdi
movq %rbx, %r8
callq 0x25144
movq 0xd030(%rbx), %rdi
movq 0xd038(%rbx), %r14
andq $0x0, 0xd038(%rbx)
callq 0x27548
movq 0xd040(%rbx), %r15
testq %r15, %r15
je 0x254cc
movq 0x118(%r15), %rdi
movq 0x120(%r15), %r12
callq 0x8530
movq %r15, %rdi
callq 0x8530
movq %r12, %r15
jmp 0x254a7
movq 0xd038(%rbx), %rdi
callq 0x274f2
movq %rbx, %rdi
callq 0x31ccf
movq %rbx, %rdi
callq 0x8530
jmp 0x254f5
movq %rbx, %rdi
callq 0x8530
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x67, (%rsi)
jne 0x273e1
cmpb $0x0, 0x1(%r14)
je 0x27419
leaq 0xf591(%rip), %rsi      # 0x36979
movq %r14, %rdi
callq 0x85d0
testl %eax, %eax
je 0x27410
leaq 0x10887(%rip), %rsi     # 0x37c82
movq %r14, %rdi
callq 0x85d0
testl %eax, %eax
jne 0x2742b
movb $0x0, 0xd089(%rbx)
jmp 0x2742b
movb $0x0, 0xd088(%rbx)
jmp 0x2742b
movl 0xd000(%rbx), %eax
testl %eax, %eax
jle 0x2742b
decl %eax
movl %eax, 0xd000(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
leaq 0xf04f(%rip), %rsi      # 0x36499
callq 0x8520
testq %rax, %rax
je 0x274db
movq %rax, %rbx
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x84b0
movq %rbx, %rdi
callq 0x8030
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x84b0
leaq 0x1(%r15), %rdi
callq 0x85b0
movq %rax, %r14
testq %rax, %rax
je 0x274d1
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x8640
cmpq %r15, %rax
jne 0x274d1
movb $0x0, (%r14,%r15)
movq %rbx, %rdi
callq 0x8430
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x253c3
movq %rax, %rbx
movq %r14, %rdi
callq 0x8530
movq %rbx, %rax
jmp 0x274e8
movq %rbx, %rdi
callq 0x8430
jmp 0x274de
xorl %r14d, %r14d
movq %r14, %rdi
callq 0x8530
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x27547
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x2753a
movq 0xf0(%r14), %rdi
movq 0xf8(%r14), %r15
callq 0x27548
leaq 0x40(%r14), %rdi
callq 0x2757b
leaq 0x50(%r14), %rdi
callq 0x2757b
movq %r14, %rdi
callq 0x8530
movq %r15, %r14
jmp 0x27503
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8530
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rbx, %rbx
je 0x27573
movq 0x10(%rbx), %rdi
movq 0x48(%rbx), %r14
testq %rdi, %rdi
je 0x27566
callq 0x3245c
movq %rbx, %rdi
callq 0x8530
movq %r14, %rbx
jmp 0x2754f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
addq $0x58, %rsi
xorl %eax, %eax
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x2890a
incl %eax
addq $0x48, %rsi
jmp 0x288fa
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x23e6b(%rip), %rax     # 0x4ccf0
movq %rax, (%rdi)
leaq 0x20(%rdi), %r14
movq %r14, 0x28(%rdi)
movq %r14, 0x20(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x50(%rdi), %rax
movq %rax, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movq %rsi, %r13
leaq 0x40(%rdi), %r15
movb $0x0, 0x50(%rdi)
leaq 0x68(%rdi), %r12
movq %r12, %rdi
callq 0x8720
callq 0x8300
movq %rax, 0x268(%rbx)
movq %r15, %rdi
movq %r13, %rsi
callq 0x8270
andq $0x0, 0x38(%rbx)
movq (%r13), %rdi
movsd 0xd333(%rip), %xmm0     # 0x36218
callq 0x27434
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x28f34
movupd (%rax), %xmm0
mulpd 0xd271(%rip), %xmm0     # 0x36170
movapd %xmm0, (%rsp)
callq 0x81a0
movapd %xmm0, 0x10(%rsp)
movapd (%rsp), %xmm0
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
callq 0x81a0
movapd 0x10(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
divpd 0xd241(%rip), %xmm1     # 0x36170
movupd %xmm1, 0x10(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x2a0(%rbx)
movupd %xmm0, 0x290(%rbx)
movupd %xmm0, 0x280(%rbx)
movupd %xmm0, 0x270(%rbx)
andq $0x0, 0x2b0(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x28f7e
movq %rax, %rbx
movq %r12, %rdi
callq 0x8630
movq %r15, %rdi
callq 0x8858
movq %r14, %rdi
callq 0x33458
movq %rbx, %rdi
callq 0x8770
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xd5cd(%rip), %rsi      # 0x36cd8
movq %rbx, %rdi
callq 0x8420
leaq 0xd2e7(%rip), %rsi      # 0x36a01
movq %rbx, %rdi
callq 0x8420
movq %rax, %rdi
callq 0x8200
leaq 0xd2f4(%rip), %rsi      # 0x36a25
movq %rbx, %rdi
callq 0x8420
movq %rax, %rdi
callq 0x8200
leaq 0xd2fd(%rip), %rsi      # 0x36a45
movq %rbx, %rdi
callq 0x8420
movq %rax, %rdi
callq 0x8200
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x18(%rbx,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq $0x6, 0x8(%rbx,%rax)
movq 0x8(%r14), %r14
addq $0x10, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x297d9
leaq 0xf0(%r14), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x297d0
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x29008
leaq 0x58(%r15), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x297ca
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x29008
addq $0x48, %r12
jmp 0x297ad
addq $0x48, %r15
jmp 0x29793
addq $0xf8, %r14
jmp 0x29784
leaq 0xd27f(%rip), %rsi      # 0x36a5f
movq %rbx, %rdi
callq 0x8420
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2a394
testb $0x1, %bpl
je 0x2a70c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x296f6
testb $0x2, %bpl
je 0x2a71d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x297fc
testb $0x4, %bpl
je 0x2a72e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29a5e
testb $0x8, %bpl
je 0x2a73f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29cea
testb $0x10, %bpl
je 0x2a750
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29f76
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a202
leaq 0xca89(%rip), %rsi      # 0x371eb
movq %rbx, %rdi
callq 0x8420
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x8200
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: SvgDoc::WriteDoc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int, int)
int SvgDoc::WriteDoc(string &FileName, int FlagFile, int Output_Layers)
{

ofstream Out;

    if ( SvgData == NULL ) return(0);
    if ( FlagFile )
    {
        Out.open(FileName.c_str());
        if ( !Out.is_open()  ) return(0);
        WriteFile(Out, Output_Layers);
        Out.close();
    }
    else
        WriteFile(cout, Output_Layers);
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movl %ecx, %ebx
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rdi
callq 0x8720
xorl %ebp, %ebp
cmpq $0x0, 0x8(%r14)
je 0x2a7ed
testl %r12d, %r12d
je 0x2a7d9
movq (%r15), %rsi
movq %rsp, %rdi
pushq $0x10
popq %rdx
callq 0x8060
leaq 0x70(%rsp), %rdi
callq 0x8110
testb %al, %al
je 0x2a7ed
movq %rsp, %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x2a6ea
movq %rsp, %rdi
callq 0x8600
jmp 0x2a7ea
movq 0x227b8(%rip), %rsi     # 0x4cf98
movq %r14, %rdi
movl %ebx, %edx
callq 0x2a6ea
pushq $0x1
popq %rbp
movq %rsp, %rdi
callq 0x8630
movl %ebp, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8630
movq %rbx, %rdi
callq 0x8770
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: SvgDoc::getFixedNbVertex(std::__cxx11::list<NSVGpath*, std::allocator<NSVGpath*>>)
int SvgDoc::getFixedNbVertex(std::list<NSVGpath *> FixedList)
{
int num = 0;

    //  For each element in list, add the number of vertices
    for (std::list<NSVGpath *>::iterator it=FixedList.begin(); it != FixedList.end(); ++it)
    {
        NSVGpath *path = *it;
        num += path->LargePolygon->nVertices;
    }
    return num;
}

// Assembly:
xorl %eax, %eax
movq %rsi, %rcx
movq (%rcx), %rcx
cmpq %rsi, %rcx
je 0x2d76e
movq 0x10(%rcx), %rdx
movq 0x68(%rdx), %rdx
addl 0x8(%rdx), %eax
jmp 0x2d759
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseGradientStop(NSVGparser*, char const**)
static void nsvg__parseGradientStop(NSVGparser* p, const char** attr)
{
	NSVGattrib* curAttr = nsvg__getAttr(p);
	NSVGgradientData* grad;
	NSVGgradientStop* stop;
	int i, idx;

	curAttr->stopOffset = 0;
	curAttr->stopColor = 0;
	curAttr->stopOpacity = 1.0;

	for (i = 0; attr[i]; i += 2) {
		nsvg__parseAttr(p, attr[i], attr[i + 1]);
	}

	// Add stop to the last gradient.
	grad = p->gradients;
	if (grad == NULL) return;

	grad->nstops++;
	grad->stops = (NSVGgradientStop*)realloc(grad->stops, sizeof(NSVGgradientStop)*grad->nstops);
	if (grad->stops == NULL) return;

	// Insert
	idx = grad->nstops-1;
	for (i = 0; i < grad->nstops-1; i++) {
		if (curAttr->stopOffset < grad->stops[i].offset) {
			idx = i;
			break;
		}
	}
	if (idx != grad->nstops-1) {
		for (i = grad->nstops-1; i > idx; i--)
			grad->stops[i] = grad->stops[i-1];
	}

	stop = &grad->stops[idx];
	stop->color = curAttr->stopColor;
	stop->color |= (unsigned int)(curAttr->stopOpacity*255) << 24;
	stop->offset = curAttr->stopOffset;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq 0xd000(%rdi), %rax
imulq $0x1a0, %rax, %rax      # imm = 0x1A0
andl $0x0, 0x180(%rdi,%rax)
leaq (%rdi,%rax), %r15
movsd 0x3a68(%rip), %xmm0     # 0x34008
movupd %xmm0, 0x188(%rdi,%rax)
addq $0x8, %r14
movq -0x8(%r14), %rsi
testq %rsi, %rsi
je 0x305c7
movq (%r14), %rdx
movq %rbx, %rdi
callq 0x30855
addq $0x10, %r14
jmp 0x305ad
movq 0xd040(%rbx), %rbx
testq %rbx, %rbx
je 0x306a4
movslq 0x110(%rbx), %rsi
incq %rsi
movl %esi, 0x110(%rbx)
movq 0x118(%rbx), %rdi
shlq $0x4, %rsi
callq 0x86f0
movq %rax, 0x118(%rbx)
testq %rax, %rax
je 0x306a4
movslq 0x110(%rbx), %rcx
leaq -0x1(%rcx), %rsi
xorl %edx, %edx
testl %esi, %esi
movl $0x0, %edi
cmovgl %esi, %edi
movq %rax, %r8
addq $0x8, %r8
cmpq %rdx, %rdi
je 0x3066e
movsd (%r8), %xmm0
ucomisd 0x190(%r15), %xmm0
ja 0x30643
incq %rdx
addq $0x10, %r8
jmp 0x30625
leaq -0x1(%rcx), %rsi
shlq $0x4, %rcx
addq $-0x10, %rcx
movq 0x118(%rbx), %rax
cmpq %rdx, %rsi
jle 0x3066b
movupd -0x10(%rax,%rcx), %xmm0
movupd %xmm0, (%rax,%rcx)
decq %rsi
jmp 0x3064b
movq %rdx, %rsi
movsd 0x188(%r15), %xmm0
mulsd 0x5be9(%rip), %xmm0     # 0x36268
cvttsd2si %xmm0, %rcx
shll $0x18, %ecx
orl 0x180(%r15), %ecx
shlq $0x4, %rsi
movl %ecx, (%rax,%rsi)
movsd 0x190(%r15), %xmm0
movsd %xmm0, 0x8(%rax,%rsi)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseAttribs(NSVGparser*, char const**)
static void nsvg__parseAttribs(NSVGparser* p, const char** attr)
{
	int i;
	for (i = 0; attr[i]; i += 2)
	{
		if (strcmp(attr[i], "style") == 0)
			nsvg__parseStyle(p, attr[i + 1]);
		else
			nsvg__parseAttr(p, attr[i], attr[i + 1]);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rbx
leaq 0x766a(%rip), %r15      # 0x37d61
movq -0x8(%rbx), %r12
testq %r12, %r12
je 0x3072d
movq %r12, %rdi
movq %r15, %rsi
callq 0x85d0
movq (%rbx), %rdx
movq %r14, %rdi
testl %eax, %eax
je 0x3071f
movq %r12, %rsi
callq 0x30855
jmp 0x30727
movq %rdx, %rsi
callq 0x31422
addq $0x10, %rbx
jmp 0x306f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parsePoly(NSVGparser*, char const**, int)
static void nsvg__parsePoly(NSVGparser* p, const char** attr, int closeFlag)
{
	int i;
	const char* s;
	double args[2];
	int nargs, npts = 0;
	char item[64];

	nsvg__resetPath(p);

	for (i = 0; attr[i]; i += 2) {
		if (!nsvg__parseAttr(p, attr[i], attr[i + 1])) {
			if (strcmp(attr[i], "points") == 0) {
				s = attr[i + 1];
				nargs = 0;
				while (*s) {
					s = nsvg__getNextPathItem(s, item);
					args[nargs++] = (double)nsvg__atof(item);
					if (nargs >= 2) {
						if (npts == 0)
							nsvg__moveTo(p, args[0], args[1]);
						else
							nsvg__lineTo(p, args[0], args[1]);
						nargs = 0;
						npts++;
					}
				}
			}
		}
	}

	nsvg__addPath(p, (char)closeFlag);

	nsvg__addShape(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, 0x1c(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x31ccf
xorl %ebp, %ebp
leaq 0x77cd(%rip), %r15      # 0x37f2c
leaq 0x30(%rsp), %r12
movl $0x0, 0xc(%rsp)
movq %rbx, 0x10(%rsp)
movq (%r14,%rbp,8), %rsi
testq %rsi, %rsi
je 0x30831
movq 0x8(%r14,%rbp,8), %rdx
movq %rbx, %rdi
callq 0x30855
testl %eax, %eax
jne 0x30828
movq (%r14,%rbp,8), %rdi
movq %r15, %rsi
callq 0x85d0
testl %eax, %eax
jne 0x30828
movq %rbp, %rax
orq $0x1, %rax
movq (%r14,%rax,8), %r13
movb $0x1, %bl
leaq 0x20(%rsp), %r15
cmpb $0x0, (%r13)
je 0x3081c
movq %r13, %rdi
movq %r12, %rsi
callq 0x31cf2
movq %rax, %r13
movq %r12, %rdi
callq 0x31892
movsd %xmm0, (%r15)
leaq 0x28(%rsp), %r15
testb $0x1, %bl
movl $0x0, %ebx
jne 0x307b9
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movl 0xc(%rsp), %ebx
testl %ebx, %ebx
je 0x3080a
movq 0x10(%rsp), %rdi
callq 0x32472
jmp 0x30814
movq 0x10(%rsp), %rdi
callq 0x320d6
incl %ebx
movl %ebx, 0xc(%rsp)
jmp 0x307b2
movq 0x10(%rsp), %rbx
leaq 0x7704(%rip), %r15      # 0x37f2c
addq $0x2, %rbp
jmp 0x30771
movsbl 0x1c(%rsp), %esi
movq %rbx, %rdi
callq 0x31dbb
movq %rbx, %rdi
callq 0x3210c
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseCoordinateRaw(char const*)
static NSVGcoordinate nsvg__parseCoordinateRaw(const char* str)
{
	NSVGcoordinate coord = {0, NSVG_UNITS_USER};
	char buf[64];
	coord.units = nsvg__parseUnits(nsvg__parseNumber(str, buf, 64));
	coord.value = nsvg__atof(buf);
	return coord;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsp, %rsi
callq 0x31bff
movzbl (%rax), %ecx
cmpl $0x25, %ecx
je 0x31407
cmpl $0x63, %ecx
je 0x313f9
cmpl $0x65, %ecx
je 0x313ce
cmpl $0x69, %ecx
je 0x313ef
cmpl $0x6d, %ecx
je 0x313e5
cmpl $0x70, %ecx
jne 0x31403
movzbl 0x1(%rax), %eax
cmpl $0x63, %eax
je 0x3140f
cmpl $0x74, %eax
je 0x3140b
cmpl $0x78, %eax
jne 0x31403
pushq $0x1
jmp 0x31411
movb 0x1(%rax), %al
xorl %ecx, %ecx
cmpb $0x78, %al
sete %cl
leal (%rcx,%rcx,8), %ecx
cmpb $0x6d, %al
pushq $0x8
popq %rbx
cmovnel %ecx, %ebx
jmp 0x31412
cmpb $0x6d, 0x1(%rax)
jne 0x31403
pushq $0x4
jmp 0x31411
cmpb $0x6e, 0x1(%rax)
jne 0x31403
pushq $0x6
jmp 0x31411
cmpb $0x6d, 0x1(%rax)
jne 0x31403
pushq $0x5
jmp 0x31411
xorl %ebx, %ebx
jmp 0x31412
pushq $0x7
jmp 0x31411
pushq $0x2
jmp 0x31411
pushq $0x3
popq %rbx
movq %rsp, %rdi
callq 0x31892
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseStyle(NSVGparser*, char const*)
static void nsvg__parseStyle(NSVGparser* p, const char* str)
{
	const char* start;
	const char* end;

	while (*str) {
		// Left Trim
		while(*str && nsvg__isspace(*str)) ++str;
		start = str;
		while(*str && *str != ';') ++str;
		end = str;

		// Right Trim
		while (end > start &&  (*end == ';' || nsvg__isspace(*end))) --end;
		++end;

		nsvg__parseNameValue(p, start, end);
		if (*str) ++str;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
pushq $-0x1
popq %r12
movb (%r15), %bpl
testb %bpl, %bpl
je 0x315a1
testb %bpl, %bpl
je 0x31466
movsbl %bpl, %edi
callq 0x30174
testl %eax, %eax
je 0x31466
movb 0x1(%r15), %bpl
incq %r15
jmp 0x3144b
movl %r12d, %ebx
movq %r15, %r14
cmpb $0x3b, %bpl
je 0x31485
movzbl %bpl, %eax
testl %eax, %eax
je 0x31485
movb 0x1(%r14), %bpl
incq %r14
decl %ebx
jmp 0x3146c
movq %r14, (%rsp)
cmpq %r15, %r14
jbe 0x314a8
movb (%r14), %al
cmpb $0x3b, %al
je 0x314a1
movsbl %al, %edi
callq 0x30174
testl %eax, %eax
je 0x314a8
decq %r14
incl %ebx
jmp 0x31489
incq %r14
movl %r12d, %ebp
movq %r15, %r12
cmpq %r14, %r12
jae 0x314c6
cmpb $0x3a, (%r12)
je 0x314c6
incq %r12
decl %ebp
incl %ebx
jmp 0x314b1
movq %r12, %r13
cmpq %r15, %r13
jbe 0x314e9
movb (%r13), %al
cmpb $0x3a, %al
je 0x314e2
movsbl %al, %edi
callq 0x30174
testl %eax, %eax
je 0x314e9
decq %r13
incl %ebp
jmp 0x314c9
movl %ebp, %eax
negl %eax
movl $0x1ff, %r13d           # imm = 0x1FF
cmpl %r13d, %eax
cmovgel %r13d, %eax
testl %ebp, %ebp
je 0x31516
movslq %eax, %rbp
leaq 0x210(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x83a0
jmp 0x31518
movl %eax, %ebp
movb $0x0, 0x210(%rsp,%rbp)
cmpq %r14, %r12
jae 0x31540
movb (%r12), %al
cmpb $0x3a, %al
je 0x31539
movsbl %al, %edi
callq 0x30174
testl %eax, %eax
je 0x31540
incq %r12
incl %ebx
jmp 0x31520
movl %ebx, %eax
negl %eax
cmpl %r13d, %eax
cmovgel %r13d, %eax
testl %ebx, %ebx
je 0x3156b
movslq %eax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x83a0
pushq $-0x1
popq %r12
jmp 0x31576
movl %eax, %ebx
pushq $-0x1
popq %r12
leaq 0x10(%rsp), %r14
movb $0x0, 0x10(%rsp,%rbx)
movq 0x8(%rsp), %rdi
leaq 0x210(%rsp), %rsi
movq %r14, %rdx
callq 0x30855
movq (%rsp), %r15
cmpb $0x1, (%r15)
sbbq $-0x1, %r15
jmp 0x3143f
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseUrl(char*, char const*)
static void nsvg__parseUrl(char* id, const char* str)
{
	int i = 0;
	str += 4; // "url(";
	if (*str == '#')
		str++;
	while (i < 63 && *str != ')') {
		id[i] = *str++;
		i++;
	}
	id[i] = '\0';
}

// Assembly:
leaq 0x4(%rsi), %rax
cmpb $0x23, 0x4(%rsi)
leaq 0x5(%rsi), %rcx
cmoveq %rcx, %rax
xorl %ecx, %ecx
cmpq $0x3f, %rcx
je 0x315db
movb (%rax,%rcx), %dl
cmpb $0x29, %dl
je 0x315db
movb %dl, (%rdi,%rcx)
incq %rcx
jmp 0x315c5
movb $0x0, (%rdi,%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseColor(char const*)
static unsigned int nsvg__parseColor(const char* str)
{
	size_t len = 0;
	while(*str == ' ') ++str;
	len = strlen(str);
	if (len >= 1 && *str == '#')
		return nsvg__parseColorHex(str);
	else if (len >= 4 && str[0] == 'r' && str[1] == 'g' && str[2] == 'b' && str[3] == '(')
		return nsvg__parseColorRGB(str);
	return nsvg__parseColorName(str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movb (%rbx), %bpl
incq %rbx
cmpb $0x20, %bpl
je 0x315ed
leaq -0x1(%rbx), %r14
movq %r14, %rdi
callq 0x81b0
testq %rax, %rax
sete %cl
cmpb $0x23, %bpl
setne %dl
orb %cl, %dl
jne 0x3163f
andl $0x0, 0x20(%rsp)
xorl %r14d, %r14d
movb (%rbx,%r14), %al
testb %al, %al
je 0x31714
movsbl %al, %edi
callq 0x30174
testl %eax, %eax
jne 0x31714
incq %r14
jmp 0x3161e
cmpq $0x4, %rax
setb %al
cmpb $0x72, %bpl
setne %cl
orb %al, %cl
jne 0x31744
cmpb $0x67, (%rbx)
jne 0x31744
cmpb $0x62, 0x1(%rbx)
jne 0x31744
cmpb $0x28, 0x2(%rbx)
jne 0x31744
leaq 0x1c(%rsp), %r14
orl $-0x1, (%r14)
leaq 0x18(%rsp), %r8
orl $-0x1, (%r8)
leaq 0x14(%rsp), %rax
orl $-0x1, (%rax)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0x40(%rsp), %r9
movaps %xmm0, 0x10(%r9)
movaps %xmm0, (%r9)
addq $0x3, %rbx
movq %rax, (%rsp)
leaq 0x6781(%rip), %rsi      # 0x37e3b
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x8410
pushq $0x25
popq %rsi
movq %r15, %rdi
callq 0x8160
movl (%r14), %edx
testq %rax, %rax
je 0x317db
imull $0xff, %edx, %eax
pushq $0x64
popq %rdi
xorl %edx, %edx
divl %edi
movl %eax, %esi
imull $0xff, 0x18(%rsp), %eax
xorl %edx, %edx
divl %edi
movl %eax, %ecx
shll $0x8, %ecx
orl %esi, %ecx
imull $0xff, 0x14(%rsp), %eax
xorl %edx, %edx
divl %edi
jmp 0x317e8
cmpl $0x3, %r14d
je 0x3177b
xorl %eax, %eax
cmpl $0x6, %r14d
jne 0x317b6
leaq 0x670b(%rip), %rsi      # 0x37e38
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x8410
movl (%r14), %eax
jmp 0x317b6
xorl %ecx, %ecx
leaq 0x1c103(%rip), %rbx     # 0x4d850
leaq 0x10(%rcx), %r15
cmpq $0xb0, %r15
je 0x31774
movq (%rcx,%rbx), %rdi
movq %r14, %rsi
callq 0x85d0
movq %r15, %rcx
testl %eax, %eax
jne 0x3174d
movl -0x8(%r15,%rbx), %eax
jmp 0x317d0
movl $0x808080, %eax         # imm = 0x808080
jmp 0x317d0
leaq 0x66b6(%rip), %rsi      # 0x37e38
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x8410
movl (%r14), %eax
movl %eax, %ecx
andl $0xf, %ecx
movl %eax, %edx
shll $0x4, %edx
andl $0xf00, %edx            # imm = 0xF00
orl %ecx, %edx
shll $0x8, %eax
andl $0xf0000, %eax          # imm = 0xF0000
orl %edx, %eax
imull $0x11, %eax, %eax
movl %eax, %ecx
shrl $0x10, %ecx
movzbl %cl, %ecx
movl %eax, %edx
andl $0xff00, %edx           # imm = 0xFF00
orl %ecx, %edx
movzbl %al, %eax
shll $0x10, %eax
orl %edx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%rsp), %ecx
shll $0x8, %ecx
orl %edx, %ecx
movl 0x14(%rsp), %eax
shll $0x10, %eax
orl %ecx, %eax
jmp 0x317d0
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseOpacity(char const*)
static double nsvg__parseOpacity(const char* str)
{
	double val = nsvg__atof(str);
	if (val < 0.0) val = 0.0;
	if (val > 1.0) val = 1.0;
	return val;
}

// Assembly:
pushq %rax
callq 0x31892
xorpd %xmm1, %xmm1
maxsd %xmm0, %xmm1
movsd 0x2803(%rip), %xmm0     # 0x34008
minsd %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__atof(char const*)
static double nsvg__atof(const char* s)
{
	char* cur = (char*)s;
	char* end = NULL;
	double res = 0.0, sign = 1.0;
	long long intPart = 0, fracPart = 0;
	char hasIntPart = 0, hasFracPart = 0;

	// Parse optional sign
	if (*cur == '+') {
		cur++;
	} else if (*cur == '-') {
		sign = -1;
		cur++;
	}

	// Parse integer part
	if (nsvg__isdigit(*cur)) {
		// Parse digit sequence
		intPart = (double)strtoll(cur, &end, 10);
		if (cur != end) {
			res = (double)intPart;
			hasIntPart = 1;
			cur = end;
		}
	}

	// Parse fractional part.
	if (*cur == '.') {
		cur++; // Skip '.'
		if (nsvg__isdigit(*cur)) {
			// Parse digit sequence
			fracPart = strtoll(cur, &end, 10);
			if (cur != end) {
				res += (double)fracPart / pow(10.0, (double)(end - cur));
				hasFracPart = 1;
				cur = end;
			}
		}
	}

	// A valid number should have integer or fractional part.
	if (!hasIntPart && !hasFracPart)
		return 0.0;

	// Parse optional exponent
	if (*cur == 'e' || *cur == 'E') {
		int expPart = 0;
		cur++; // skip 'E'
		expPart = strtol(cur, &end, 10); // Parse digit sequence with sign
		if (cur != end) {
			res *= pow(10.0, (double)expPart);
		}
	}

	return res * sign;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
andq $0x0, 0x8(%rsp)
movq %rdi, %r14
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x318c3
movsd 0x2755(%rip), %xmm0     # 0x34008
movsd %xmm0, 0x10(%rsp)
cmpl $0x2b, %eax
jne 0x318d4
incq %r14
jmp 0x318d4
incq %r14
movsd 0x48d2(%rip), %xmm0     # 0x361a0
movsd %xmm0, 0x10(%rsp)
movb (%r14), %al
leal -0x3a(%rax), %ecx
cmpb $-0xa, %cl
jae 0x318ea
xorpd %xmm1, %xmm1
xorl %ebp, %ebp
movq %r14, %rbx
jmp 0x31920
leaq 0x8(%rsp), %rbx
pushq $0xa
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x80b0
movq (%rbx), %rbx
cmpq %rbx, %r14
setne %bpl
jne 0x3190f
xorpd %xmm1, %xmm1
jmp 0x3191e
cvtsi2sd %rax, %xmm0
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm1
movb (%rbx), %al
cmpb $0x2e, %al
jne 0x3198d
movb 0x1(%rbx), %al
incq %rbx
addb $-0x3a, %al
cmpb $-0xa, %al
jb 0x3198d
movsd %xmm1, (%rsp)
leaq 0x8(%rsp), %r14
pushq $0xa
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x80b0
movq (%r14), %r14
cmpq %r14, %rbx
je 0x31988
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r14, %rax
subq %rbx, %rax
cvtsi2sd %rax, %xmm1
movsd 0x26aa(%rip), %xmm0     # 0x34018
callq 0x8750
movsd 0x18(%rsp), %xmm2
divsd %xmm0, %xmm2
movsd (%rsp), %xmm1
addsd %xmm2, %xmm1
jmp 0x31999
movsd (%rsp), %xmm1
xorpd %xmm0, %xmm0
movq %rbx, %r14
testb %bpl, %bpl
je 0x319f0
movzbl (%r14), %eax
orl $0x20, %eax
cmpl $0x65, %eax
jne 0x319e6
movsd %xmm1, (%rsp)
incq %r14
leaq 0x8(%rsp), %rbx
pushq $0xa
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x85e0
cmpq (%rbx), %r14
je 0x319e1
cvtsi2sd %eax, %xmm1
movsd 0x2647(%rip), %xmm0     # 0x34018
callq 0x8750
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
jmp 0x319e6
movsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__convertToPixels(NSVGparser*, NSVGcoordinate, double, double)
static double nsvg__convertToPixels(NSVGparser* p, NSVGcoordinate c, double orig, double length)
{
	NSVGattrib* attr = nsvg__getAttr(p);
	switch (c.units) {
		case NSVG_UNITS_USER:		return c.value;
		case NSVG_UNITS_PX:			return c.value;
		case NSVG_UNITS_PT:			return c.value / 72.0 * p->dpi;
		case NSVG_UNITS_PC:			return c.value / 6.0 * p->dpi;
		case NSVG_UNITS_MM:			return c.value / 25.4 * p->dpi;
		case NSVG_UNITS_CM:			return c.value / 2.54 * p->dpi;
		case NSVG_UNITS_IN:			return c.value * p->dpi;
		case NSVG_UNITS_EM:			return c.value * attr->fontSize;
		case NSVG_UNITS_EX:			return c.value * attr->fontSize * 0.52; // x-height of Helvetica.
		case NSVG_UNITS_PERCENT:	return orig + c.value / 100.0 * length;
		default:					return c.value;
	}
	return c.value;
}

// Assembly:
addl $-0x2, %esi
cmpl $0x7, %esi
ja 0x31a72
movslq 0xd000(%rdi), %rax
imulq $0x1a0, %rax, %rax      # imm = 0x1A0
addq %rdi, %rax
leaq 0x496f(%rip), %rcx      # 0x36388
movslq (%rcx,%rsi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
divsd 0x4856(%rip), %xmm0     # 0x36280
jmp 0x31a48
divsd 0x4844(%rip), %xmm0     # 0x36278
jmp 0x31a48
divsd 0x4652(%rip), %xmm0     # 0x36090
jmp 0x31a48
divsd 0x47d0(%rip), %xmm0     # 0x36218
mulsd 0xd080(%rdi), %xmm0
retq
mulsd 0x178(%rax), %xmm0
mulsd 0x4827(%rip), %xmm0     # 0x36288
retq
divsd 0x47f6(%rip), %xmm0     # 0x36260
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
retq
mulsd 0x178(%rax), %xmm0
retq