LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::Reverse()
void Polygon::Reverse(void)
{
    if ( poly_clockwise < 0) return;    //  Oups OK before entering
    if ( poly_clockwise == 0 ) return;  //  Oups not known, unable to change
    for ( int i = 0, j = nVertices-1; i < j ; i++, j--)
    {
        Point p = _Vertices[i];
        _Vertices[i] = _Vertices[j];
        _Vertices[j] = p;
    }
    poly_clockwise = -1;
}

// Assembly:
cmpl $0x0, 0x94(%rdi)
jle 0x26bed
movslq 0x8(%rdi), %rax
cmpq $0x2, %rax
jl 0x26be3
movq %rax, %rcx
shlq $0x4, %rcx
addq $-0x10, %rcx
addq $-0x2, %rax
xorl %edx, %edx
xorl %esi, %esi
movq 0x10(%rdi), %r8
movups (%r8,%rdx), %xmm0
movaps %xmm0, -0x18(%rsp)
movups (%r8,%rcx), %xmm0
movups %xmm0, (%r8,%rdx)
movq 0x10(%rdi), %r8
movaps -0x18(%rsp), %xmm0
movups %xmm0, (%r8,%rcx)
incq %rsi
addq $0x10, %rdx
addq $-0x10, %rcx
leaq -0x1(%rax), %r8
cmpq %rax, %rsi
movq %r8, %rax
jl 0x26ba6
movl $0xffffffff, 0x94(%rdi) # imm = 0xFFFFFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O1/thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::setStartPointMinY()
void Polygon::setStartPointMinY()
{
    double ymin = 1e30;
    int idxmin = 0;
    for ( int i = 0; i < nVertices-1; i++)
    {
        if ( _Vertices[i].y < ymin )
        {
            ymin = _Vertices[i].y;
            idxmin = i;
        }
    }
    if ( idxmin == 0 ) return;      //  Already ordered, return;
    //  Create a new vector
    std::vector<Point>  tmp_vertices;
    for ( int i = 0; i < nVertices - 1; i++)
    {
        tmp_vertices.push_back(_Vertices[(i + idxmin)%(nVertices-1)]);
    }
    tmp_vertices[nVertices-1] = tmp_vertices[0];
    for ( int i = 0; i < nVertices; i++)
    {
        _Vertices[i] = tmp_vertices[i];
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %eax
xorl %r15d, %r15d
cmpl $0x2, %eax
jl 0x26c3e
decl %eax
movq 0x10(%rbx), %rcx
addq $0x8, %rcx
xorl %edx, %edx
movsd 0x184a5(%rip), %xmm0    # 0x3f0c0
xorl %r15d, %r15d
movsd (%rcx), %xmm1
ucomisd %xmm1, %xmm0
cmoval %edx, %r15d
minsd %xmm0, %xmm1
incq %rdx
addq $0x10, %rcx
movapd %xmm1, %xmm0
cmpq %rdx, %rax
jne 0x26c1e
testl %r15d, %r15d
je 0x26d03
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movl 0x8(%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %eax
jl 0x26cad
xorl %r12d, %r12d
movq %rsp, %r14
leal (%r15,%r12), %eax
cltd
idivl %ecx
movslq %edx, %rdx
shlq $0x4, %rdx
addq 0x10(%rbx), %rdx
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x26c98
movupd (%rdx), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x8(%rsp)
jmp 0x26ca0
movq %r14, %rdi
callq 0x25c6c
incl %r12d
movl 0x8(%rbx), %ecx
decl %ecx
cmpl %ecx, %r12d
jl 0x26c6a
movq (%rsp), %rax
movslq %ecx, %rcx
shlq $0x4, %rcx
movupd (%rax), %xmm0
movupd %xmm0, (%rax,%rcx)
cmpl $0x0, 0x8(%rbx)
jle 0x26ced
xorl %eax, %eax
xorl %ecx, %ecx
movq (%rsp), %rdx
movq 0x10(%rbx), %rsi
movupd (%rdx,%rax), %xmm0
movupd %xmm0, (%rsi,%rax)
incq %rcx
movslq 0x8(%rbx), %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
jl 0x26ccb
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x26d03
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x26d28
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
movq %rbx, %rdi
callq 0x7730
// File: /workspace/github_cpp_makefile_star2_O1/thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::delVertex(int)
void Polygon::delVertex(int index)
{
    if ( nVertices > 3 )
    {
        _Vertices.erase(_Vertices.begin()+index);
        nVertices = _Vertices.size();
        poly_changed = 1;
        poly_centroid_ok = 0;
    }
}

// Assembly:
cmpl $0x4, 0x8(%rdi)
jl 0x2821b
pushq %rbx
movq %rdi, %rbx
movslq %esi, %rax
shlq $0x4, %rax
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rdx
leaq (%rdi,%rax), %rsi
addq $0x10, %rsi
cmpq %rdx, %rsi
je 0x281ef
addq %rax, %rdi
subq %rsi, %rdx
callq 0x7690
movq 0x18(%rbx), %rax
addq $-0x10, %rax
movq %rax, 0x18(%rbx)
subq 0x10(%rbx), %rax
shrq $0x4, %rax
movl %eax, 0x8(%rbx)
movl $0x1, 0x9c(%rbx)
movl $0x0, 0x90(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movsd 0x58(%rsi), %xmm0
movsd 0xa0(%rsi), %xmm1
divsd 0x16e92(%rip), %xmm1    # 0x3f0e0
subsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd 0x60(%rsi), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x68(%rsi), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdi)
addsd 0x70(%rsi), %xmm1
movsd %xmm1, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movl $0xc0, %edi
callq 0x7430
movq %rax, %rbx
leaq 0x299ff(%rip), %rax     # 0x51ca0
movq %rax, (%rbx)
leaq 0x10(%rbx), %r15
xorl %ebp, %ebp
movl %ebp, 0x8(%rbx)
movl $0x8c, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x7270
xorps %xmm0, %xmm0
movups %xmm0, 0xb0(%rbx)
movl $0x1, 0x9c(%rbx)
movq $0x0, 0xa8(%rbx)
movabsq $0x3f1a36e2eb1c432d, %rax # imm = 0x3F1A36E2EB1C432D
movq %rax, 0xa0(%rbx)
movl %ebp, 0xc(%rbx)
incq 0x2a70a(%rip)           # 0x52a00
incq 0x2a733(%rip)           # 0x52a30
addq $0x10, %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x258e6
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a20e
movq (%r12), %rdi
testq %rdi, %rdi
je 0x28332
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x7440
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rax
subq %rsi, %rax
shrq $0x4, %rax
movl %eax, 0x8(%rbx)
cltq
shlq $0x4, %rax
movsd 0x8(%rsi), %xmm0
movsd -0x8(%rsi,%rax), %xmm1
movsd -0x10(%rsi,%rax), %xmm2
movsd (%rsi), %xmm3
cmpeqpd %xmm2, %xmm3
cmpeqpd %xmm0, %xmm1
andpd %xmm3, %xmm1
movq %xmm1, %rax
movl %eax, %ecx
andl $0x1, %ecx
movl %ecx, 0x98(%rbx)
testb $0x1, %al
jne 0x28389
movq %rbx, %rdi
callq 0x266b0
movq %rbx, %rdi
callq 0x27c90
movl $0x1, 0x9c(%rbx)
movq %rbx, %rdi
callq 0x26926
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::getCentroid()
Point Polygon::getCentroid()
{
double p_area;
double cx = 0, cy = 0;

    if ( poly_changed ) poly_centroid_ok = 0;
    if ( poly_centroid_ok == 0 )    //  Not yet computed, do it
    {
        p_area = area();
        for ( int i = 0; i < nVertices - 1; i++)
        {
            double d = _Vertices[i].x*_Vertices[i+1].y - _Vertices[i+1].x*_Vertices[i].y;
            cx += (_Vertices[i].x + _Vertices[i+1].x)*d;
            cy += (_Vertices[i].y + _Vertices[i+1].y)*d;
        }
        cx /= 6*p_area;
        cy /= 6*p_area;
        poly_centroid = Point(cx, cy);
        poly_centroid_ok = 1;
    }
    return poly_centroid;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x9c(%rdi)
je 0x283cb
movl $0x0, 0x90(%rbx)
cmpl $0x0, 0x90(%rbx)
jne 0x2846e
movq %rbx, %rdi
callq 0x26926
movl 0x8(%rbx), %eax
xorpd %xmm2, %xmm2
xorpd %xmm1, %xmm1
cmpl $0x2, %eax
jl 0x28444
decl %eax
movq 0x10(%rbx), %rcx
shlq $0x4, %rax
xorl %edx, %edx
movsd 0x18(%rcx,%rdx), %xmm3
movsd 0x10(%rcx,%rdx), %xmm4
movsd (%rcx,%rdx), %xmm5
movsd 0x8(%rcx,%rdx), %xmm6
movapd %xmm5, %xmm7
mulsd %xmm3, %xmm7
addsd %xmm6, %xmm3
mulsd %xmm4, %xmm6
subsd %xmm6, %xmm7
addsd %xmm4, %xmm5
mulsd %xmm7, %xmm5
addsd %xmm5, %xmm1
mulsd %xmm7, %xmm3
addsd %xmm3, %xmm2
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0x283fc
mulsd 0x16ca4(%rip), %xmm0    # 0x3f0f0
divsd %xmm0, %xmm1
divsd %xmm0, %xmm2
movsd %xmm1, 0x80(%rbx)
movsd %xmm2, 0x88(%rbx)
movl $0x1, 0x90(%rbx)
movsd 0x80(%rbx), %xmm0
movsd 0x88(%rbx), %xmm1
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $0x0, (%rdx)
movq %rbx, %rdi
callq 0x29f3c
movl 0x8(%r14), %eax
cmpl $0x2, %eax
jl 0x28fac
movl $0x18, %r15d
xorl %r12d, %r12d
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 0x7090
movq 0x40(%r14), %rax
movsd %xmm0, (%rax,%r12,8)
movslq 0x8(%r14), %rax
decq %rax
addq $0x10, %r15
movq %r13, %r12
cmpq %rax, %r13
jl 0x28f64
jmp 0x28fae
decl %eax
cltq
movq (%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x297a5
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movsd 0x60(%rsi), %xmm0
ucomisd 0x60(%rdi), %xmm0
ja 0x2979d
movsd 0x68(%rdi), %xmm0
ucomisd 0x68(%rbx), %xmm0
ja 0x2979d
movsd 0x70(%rdi), %xmm0
ucomisd 0x70(%rbx), %xmm0
ja 0x2979d
movslq 0x8(%rdi), %r15
testq %r15, %r15
setle %bpl
jle 0x29799
movq 0x10(%rdi), %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x27d3a
testl %eax, %eax
jle 0x29799
addq $0x10, %r14
movl $0x1, %ecx
movq %rcx, %r12
cmpq %rcx, %r15
je 0x29792
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x27d3a
leaq 0x1(%r12), %rcx
addq $0x10, %r14
testl %eax, %eax
jg 0x29770
cmpq %r15, %r12
setae %bpl
movzbl %bpl, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rcx, %rcx
je 0x29f78
movb $0x0, (%rcx)
movsd (%rsi), %xmm2
movsd 0x8(%rsi), %xmm3
movsd (%rdi), %xmm5
movsd 0x8(%rdi), %xmm8
movapd %xmm3, %xmm0
mulsd %xmm5, %xmm0
movapd %xmm2, %xmm7
mulsd %xmm8, %xmm7
subsd %xmm0, %xmm7
movapd 0x15088(%rip), %xmm6    # 0x3f030
andpd %xmm7, %xmm6
xorpd %xmm1, %xmm1
movsd 0x15110(%rip), %xmm4    # 0x3f0c8
ucomisd %xmm6, %xmm4
xorpd %xmm0, %xmm0
ja 0x29ff8
movsd 0x10(%rdi), %xmm1
movsd 0x10(%rsi), %xmm9
mulsd %xmm9, %xmm8
movapd %xmm3, %xmm0
mulsd %xmm1, %xmm0
subsd %xmm8, %xmm0
divsd %xmm7, %xmm0
mulsd %xmm2, %xmm1
mulsd %xmm9, %xmm5
subsd %xmm1, %xmm5
divsd %xmm7, %xmm5
movapd %xmm5, %xmm1
ucomisd %xmm6, %xmm4
ja 0x2a116
testq %rdx, %rdx
je 0x2a010
movsd %xmm0, (%rdx)
movsd %xmm1, 0x8(%rdx)
movsd 0x38(%rdi), %xmm2
xorl %eax, %eax
ucomisd %xmm0, %xmm2
ja 0x2a141
ucomisd 0x40(%rdi), %xmm0
ja 0x2a141
movsd 0x48(%rdi), %xmm2
ucomisd %xmm1, %xmm2
ja 0x2a141
ucomisd 0x50(%rdi), %xmm1
ja 0x2a141
movapd %xmm0, %xmm3
subsd 0x18(%rdi), %xmm3
movapd 0x14fd9(%rip), %xmm2    # 0x3f030
andpd %xmm2, %xmm3
movapd %xmm1, %xmm4
subsd 0x28(%rdi), %xmm4
andpd %xmm2, %xmm4
addsd %xmm3, %xmm4
movsd 0x15084(%rip), %xmm3    # 0x3f0f8
ucomisd %xmm4, %xmm3
ja 0x2a141
movapd %xmm0, %xmm4
subsd 0x20(%rdi), %xmm4
andpd %xmm2, %xmm4
movapd %xmm1, %xmm5
subsd 0x30(%rdi), %xmm5
andpd %xmm2, %xmm5
addsd %xmm4, %xmm5
ucomisd %xmm5, %xmm3
ja 0x2a141
movsd 0x38(%rsi), %xmm4
ucomisd %xmm0, %xmm4
ja 0x2a141
ucomisd 0x40(%rsi), %xmm0
ja 0x2a141
movsd 0x48(%rsi), %xmm4
ucomisd %xmm1, %xmm4
ja 0x2a141
ucomisd 0x50(%rsi), %xmm1
ja 0x2a141
movapd %xmm0, %xmm4
subsd 0x18(%rsi), %xmm4
andpd %xmm2, %xmm4
movapd %xmm1, %xmm5
subsd 0x28(%rsi), %xmm5
andpd %xmm2, %xmm5
addsd %xmm4, %xmm5
ucomisd %xmm5, %xmm3
ja 0x2a141
subsd 0x20(%rsi), %xmm0
subsd 0x30(%rsi), %xmm1
andpd %xmm2, %xmm0
andpd %xmm2, %xmm1
addsd %xmm0, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm3
setbe %al
retq
xorl %eax, %eax
testq %rcx, %rcx
je 0x2a141
mulsd 0x28(%rdi), %xmm3
mulsd 0x18(%rdi), %xmm2
addsd %xmm3, %xmm2
addsd 0x10(%rsi), %xmm2
andpd 0x14ef8(%rip), %xmm2    # 0x3f030
ucomisd %xmm2, %xmm4
jbe 0x2a141
movb $0x1, (%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xd090, %edi           # imm = 0xD090
callq 0x7580
testq %rax, %rax
je 0x2aa5e
movq %rax, %rbx
movl $0xd090, %edx           # imm = 0xD090
movq %rax, %rdi
xorl %esi, %esi
callq 0x7270
movl $0x18, %edi
callq 0x7580
movq %rax, 0xd038(%rbx)
testq %rax, %rax
je 0x2aa56
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x40(%rbx)
movups %xmm0, 0x48(%rbx)
movq %rax, 0x58(%rbx)
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rcx, 0x70(%rbx)
movq %rax, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
movq %rax, 0x188(%rbx)
movq %rax, 0x110(%rbx)
movw $0x0, 0x164(%rbx)
movabsq $0x4010000000000000, %rax # imm = 0x4010000000000000
movq %rax, 0x168(%rbx)
movb $0x0, 0x170(%rbx)
movb $0x1, %al
movb %al, 0x198(%rbx)
movb %al, 0x19a(%rbx)
jmp 0x2aa60
movq %rbx, %rdi
callq 0x7520
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x2ab2e
movsd (%rsp), %xmm0
movsd %xmm0, 0xd080(%rbx)
leaq 0xc3(%rip), %rsi        # 0x2ab40
leaq 0x242d(%rip), %rdx      # 0x2ceb1
leaq 0x2495(%rip), %rcx      # 0x2cf20
movq %r14, %rdi
movq %rbx, %r8
callq 0x2a620
movq 0xd030(%rbx), %rdi
movq 0xd038(%rbx), %r14
movq $0x0, 0xd038(%rbx)
callq 0x2d052
movq 0xd040(%rbx), %r15
testq %r15, %r15
je 0x2aae3
movq 0x118(%r15), %rdi
movq 0x120(%r15), %r12
callq 0x7520
movq %r15, %rdi
callq 0x7520
movq %r12, %r15
testq %r12, %r12
jne 0x2aac0
movq 0xd038(%rbx), %rdi
callq 0x2cfe5
leaq 0xd008(%rbx), %r15
movq 0xd008(%rbx), %rdi
testq %rdi, %rdi
je 0x2ab13
movq 0x38(%rdi), %r12
callq 0x7520
movq %r12, %rdi
testq %r12, %r12
jne 0x2ab02
movl $0x0, 0xd028(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq %rbx, %rdi
callq 0x7520
jmp 0x2ab31
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x1060c(%rip), %rsi     # 0x3d4ce
movq %r14, %rdi
callq 0x7590
testl %eax, %eax
je 0x2cefd
leaq 0x12a48(%rip), %rsi     # 0x3f91d
movq %r14, %rdi
callq 0x7590
testl %eax, %eax
je 0x2cf11
leaq 0x13d3e(%rip), %rsi     # 0x40c26
movq %r14, %rdi
callq 0x7590
testl %eax, %eax
jne 0x2cf18
movb $0x0, 0xd089(%rbx)
jmp 0x2cf18
movl 0xd000(%rbx), %eax
testl %eax, %eax
jle 0x2cf18
decl %eax
movl %eax, 0xd000(%rbx)
jmp 0x2cf18
movb $0x0, 0xd088(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
leaq 0x12508(%rip), %rsi     # 0x3f43d
callq 0x7510
movq %rax, %rbx
xorl %r14d, %r14d
testq %rax, %rax
je 0x2cfba
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x7490
movq %rbx, %rdi
callq 0x7030
movq %rax, %r12
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7490
leaq 0x1(%r12), %rdi
callq 0x7580
testq %rax, %rax
je 0x2cfba
movq %rax, %r15
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x7610
cmpq %r12, %rax
jne 0x2cfb7
movb $0x0, (%r15,%r12)
movq %rbx, %rdi
callq 0x7420
movq %r15, %rdi
movsd (%rsp), %xmm0
callq 0x2a97d
movq %rax, %rbx
movq %r15, %r14
jmp 0x2cfce
movq %r15, %r14
testq %rbx, %rbx
je 0x2cfc7
movq %rbx, %rdi
callq 0x7420
xorl %ebx, %ebx
testq %r14, %r14
je 0x2cfd6
movq %r14, %rdi
callq 0x7520
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d051
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x2d044
movq 0xf0(%r14), %rdi
movq 0xf8(%r14), %r15
callq 0x2d052
movb 0x40(%r14), %al
andb $-0x2, %al
cmpb $0x2, %al
jne 0x2d021
movq 0x48(%r14), %rdi
callq 0x7520
movb 0x50(%r14), %al
andb $-0x2, %al
cmpb $0x2, %al
jne 0x2d034
movq 0x58(%r14), %rdi
callq 0x7520
movq %r14, %rdi
callq 0x7520
movq %r15, %r14
testq %r15, %r15
jne 0x2cffb
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7520
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x2d092
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rbx), %rdi
movq 0x48(%rbx), %r14
testq %rdi, %rdi
je 0x2d07d
movq 0x38(%rdi), %r15
callq 0x7520
movq %r15, %rdi
testq %r15, %r15
jne 0x2d06c
movq %rbx, %rdi
callq 0x7520
movq %r14, %rbx
testq %r14, %r14
jne 0x2d05f
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x22cd8(%rip), %rax     # 0x51cd0
movq %rax, (%rdi)
leaq 0x20(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %r13, 0x20(%rdi)
xorl %eax, %eax
movq %rax, 0x30(%rdi)
leaq 0x40(%rdi), %r14
leaq 0x50(%rdi), %rbp
movq %rbp, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb $0x0, 0x50(%rdi)
leaq 0x68(%rdi), %r15
movq %r15, %rdi
callq 0x76f0
callq 0x72e0
movq %rax, 0x268(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x7260
movq $0x0, 0x38(%rbx)
movq (%r12), %rdi
movsd 0x10160(%rip), %xmm0    # 0x3f1b8
callq 0x2cf21
movq %rax, %r12
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x2f0aa
movsd (%r12), %xmm0
mulsd 0x10149(%rip), %xmm0    # 0x3f1c0
callq 0x71c0
movsd 0x1013c(%rip), %xmm1    # 0x3f1c0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rbx)
movsd 0x8(%r12), %xmm0
mulsd %xmm1, %xmm0
callq 0x71c0
divsd 0x1011b(%rip), %xmm0    # 0x3f1c0
movsd %xmm0, 0x18(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x2a0(%rbx)
movupd %xmm0, 0x290(%rbx)
movupd %xmm0, 0x280(%rbx)
movupd %xmm0, 0x270(%rbx)
movq $0x0, 0x2b0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2f0f8
movq %rax, %rbx
movq %r15, %rdi
callq 0x7600
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x2f10c
movq (%rbp), %rsi
incq %rsi
callq 0x7440
movq (%r13), %rdi
cmpq %r13, %rdi
je 0x2f12a
movq (%rdi), %r14
movl $0x18, %esi
callq 0x7440
movq %r14, %rdi
cmpq %r13, %r14
jne 0x2f115
movq %rbx, %rdi
callq 0x7730
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfddd(%rip), %rsi      # 0x3fc7c
movl $0x5, %edx
movq %rbx, %rdi
callq 0x74d0
leaq 0xfaf2(%rip), %rsi      # 0x3f9a5
movl $0x23, %edx
movq %rbx, %rdi
callq 0x74d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x73f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7050
movq %rax, %rdi
callq 0x7300
leaq 0xfadb(%rip), %rsi      # 0x3f9c9
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x74d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x73f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7050
movq %rax, %rdi
callq 0x7300
leaq 0xfac0(%rip), %rsi      # 0x3f9e9
movl $0x19, %edx
movq %rbx, %rdi
callq 0x74d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x73f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7050
movq %rax, %rdi
callq 0x7300
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), %rax
movq 0x10(%rax), %r14
testq %r14, %r14
je 0x2ffd5
movq 0xf0(%r14), %r15
testq %r15, %r15
je 0x2ffcc
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2f1ee
movq 0x58(%r15), %r12
testq %r12, %r12
je 0x2ffc6
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2f1ee
movq 0x48(%r12), %r12
jmp 0x2ffac
movq 0x48(%r15), %r15
jmp 0x2ff95
movq 0xf8(%r14), %r14
jmp 0x2ff89
leaq 0xfa27(%rip), %rsi      # 0x3fa03
movl $0x6, %edx
movq %rbx, %rdi
callq 0x74d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x73f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7050
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7300
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x312f0
testb $0x1, %bpl
je 0x317b6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fe8a
testb $0x2, %bpl
je 0x317c7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3001c
testb $0x4, %bpl
je 0x317d8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3041e
testb $0x8, %bpl
je 0x317e9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3084e
testb $0x10, %bpl
je 0x317fa
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30c7e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x310ae
leaq 0xe983(%rip), %rsi      # 0x4018f
movl $0x6, %edx
movq %rbx, %rdi
callq 0x74d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x73f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x7050
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7300
// File: /workspace/github_cpp_makefile_star2_O1/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, %ebp
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rdi
callq 0x76f0
xorl %ebx, %ebx
cmpq $0x0, 0x8(%r14)
je 0x318c4
testl %r12d, %r12d
je 0x318ae
movq (%r15), %rsi
movq %rsp, %rdi
movl $0x10, %edx
callq 0x7070
leaq 0x70(%rsp), %rdi
callq 0x7110
testb %al, %al
je 0x318c4
movq %rsp, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x31794
movl $0x1, %ebx
movq %rsp, %rdi
callq 0x75c0
jmp 0x318c4
movl $0x1, %ebx
movq 0x206d6(%rip), %rsi     # 0x51f90
movq %r14, %rdi
movl %ebp, %edx
callq 0x31794
movq 0x2069d(%rip), %rax     # 0x51f68
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x7390
leaq 0xf8(%rsp), %rdi
callq 0x7160
movl %ebx, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7600
movq %rbx, %rdi
callq 0x7730
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq (%rsi), %rcx
xorl %eax, %eax
cmpq %rsi, %rcx
je 0x354b4
movq 0x10(%rcx), %rdx
movq (%rcx), %rdi
movq 0x68(%rdx), %rcx
addl 0x8(%rcx), %eax
movq %rdi, %rcx
cmpq %rsi, %rdi
jne 0x3549e
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15      # imm = 0x1A0
movq $0x0, 0x190(%rdi,%r15)
movl $0x0, 0x180(%rdi,%r15)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x188(%rdi,%r15)
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x38f8f
addq $0x10, %r14
movq -0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x39851
movq (%r14), %rsi
addq $0x10, %r14
testq %rsi, %rsi
jne 0x38f77
movq 0xd040(%rbx), %r14
testq %r14, %r14
je 0x3907a
movslq 0x110(%r14), %rsi
incq %rsi
movl %esi, 0x110(%r14)
movq 0x118(%r14), %rdi
shlq $0x4, %rsi
callq 0x76c0
movq %rax, 0x118(%r14)
testq %rax, %rax
je 0x3907a
addq %r15, %rbx
movl 0x110(%r14), %esi
leal -0x1(%rsi), %ecx
movl %ecx, %edx
cmpl $0x2, %esi
jl 0x3900c
movsd 0x190(%rbx), %xmm0
movl %ecx, %esi
addq $0x8, %rax
xorl %edx, %edx
movsd (%rax), %xmm1
ucomisd %xmm0, %xmm1
ja 0x3900c
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rsi
jne 0x38ff4
movl %ecx, %edx
movslq %edx, %rax
cmpl %edx, %ecx
jle 0x3903b
movslq %ecx, %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
movq 0x118(%r14), %rsi
movupd -0x10(%rsi,%rdx), %xmm0
movupd %xmm0, (%rsi,%rdx)
decq %rcx
addq $-0x10, %rdx
cmpq %rax, %rcx
jg 0x3901d
movq 0x118(%r14), %rcx
shlq $0x4, %rax
movl 0x180(%rbx), %edx
movl %edx, (%rcx,%rax)
movsd 0x188(%rbx), %xmm0
mulsd 0x61a9(%rip), %xmm0     # 0x3f208
cvttsd2si %xmm0, %rsi
shll $0x18, %esi
orl %edx, %esi
movl %esi, (%rcx,%rax)
movsd 0x190(%rbx), %xmm0
movsd %xmm0, 0x8(%rcx,%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %r12
testq %r12, %r12
je 0x390d5
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rbx
leaq 0x7c7c(%rip), %r15      # 0x40d1d
movq %r12, %rdi
movq %r15, %rsi
callq 0x7590
movq -0x8(%rbx), %rdx
movq %r14, %rdi
testl %eax, %eax
je 0x390c1
movq %r12, %rsi
callq 0x39851
jmp 0x390c9
movq %rdx, %rsi
callq 0x3a449
movq (%rbx), %r12
addq $0x10, %rbx
testq %r12, %r12
jne 0x390a1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0xc(%rsp)
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xd008(%rdi), %r14
movq 0xd008(%rdi), %rdi
testq %rdi, %rdi
je 0x39386
movq 0x38(%rdi), %r15
callq 0x7520
movq %r15, %rdi
testq %r15, %r15
jne 0x39375
movl $0x0, 0xd028(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq (%r13), %rsi
testq %rsi, %rsi
je 0x3948a
xorl %ebp, %ebp
leaq 0x30(%rsp), %r12
xorl %r15d, %r15d
movq %r13, 0x28(%rsp)
movq 0x8(%r13,%rbp,8), %rdx
movq %rbx, %rdi
callq 0x39851
testl %eax, %eax
jne 0x393d9
movq (%r13,%rbp,8), %rdi
leaq 0x7b1e(%rip), %rsi      # 0x40eee
callq 0x7590
testl %eax, %eax
je 0x393f1
movq 0x28(%rsp), %r13
movq 0x10(%r13,%rbp,8), %rsi
addq $0x2, %rbp
testq %rsi, %rsi
jne 0x393b3
jmp 0x3948a
movq %rbp, %rax
orq $0x1, %rax
movq (%r13,%rax,8), %r13
cmpb $0x0, (%r13)
je 0x393d9
xorl %r14d, %r14d
movq %r13, %rdi
movq %r12, %rsi
callq 0x3afff
movq %rax, %r13
movq %r12, %rdi
callq 0x3ab74
movl %r14d, %eax
movsd %xmm0, 0x10(%rsp,%rax,8)
testl %r14d, %r14d
je 0x39454
testl %r15d, %r15d
je 0x3945c
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
xorps %xmm2, %xmm2
xorps %xmm3, %xmm3
xorps %xmm4, %xmm4
xorps %xmm5, %xmm5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3b95a
jmp 0x39471
movl $0x1, %r14d
jmp 0x39477
cmpl $0x0, 0xd028(%rbx)
jg 0x39483
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0xd018(%rbx)
incl %r15d
xorl %r14d, %r14d
cmpb $0x0, (%r13)
jne 0x39407
jmp 0x393d9
callq 0x7ab9
jmp 0x39471
movsbl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x3b0ec
movq %rbx, %rdi
callq 0x3b5ad
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3af17
movzbl (%rax), %ecx
cmpl $0x68, %ecx
jg 0x3a381
cmpl $0x25, %ecx
je 0x3a3e4
cmpl $0x63, %ecx
jne 0x3a40a
movl $0x5, %ebx
cmpb $0x6d, 0x1(%rax)
je 0x3a42b
cmpl $0x25, %ecx
jne 0x3a3eb
jmp 0x3a3e4
cmpl $0x69, %ecx
je 0x3a3f5
cmpl $0x6d, %ecx
je 0x3a3c8
cmpl $0x70, %ecx
jne 0x3a429
movzbl 0x1(%rax), %edx
cmpl $0x63, %edx
je 0x3a442
cmpl $0x74, %edx
je 0x3a43b
movl $0x1, %ebx
cmpl $0x78, %edx
je 0x3a42b
cmpl $0x64, %ecx
jle 0x3a3d8
cmpl $0x65, %ecx
je 0x3a40f
cmpl $0x69, %ecx
je 0x3a3f5
cmpl $0x6d, %ecx
jne 0x3a429
movl $0x4, %ebx
cmpb $0x6d, 0x1(%rax)
je 0x3a42b
cmpl $0x64, %ecx
jg 0x3a3eb
cmpl $0x25, %ecx
je 0x3a3e4
cmpl $0x63, %ecx
je 0x3a36b
jmp 0x3a429
movl $0x7, %ebx
jmp 0x3a42b
cmpl $0x65, %ecx
je 0x3a40f
cmpl $0x69, %ecx
jne 0x3a429
movl $0x6, %ebx
cmpb $0x6e, 0x1(%rax)
je 0x3a42b
movl $0x7, %ebx
cmpl $0x25, %ecx
je 0x3a42b
cmpl $0x65, %ecx
jne 0x3a429
movb 0x1(%rax), %al
movl $0x8, %ebx
cmpb $0x6d, %al
je 0x3a42b
xorb $0x65, %cl
xorb $0x78, %al
movl $0x9, %ebx
orb %cl, %al
je 0x3a42b
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x3ab74
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
movl $0x2, %ebx
jmp 0x3a42b
movl $0x3, %ebx
jmp 0x3a42b
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, (%rsp)
cmpb $0x0, (%rsi)
je 0x3a608
movq %rsi, %r14
leaq 0x6766(%rip), %rbp      # 0x40bd7
movb (%r14), %al
testb %al, %al
je 0x3a496
movsbl %al, %esi
movl $0x7, %edx
movq %rbp, %rdi
callq 0x74a0
testq %rax, %rax
je 0x3a496
movb 0x1(%r14), %al
incq %r14
jmp 0x3a474
movq %r14, %rbx
movzbl (%rbx), %eax
testl %eax, %eax
je 0x3a4aa
cmpl $0x3b, %eax
je 0x3a4aa
incq %rbx
jmp 0x3a499
movq %rbx, %r12
cmpq %r14, %rbx
jbe 0x3a4dc
movq %rbx, %r12
movsbl (%r12), %esi
cmpl $0x3b, %esi
je 0x3a4d1
movl $0x7, %edx
movq %rbp, %rdi
callq 0x74a0
testq %rax, %rax
je 0x3a4dc
decq %r12
cmpq %r14, %r12
ja 0x3a4b5
movq %r14, %r12
leaq 0x1(%r12), %rax
movq %r14, %r15
movq %rax, 0x8(%rsp)
cmpq %rax, %r14
jae 0x3a507
movq %r14, %rax
cmpb $0x3a, (%rax)
je 0x3a504
leaq 0x1(%rax), %r15
cmpq %r12, %rax
movq %r15, %rax
jb 0x3a4f1
jmp 0x3a507
movq %rax, %r15
movq %r15, %r13
cmpq %r14, %r15
jbe 0x3a539
movq %r15, %r13
movsbl (%r13), %esi
cmpl $0x3a, %esi
je 0x3a52e
movl $0x7, %edx
movq %rbp, %rdi
callq 0x74a0
testq %rax, %rax
je 0x3a539
decq %r13
cmpq %r14, %r13
ja 0x3a512
movq %r14, %r13
subl %r14d, %r13d
incl %r13d
movl $0x1ff, %eax            # imm = 0x1FF
cmpl %eax, %r13d
cmovll %r13d, %eax
movslq %eax, %rbp
testl %r13d, %r13d
je 0x3a563
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x7380
movb $0x0, 0x10(%rsp,%rbp)
movq 0x8(%rsp), %r14
cmpq %r14, %r15
jae 0x3a5a2
leaq 0x665e(%rip), %rbp      # 0x40bd7
movsbl (%r15), %esi
cmpl $0x3a, %esi
je 0x3a594
movl $0x7, %edx
movq %rbp, %rdi
callq 0x74a0
testq %rax, %rax
je 0x3a5ae
leaq 0x1(%r15), %rsi
cmpq %r12, %r15
movq %rsi, %r15
jb 0x3a579
jmp 0x3a5b1
movq %r15, %rsi
leaq 0x662b(%rip), %rbp      # 0x40bd7
jmp 0x3a5b1
movq %r15, %rsi
subl %esi, %r14d
movl $0x1ff, %eax            # imm = 0x1FF
cmpl %eax, %r14d
cmovll %r14d, %eax
movslq %eax, %r13
testl %r14d, %r14d
leaq 0x210(%rsp), %r14
je 0x3a5db
movq %r14, %rdi
movq %r13, %rdx
callq 0x7380
movb $0x0, 0x210(%rsp,%r13)
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x39851
cmpb $0x1, (%rbx)
sbbq $-0x1, %rbx
cmpb $0x0, (%rbx)
movq %rbx, %r14
jne 0x3a471
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %rdi, %rbx
movb (%rbx), %bpl
incq %rbx
cmpb $0x20, %bpl
je 0x3a624
leaq -0x1(%rbx), %r14
movq %r14, %rdi
callq 0x71d0
testq %rax, %rax
sete %cl
cmpb $0x23, %bpl
setne %dl
orb %cl, %dl
jne 0x3a6b5
movl $0x0, 0x4(%rsp)
movb (%rbx), %al
xorl %r15d, %r15d
testb %al, %al
je 0x3a686
leaq 0x6572(%rip), %r14      # 0x40bd7
movsbl %al, %esi
movl $0x7, %edx
movq %r14, %rdi
callq 0x74a0
testq %rax, %rax
jne 0x3a686
movb 0x1(%rbx,%r15), %al
incq %r15
testb %al, %al
jne 0x3a665
cmpl $0x3, %r15d
je 0x3a721
cmpl $0x6, %r15d
jne 0x3a763
leaq 0x6753(%rip), %rsi      # 0x40df4
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x7400
jmp 0x3a763
cmpq $0x4, %rax
setb %al
cmpb $0x72, %bpl
setne %cl
orb %al, %cl
jne 0x3a6ea
cmpb $0x67, (%rbx)
jne 0x3a6ea
cmpb $0x62, 0x1(%rbx)
jne 0x3a6ea
cmpb $0x28, 0x2(%rbx)
jne 0x3a6ea
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3aaa1
movl $0x8, %ebx
leaq 0x1812a(%rip), %r15     # 0x52820
movq -0x8(%rbx,%r15), %rdi
movq %r14, %rsi
callq 0x7590
testl %eax, %eax
je 0x3a71b
addq $0x10, %rbx
cmpq $0xa8, %rbx
jne 0x3a6f6
movl $0x808080, %eax         # imm = 0x808080
jmp 0x3a77f
movl (%rbx,%r15), %eax
jmp 0x3a77f
leaq 0x66cc(%rip), %rsi      # 0x40df4
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x7400
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
movl %eax, %ecx
shll $0x4, %ecx
orl %eax, %ecx
movl %ecx, (%r14)
movl 0x4(%rsp), %ecx
movl %ecx, %edx
movzbl %cl, %eax
shrl $0x10, %ecx
movzbl %cl, %ecx
andl $0xff00, %edx           # imm = 0xFF00
orl %ecx, %edx
shll $0x10, %eax
orl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseStrokeDashArray(NSVGparser*, char const*, double*)
static int nsvg__parseStrokeDashArray(NSVGparser* p, const char* str, double* strokeDashArray)
{
	char item[64];
	int count = 0, i;
	double sum = 0.0;

	// Handle "none"
	if (str[0] == 'n')
		return 0;

	// Parse dashes
	while (*str) {
		str = nsvg__getNextDashItem(str, item);
		if (!*item) break;
		if (count < NSVG_MAX_DASHES)
			strokeDashArray[count++] = fabs(nsvg__parseCoordinate(p, item, 0.0, nsvg__actualLength(p)));
	}

	for (i = 0; i < count; i++)
		sum += strokeDashArray[i];
	if (sum <= 1e-6f)
		count = 0;

	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
xorl %eax, %eax
cmpb $0x6e, (%rsi)
je 0x3a914
movq %rsi, %r14
movq %rdx, 0x8(%rsp)
cmpb $0x0, (%rsi)
movl $0x0, %ebp
je 0x3a8e0
xorl %ebp, %ebp
leaq 0x6410(%rip), %r13      # 0x40bd7
movb $0x0, 0x20(%rsp)
movb (%r14), %al
testb %al, %al
je 0x3a7fb
movsbl %al, %r12d
movl $0x7, %edx
movq %r13, %rdi
movl %r12d, %esi
callq 0x74a0
cmpb $0x2c, %r12b
je 0x3a7f2
testq %rax, %rax
je 0x3a7fb
movb 0x1(%r14), %al
incq %r14
jmp 0x3a7cf
movb (%r14), %bl
testb %bl, %bl
je 0x3a844
xorl %r15d, %r15d
movsbl %bl, %r12d
movl $0x7, %edx
movq %r13, %rdi
movl %r12d, %esi
callq 0x74a0
cmpb $0x2c, %r12b
je 0x3a83f
testq %rax, %rax
jne 0x3a83f
cmpl $0x3e, %r15d
jg 0x3a834
movslq %r15d, %rax
incl %r15d
movb %bl, 0x20(%rsp,%rax)
movb 0x1(%r14), %bl
incq %r14
testb %bl, %bl
jne 0x3a805
movslq %r15d, %rax
jmp 0x3a846
xorl %eax, %eax
movb $0x0, 0x20(%rsp,%rax)
cmpb $0x0, 0x20(%rsp)
je 0x3a8e0
cmpl $0x7, %ebp
jg 0x3a8d6
movq 0x10(%rsp), %rax
movsd 0xd060(%rax), %xmm0
movsd 0xd068(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd 0x4854(%rip), %xmm0     # 0x3f0d8
jb 0x3a88c
sqrtsd %xmm0, %xmm0
jmp 0x3a891
callq 0x7370
divsd 0x48a7(%rip), %xmm0     # 0x3f140
movsd %xmm0, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3a344
xorpd %xmm1, %xmm1
movq 0x10(%rsp), %rdi
movl %eax, %esi
movsd 0x18(%rsp), %xmm2
callq 0x3ad0d
andpd 0x4769(%rip), %xmm0     # 0x3f030
movslq %ebp, %rax
incl %ebp
movq 0x8(%rsp), %rcx
movlpd %xmm0, (%rcx,%rax,8)
cmpb $0x0, (%r14)
jne 0x3a7c7
testl %ebp, %ebp
movq 0x8(%rsp), %rdx
movl $0x0, %eax
jle 0x3a914
movl %ebp, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
addsd (%rdx,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x3a8f6
xorl %eax, %eax
movsd 0x4903(%rip), %xmm1     # 0x3f210
ucomisd %xmm0, %xmm1
cmovbl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseLineCap(char const*)
static char nsvg__parseLineCap(const char* str)
{
	if (strcmp(str, "butt") == 0)
		return NSVG_CAP_BUTT;
	else if (strcmp(str, "round") == 0)
		return NSVG_CAP_ROUND;
	else if (strcmp(str, "square") == 0)
		return NSVG_CAP_SQUARE;
	// TODO: handle inherit.
	return NSVG_CAP_BUTT;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x64e0(%rip), %rsi      # 0x40e0e
callq 0x7590
testl %eax, %eax
je 0x3a962
leaq 0x64d5(%rip), %rsi      # 0x40e13
movq %rbx, %rdi
callq 0x7590
testl %eax, %eax
je 0x3a966
leaq 0x64c8(%rip), %rsi      # 0x40e19
movq %rbx, %rdi
callq 0x7590
testl %eax, %eax
sete %al
addb %al, %al
jmp 0x3a968
xorl %eax, %eax
jmp 0x3a968
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseLineJoin(char const*)
static char nsvg__parseLineJoin(const char* str)
{
	if (strcmp(str, "miter") == 0)
		return NSVG_JOIN_MITER;
	else if (strcmp(str, "round") == 0)
		return NSVG_JOIN_ROUND;
	else if (strcmp(str, "bevel") == 0)
		return NSVG_JOIN_BEVEL;
	// TODO: handle inherit.
	return NSVG_JOIN_MITER;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x64ab(%rip), %rsi      # 0x40e20
callq 0x7590
testl %eax, %eax
je 0x3a9a9
leaq 0x648e(%rip), %rsi      # 0x40e13
movq %rbx, %rdi
callq 0x7590
testl %eax, %eax
je 0x3a9ad
leaq 0x648e(%rip), %rsi      # 0x40e26
movq %rbx, %rdi
callq 0x7590
testl %eax, %eax
sete %al
addb %al, %al
jmp 0x3a9af
xorl %eax, %eax
jmp 0x3a9af
movb $0x1, %al
popq %rbx
retq