LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x240(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x98f0
movq -0x240(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6d634
movl $0x0, -0x4(%rbp)
movl $0x1, -0x224(%rbp)
jmp 0x6d703
cmpl $0x0, -0x1c(%rbp)
je 0x6d6d8
movq -0x18(%rbp), %rdi
callq 0x9200
movq %rax, %rsi
leaq -0x220(%rbp), %rdi
movl $0x10, %edx
callq 0x9090
jmp 0x6d65d
leaq -0x220(%rbp), %rdi
callq 0x9430
movb %al, -0x241(%rbp)
jmp 0x6d671
movb -0x241(%rbp), %al
testb $0x1, %al
jne 0x6d6b0
jmp 0x6d67d
movl $0x0, -0x4(%rbp)
movl $0x1, -0x224(%rbp)
jmp 0x6d703
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x97e0
jmp 0x6d71b
movq -0x240(%rbp), %rdi
movl -0x20(%rbp), %edx
leaq -0x220(%rbp), %rsi
callq 0x6d510
jmp 0x6d6c8
leaq -0x220(%rbp), %rdi
callq 0x97a0
jmp 0x6d6d6
jmp 0x6d6f2
movq -0x240(%rbp), %rdi
movl -0x20(%rbp), %edx
movq 0x4a8a7(%rip), %rsi     # 0xb7f90
callq 0x6d510
jmp 0x6d6f0
jmp 0x6d6f2
movl $0x1, -0x4(%rbp)
movl $0x1, -0x224(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x97e0
movl -0x4(%rbp), %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x230(%rbp), %rdi
callq 0x9960
nopw (%rax,%rax)
// File: thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: CheckOKAngles(double, double, double)
bool CheckOKAngles(double alpha, double beta, double a)
{
    //  First case, alpha is negative
    if ( alpha < 0 )
    {
        if ( beta < alpha )
        {
            //  Beta is also < 0
            //  In this case, OK if a >= alpha or a <= beta
            return (a >= alpha - angle_precision || a <= beta + angle_precision);
        }
        //  For all other cases, OK if a is betwen alpha and beta
        return (a >= alpha - angle_precision && a <= beta + angle_precision);
    }
    else
    {
    //  Alpha is positive.
        if ( beta >= alpha )
        {
            //  In this case beta is also positive, OK between alpha and beta
            return ( a >= alpha - angle_precision && a <= beta + angle_precision);
        }
        //  All other cases, NOK is between beta and alpha, so OK if >= alpha or <= beta
        return ( a >= alpha - angle_precision || a <= beta + angle_precision );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x6db95
movsd -0x18(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x6db4b
movsd -0x20(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd 0x16685(%rip), %xmm2    # 0x84198
subsd %xmm2, %xmm1
movb $0x1, %al
ucomisd %xmm1, %xmm0
movb %al, -0x21(%rbp)
jae 0x6db3e
movsd -0x20(%rbp), %xmm1
movsd 0x16669(%rip), %xmm0    # 0x84198
addsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6dc2d
movsd -0x20(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd 0x1663b(%rip), %xmm2    # 0x84198
subsd %xmm2, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x22(%rbp)
jb 0x6db88
movsd -0x20(%rbp), %xmm1
movsd 0x1661f(%rip), %xmm0    # 0x84198
addsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6dc2d
movsd -0x18(%rbp), %xmm0
ucomisd -0x10(%rbp), %xmm0
jb 0x6dbe8
movsd -0x20(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd 0x165e5(%rip), %xmm2    # 0x84198
subsd %xmm2, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x23(%rbp)
jb 0x6dbde
movsd -0x20(%rbp), %xmm1
movsd 0x165c9(%rip), %xmm0    # 0x84198
addsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6dc2d
movsd -0x20(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd 0x1659e(%rip), %xmm2    # 0x84198
subsd %xmm2, %xmm1
movb $0x1, %al
ucomisd %xmm1, %xmm0
movb %al, -0x24(%rbp)
jae 0x6dc25
movsd -0x20(%rbp), %xmm1
movsd 0x16582(%rip), %xmm0    # 0x84198
addsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x24(%rbp)
movb -0x24(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x803f0
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
callq 0x80450
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x80420
testb $0x1, %al
jne 0x723ff
jmp 0x7242b
leaq -0x20(%rbp), %rdi
callq 0x80480
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rax
movl 0x8(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x80570
jmp 0x723df
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: SvgDoc::ComputeRefPoint(int, int, int)
Point SvgDoc::ComputeRefPoint(int FirstPos, int xSize, int ySize)
{
Point A;

    if ( FirstPos < CenterLeft)     //  Top
    {
        A.y = MARGIN_PAGE;
    }
    else if ( FirstPos < BottomLeft )
    {
        A.y = (SheetSizeY - ySize)/2;       //  Sheet center
    }
    else
    {
        A.y = SheetSizeY - ySize - MARGIN_PAGE;           //  Bottom
    }
    if ( (FirstPos &3) == 0 )     //  Left
    {
        A.x = MARGIN_PAGE;
    }
    else if ( (FirstPos &3) == 1 )     //  Center ?
    {
        A.x = (SheetSizeX - xSize)/2;       //  Sheet center
    }
    else
    {
        A.x = SheetSizeX - xSize - MARGIN_PAGE;           //  Right
    }
    return A;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x5b520
cmpl $0x4, -0x1c(%rbp)
jge 0x72e11
movsd 0x112ee(%rip), %xmm0    # 0x840f8
movsd %xmm0, -0x8(%rbp)
jmp 0x72e61
cmpl $0x8, -0x1c(%rbp)
jge 0x72e3c
movq -0x30(%rbp), %rax
movsd 0x18(%rax), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd 0x1126f(%rip), %xmm1    # 0x840a0
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x72e5f
movq -0x30(%rbp), %rax
movsd 0x18(%rax), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd 0x112a2(%rip), %xmm1    # 0x840f8
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x72e61
movl -0x1c(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x72e7b
movsd 0x11284(%rip), %xmm0    # 0x840f8
movsd %xmm0, -0x10(%rbp)
jmp 0x72ed0
movl -0x1c(%rbp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x72eab
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
cvtsi2sdl -0x20(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd 0x11200(%rip), %xmm1    # 0x840a0
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x72ece
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
cvtsi2sdl -0x20(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd 0x11233(%rip), %xmm1    # 0x840f8
subsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x72ed0
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x77c02
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xe212(%rip), %rsi      # 0x85dbb
callq 0x9770
cmpl $0x0, %eax
jne 0x77bcf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x7a360
jmp 0x77bf5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
callq 0x79b90
jmp 0x77bf7
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0x77b87
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7c0d0
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7960c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
callq 0x79b90
cmpl $0x0, %eax
jne 0x795fc
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xca3a(%rip), %rsi      # 0x85f8c
callq 0x9770
cmpl $0x0, %eax
jne 0x795fa
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x795f8
movq -0x20(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7c120
movq %rax, -0x20(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x7aed0
movl -0x34(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x34(%rbp)
cltq
movsd %xmm0, -0x30(%rbp,%rax,8)
cmpl $0x2, -0x34(%rbp)
jl 0x795f6
cmpl $0x0, -0x38(%rbp)
jne 0x795d3
movq -0x8(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x7dc30
jmp 0x795e6
movq -0x8(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x7e230
movl $0x0, -0x34(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x7957c
jmp 0x795fa
jmp 0x795fc
jmp 0x795fe
movl -0x18(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x18(%rbp)
jmp 0x794fd
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movsbl %al, %esi
callq 0x7d6b0
movq -0x8(%rbp), %rdi
callq 0x7dca0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseTransform(double*, char const*)
static void nsvg__parseTransform(double* xform, const char* str)
{
	double t[6];
	nsvg__xformIdentity(xform);
	while (*str)
	{
		if (strncmp(str, "matrix", 6) == 0)
			str += nsvg__parseMatrix(t, str);
		else if (strncmp(str, "translate", 9) == 0)
			str += nsvg__parseTranslate(t, str);
		else if (strncmp(str, "scale", 5) == 0)
			str += nsvg__parseScale(t, str);
		else if (strncmp(str, "rotate", 6) == 0)
			str += nsvg__parseRotate(t, str);
		else if (strncmp(str, "skewX", 5) == 0)
			str += nsvg__parseSkewX(t, str);
		else if (strncmp(str, "skewY", 5) == 0)
			str += nsvg__parseSkewY(t, str);
		else{
			++str;
			continue;
		}

		nsvg__xformPremultiply(xform, t);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x77000
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7a2d5
movq -0x10(%rbp), %rdi
leaq 0xbd89(%rip), %rsi      # 0x85eda
movl $0x6, %edx
callq 0x9280
cmpl $0x0, %eax
jne 0x7a182
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7b590
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a2c3
movq -0x10(%rbp), %rdi
leaq 0xbd54(%rip), %rsi      # 0x85ee1
movl $0x9, %edx
callq 0x9280
cmpl $0x0, %eax
jne 0x7a1be
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7b5f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a2c1
movq -0x10(%rbp), %rdi
leaq 0xbd22(%rip), %rsi      # 0x85eeb
movl $0x5, %edx
callq 0x9280
cmpl $0x0, %eax
jne 0x7a1fa
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7b660
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a2bf
movq -0x10(%rbp), %rdi
leaq 0xbcec(%rip), %rsi      # 0x85ef1
movl $0x6, %edx
callq 0x9280
cmpl $0x0, %eax
jne 0x7a236
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7b6d0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a2bd
movq -0x10(%rbp), %rdi
leaq 0xbcb7(%rip), %rsi      # 0x85ef8
movl $0x5, %edx
callq 0x9280
cmpl $0x0, %eax
jne 0x7a26f
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7b810
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a2bb
movq -0x10(%rbp), %rdi
leaq 0xbc84(%rip), %rsi      # 0x85efe
movl $0x5, %edx
callq 0x9280
cmpl $0x0, %eax
jne 0x7a2a8
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7b890
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a2b9
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a139
jmp 0x7a2bb
jmp 0x7a2bd
jmp 0x7a2bf
jmp 0x7a2c1
jmp 0x7a2c3
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7a9c0
jmp 0x7a139
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq %rsi, -0x68(%rbp)
movl $0x40, %edx
callq 0x7bab0
movq %rax, %rdi
callq 0x7bf70
movq -0x68(%rbp), %rdi
movl %eax, -0x8(%rbp)
callq 0x7aed0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movl -0x8(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7a487
jmp 0x7a37f
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x7a3a2
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x76fd0
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x7a3ab
jmp 0x7a3b9
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a37f
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x22(%rbp)
je 0x7a3df
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x7a3e8
jmp 0x7a3f6
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a3c1
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x23(%rbp)
jbe 0x7a439
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x3b, %ecx
movb %al, -0x24(%rbp)
je 0x7a433
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x76fd0
cmpl $0x0, %eax
setne %al
movb %al, -0x24(%rbp)
movb -0x24(%rbp), %al
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %al
testb $0x1, %al
jne 0x7a442
jmp 0x7a450
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7a3fe
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7aa10
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7a482
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a370
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x7a4c7
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a4c9
xorl %eax, %eax
cmpl $0x3f, -0x14(%rbp)
movb %al, -0x15(%rbp)
jge 0x7a4e4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x7a4ed
jmp 0x7a514
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7a4c9
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x7a55e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a544
movq -0x10(%rbp), %rdi
callq 0x9240
movq %rax, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
jb 0x7a58c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x7a58c
movq -0x10(%rbp), %rdi
callq 0x7ac20
movl %eax, -0x4(%rbp)
jmp 0x7a5e2
cmpq $0x4, -0x18(%rbp)
jb 0x7a5d4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x7a5d4
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x67, %eax
jne 0x7a5d4
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x62, %eax
jne 0x7a5d4
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x28, %eax
jne 0x7a5d4
movq -0x10(%rbp), %rdi
callq 0x7ad50
movl %eax, -0x4(%rbp)
jmp 0x7a5e2
jmp 0x7a5d6
movq -0x10(%rbp), %rdi
callq 0x7ae50
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7aed0
movsd %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x7a61c
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x9acf(%rip), %xmm1     # 0x840f8
ucomisd %xmm1, %xmm0
jbe 0x7a63c
movsd 0x9ac1(%rip), %xmm0     # 0x840f8
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x64(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
jne 0x7a75e
movl $0x0, -0x4(%rbp)
jmp 0x7a825
jmp 0x7a760
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7a7d8
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7b300
movq %rax, -0x18(%rbp)
cmpb $0x0, -0x60(%rbp)
jne 0x7a782
jmp 0x7a7d8
cmpl $0x8, -0x64(%rbp)
jge 0x7a7d6
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7a6b0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
callq 0x7a650
movaps 0x98f5(%rip), %xmm1     # 0x840b0
pand %xmm1, %xmm0
movq -0x20(%rbp), %rax
movl -0x64(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x64(%rbp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x7a760
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
cmpl -0x64(%rbp), %eax
jge 0x7a809
movq -0x20(%rbp), %rax
movslq -0x68(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x70(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x7a7df
movsd 0x99ff(%rip), %xmm0     # 0x84210
ucomisd -0x70(%rbp), %xmm0
jb 0x7a81f
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb655(%rip), %rsi      # 0x85eac
callq 0x9770
cmpl $0x0, %eax
jne 0x7a867
movb $0x0, -0x1(%rbp)
jmp 0x7a8a5
movq -0x10(%rbp), %rdi
leaq 0xb63f(%rip), %rsi      # 0x85eb1
callq 0x9770
cmpl $0x0, %eax
jne 0x7a882
movb $0x1, -0x1(%rbp)
jmp 0x7a8a5
movq -0x10(%rbp), %rdi
leaq 0xb62a(%rip), %rsi      # 0x85eb7
callq 0x9770
cmpl $0x0, %eax
jne 0x7a89d
movb $0x2, -0x1(%rbp)
jmp 0x7a8a5
jmp 0x7a89f
jmp 0x7a8a1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb5f7(%rip), %rsi      # 0x85ebe
callq 0x9770
cmpl $0x0, %eax
jne 0x7a8d7
movb $0x0, -0x1(%rbp)
jmp 0x7a915
movq -0x10(%rbp), %rdi
leaq 0xb5cf(%rip), %rsi      # 0x85eb1
callq 0x9770
cmpl $0x0, %eax
jne 0x7a8f2
movb $0x1, -0x1(%rbp)
jmp 0x7a915
movq -0x10(%rbp), %rdi
leaq 0xb5c7(%rip), %rsi      # 0x85ec4
callq 0x9770
cmpl $0x0, %eax
jne 0x7a90d
movb $0x2, -0x1(%rbp)
jmp 0x7a915
jmp 0x7a90f
jmp 0x7a911
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseFillRule(char const*)
static char nsvg__parseFillRule(const char* str)
{
	if (strcmp(str, "nonzero") == 0)
		return NSVG_FILLRULE_NONZERO;
	else if (strcmp(str, "evenodd") == 0)
		return NSVG_FILLRULE_EVENODD;
	// TODO: handle inherit.
	return NSVG_FILLRULE_NONZERO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb553(%rip), %rsi      # 0x85eca
callq 0x9770
cmpl $0x0, %eax
jne 0x7a987
movb $0x0, -0x1(%rbp)
jmp 0x7a9a8
movq -0x10(%rbp), %rdi
leaq 0xb540(%rip), %rsi      # 0x85ed2
callq 0x9770
cmpl $0x0, %eax
jne 0x7a9a2
movb $0x1, -0x1(%rbp)
jmp 0x7a9a8
jmp 0x7a9a4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseColorHex(char const*)
static unsigned int nsvg__parseColorHex(const char* str)
{
	unsigned int c = 0, r = 0, g = 0, b = 0;
	int n = 0;
	str++; // skip #
	// Calculate number of characters.
	while(str[n] && !nsvg__isspace(str[n]))
		n++;
	if (n == 6) {
		sscanf(str, "%x", &c);
	} else if (n == 3) {
		sscanf(str, "%x", &c);
		c = (c&0xf) | ((c&0xf0) << 4) | ((c&0xf00) << 8);
		c |= c<<4;
	}
	r = (c >> 16) & 0xff;
	g = (c >> 8) & 0xff;
	b = c & 0xff;
	return NSVG_RGB(r,g,b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
xorl %eax, %eax
cmpb $0x0, (%rcx,%rdx)
movb %al, -0x1d(%rbp)
je 0x7ac8a
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x76fd0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x7ac93
jmp 0x7ac9e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7ac5b
cmpl $0x6, -0x1c(%rbp)
jne 0x7acbc
movq -0x8(%rbp), %rdi
leaq 0xb1e3(%rip), %rsi      # 0x85e92
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x9520
jmp 0x7ad0b
cmpl $0x3, -0x1c(%rbp)
jne 0x7ad09
movq -0x8(%rbp), %rdi
leaq 0xb1c5(%rip), %rsi      # 0x85e92
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x9520
movl -0xc(%rbp), %eax
andl $0xf, %eax
movl -0xc(%rbp), %ecx
andl $0xf0, %ecx
shll $0x4, %ecx
orl %ecx, %eax
movl -0xc(%rbp), %ecx
andl $0xf00, %ecx            # imm = 0xF00
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x4, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x7ad0b
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl -0x14(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl -0x18(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseColorRGB(char const*)
static unsigned int nsvg__parseColorRGB(const char* str)
{
	int r = -1, g = -1, b = -1;
	char s1[32]="", s2[32]="";
	sscanf(str + 4, "%d%[%%, \t]%d%[%%, \t]%d", &r, s1, &g, s2, &b);
	if (strchr(s1, '%')) {
		return NSVG_RGB((r*255)/100,(g*255)/100,(b*255)/100);
	} else {
		return NSVG_RGB(r,g,b);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x92f0
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x92f0
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
leaq -0x40(%rbp), %rcx
leaq -0x60(%rbp), %r9
leaq 0xb0ed(%rip), %rsi      # 0x85e95
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %r8
leaq -0x1c(%rbp), %rax
movq %rax, (%rsp)
movb $0x0, %al
callq 0x9520
leaq -0x40(%rbp), %rdi
movl $0x25, %esi
callq 0x91c0
cmpq $0x0, %rax
je 0x7ae22
imull $0xff, -0x14(%rbp), %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x68(%rbp)
imull $0xff, -0x18(%rbp), %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movl -0x68(%rbp), %eax
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x64(%rbp)
imull $0xff, -0x1c(%rbp), %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movl -0x64(%rbp), %eax
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x7ae38
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl -0x1c(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseColorName(char const*)
static unsigned int nsvg__parseColorName(const char* str)
{
	int i, ncolors = sizeof(nsvg__colors) / sizeof(NSVGNamedColor);

	for (i = 0; i < ncolors; i++) {
		if (strcmp(nsvg__colors[i].name, str) == 0) {
			return nsvg__colors[i].color;
		}
	}

	return NSVG_RGB(128, 128, 128);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0xa, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x7aebc
movslq -0x14(%rbp), %rcx
leaq 0x3daf3(%rip), %rax     # 0xb8970
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x9770
cmpl $0x0, %eax
jne 0x7aeaf
movslq -0x14(%rbp), %rcx
leaq 0x3dad0(%rip), %rax     # 0xb8970
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x7aec3
jmp 0x7aeb1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7ae6a
movl $0x808080, -0x4(%rbp)   # imm = 0x808080
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x18(%rbp)
movl %esi, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7a330
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %eax
movq %rax, -0x40(%rbp)
subq $0x9, %rax
ja 0x7b2a8
movq -0x40(%rbp), %rax
leaq 0x921d(%rip), %rcx      # 0x84384
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7b2b2
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7b2b2
movsd -0x18(%rbp), %xmm0
movsd 0x908d(%rip), %xmm1     # 0x84228
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
mulsd 0xd080(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7b2b2
movsd -0x18(%rbp), %xmm0
movsd 0x8f56(%rip), %xmm1     # 0x84118
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
mulsd 0xd080(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7b2b2
movsd -0x18(%rbp), %xmm0
movsd 0x8f9f(%rip), %xmm1     # 0x84188
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
mulsd 0xd080(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7b2b2
movsd -0x18(%rbp), %xmm0
movsd 0x9010(%rip), %xmm1     # 0x84220
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
mulsd 0xd080(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7b2b2
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rax
mulsd 0xd080(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7b2b2
movsd -0x18(%rbp), %xmm0
movq -0x38(%rbp), %rax
mulsd 0x178(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7b2b2
movsd -0x18(%rbp), %xmm0
movq -0x38(%rbp), %rax
mulsd 0x178(%rax), %xmm0
movsd 0x8fa5(%rip), %xmm1     # 0x84218
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7b2b2
movsd -0x28(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movsd 0x8f00(%rip), %xmm2     # 0x84190
divsd %xmm2, %xmm0
movsd -0x30(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7b2b2
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__getNextDashItem(char const*, char*)
static const char* nsvg__getNextDashItem(const char* s, char* it)
{
	int n = 0;
	it[0] = '\0';
	// Skip white spaces and commas
	while (*s && (nsvg__isspace(*s) || *s == ',')) s++;
	// Advance until whitespace, comma or end.
	while (*s && (!nsvg__isspace(*s) && *s != ',')) {
		if (n < 63)
			it[n++] = *s;
		s++;
	}
	it[n++] = '\0';
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x15(%rbp)
je 0x7b35a
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x76fd0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x16(%rbp)
jne 0x7b354
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x7b363
jmp 0x7b371
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x7b31e
jmp 0x7b373
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x17(%rbp)
je 0x7b3af
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x76fd0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x18(%rbp)
jne 0x7b3a9
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
setne %al
movb %al, -0x18(%rbp)
movb -0x18(%rbp), %al
movb %al, -0x17(%rbp)
movb -0x17(%rbp), %al
testb $0x1, %al
jne 0x7b3b8
jmp 0x7b3e7
cmpl $0x3f, -0x14(%rbp)
jge 0x7b3d9
movq -0x8(%rbp), %rax
movb (%rax), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x7b373
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__xformMultiply(double*, double*)
static void nsvg__xformMultiply(double* t, double* s)
{
	double t0 = t[0] * s[0] + t[1] * s[2];
	double t2 = t[2] * s[0] + t[3] * s[2];
	double t4 = t[4] * s[0] + t[5] * s[2] + s[4];
	t[1] = t[0] * s[1] + t[1] * s[3];
	t[3] = t[2] * s[1] + t[3] * s[3];
	t[5] = t[4] * s[1] + t[5] * s[3] + s[5];
	t[0] = t0;
	t[2] = t2;
	t[4] = t4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x10(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x10(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x28(%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x10(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
addsd 0x20(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x18(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x18(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x28(%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x18(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
addsd 0x28(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseMatrix(double*, char const*)
static int nsvg__parseMatrix(double* xform, const char* str)
{
	double t[6];
	int na = 0;
	int len = nsvg__parseTransformArgs(str, t, 6, &na);
	if (na != 6) return len;
	memcpy(xform, t, sizeof(double)*6);
	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x54(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x6, %edx
leaq -0x54(%rbp), %rcx
callq 0x7b910
movl %eax, -0x58(%rbp)
cmpl $0x6, -0x54(%rbp)
je 0x7b5ce
movl -0x58(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7b5e6
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x30, %edx
callq 0x9490
movl -0x58(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseTranslate(double*, char const*)
static int nsvg__parseTranslate(double* xform, const char* str)
{
	double args[2];
	double t[6];
	int na = 0;
	int len = nsvg__parseTransformArgs(str, args, 2, &na);
	if (na == 1) args[1] = 0.0;

	nsvg__xformSetTranslation(t, args[0], args[1]);
	memcpy(xform, t, sizeof(double)*6);
	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x54(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x2, %edx
leaq -0x54(%rbp), %rcx
callq 0x7b910
movl %eax, -0x58(%rbp)
cmpl $0x1, -0x54(%rbp)
jne 0x7b62e
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x7bd20
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x30, %edx
callq 0x9490
movl -0x58(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseScale(double*, char const*)
static int nsvg__parseScale(double* xform, const char* str)
{
	double args[2];
	int na = 0;
	double t[6];
	int len = nsvg__parseTransformArgs(str, args, 2, &na);
	if (na == 1) args[1] = args[0];
	nsvg__xformSetScale(t, args[0], args[1]);
	memcpy(xform, t, sizeof(double)*6);
	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x2, %edx
leaq -0x24(%rbp), %rcx
callq 0x7b910
movl %eax, -0x64(%rbp)
cmpl $0x1, -0x24(%rbp)
jne 0x7b6a0
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x60(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x7bd90
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x30, %edx
callq 0x9490
movl -0x64(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseRotate(double*, char const*)
static int nsvg__parseRotate(double* xform, const char* str)
{
	double args[3];
	int na = 0;
	double m[6];
	double t[6];
	int len = nsvg__parseTransformArgs(str, args, 3, &na);
	if (na == 1)
		args[1] = args[2] = 0.0;
	nsvg__xformIdentity(m);

	if (na > 1) {
		nsvg__xformSetTranslation(t, -args[1], -args[2]);
		nsvg__xformMultiply(m, t);
	}

	nsvg__xformSetRotation(t, args[0]/180.0*NSVG_PI);
	nsvg__xformMultiply(m, t);

	if (na > 1) {
		nsvg__xformSetTranslation(t, args[1], args[2]);
		nsvg__xformMultiply(m, t);
	}

	memcpy(xform, m, sizeof(double)*6);

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x3, %edx
leaq -0x34(%rbp), %rcx
callq 0x7b910
movl %eax, -0xa4(%rbp)
cmpl $0x1, -0x34(%rbp)
jne 0x7b71c
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x77000
cmpl $0x1, -0x34(%rbp)
jle 0x7b77f
leaq -0xa0(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd -0x20(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
callq 0x7bd20
leaq -0x70(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x7b410
leaq -0xa0(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
movsd 0x8a25(%rip), %xmm1     # 0x841b8
divsd %xmm1, %xmm0
movsd 0x8a91(%rip), %xmm1     # 0x84230
mulsd %xmm1, %xmm0
callq 0x7bdf0
leaq -0x70(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x7b410
cmpl $0x1, -0x34(%rbp)
jle 0x7b7e4
leaq -0xa0(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x7bd20
leaq -0x70(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x7b410
movq -0x8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x30, %edx
callq 0x9490
movl -0xa4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseSkewX(double*, char const*)
static int nsvg__parseSkewX(double* xform, const char* str)
{
	double args[1];
	int na = 0;
	double t[6];
	int len = nsvg__parseTransformArgs(str, args, 1, &na);
	nsvg__xformSetSkewX(t, args[0]/180.0*NSVG_PI);
	memcpy(xform, t, sizeof(double)*6);
	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x1, %edx
leaq -0x1c(%rbp), %rcx
callq 0x7b910
movl %eax, -0x54(%rbp)
leaq -0x50(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd 0x8967(%rip), %xmm1     # 0x841b8
divsd %xmm1, %xmm0
movsd 0x89d3(%rip), %xmm1     # 0x84230
mulsd %xmm1, %xmm0
callq 0x7be90
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x30, %edx
callq 0x9490
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseSkewY(double*, char const*)
static int nsvg__parseSkewY(double* xform, const char* str)
{
	double args[1];
	int na = 0;
	double t[6];
	int len = nsvg__parseTransformArgs(str, args, 1, &na);
	nsvg__xformSetSkewY(t, args[0]/180.0*NSVG_PI);
	memcpy(xform, t, sizeof(double)*6);
	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x1, %edx
leaq -0x1c(%rbp), %rcx
callq 0x7b910
movl %eax, -0x54(%rbp)
leaq -0x50(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd 0x88e7(%rip), %xmm1     # 0x841b8
divsd %xmm1, %xmm0
movsd 0x8953(%rip), %xmm1     # 0x84230
mulsd %xmm1, %xmm0
callq 0x7bf00
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x30, %edx
callq 0x9490
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseTransformArgs(char const*, double*, int, int*)
static int nsvg__parseTransformArgs(const char* str, double* args, int maxNa, int* na)
{
	const char* end;
	const char* ptr;
	char it[64];

	*na = 0;
	ptr = str;
	while (*ptr && *ptr != '(') ++ptr;
	if (*ptr == 0)
		return 1;
	end = ptr;
	while (*end && *end != ')') ++end;
	if (*end == 0)
		return 1;

	while (ptr < end) {
		if (*ptr == '-' || *ptr == '+' || *ptr == '.' || nsvg__isdigit(*ptr)) {
			if (*na >= maxNa) return 0;
			ptr = nsvg__parseNumber(ptr, it, 64);
			args[(*na)++] = nsvg__atof(it);
		} else {
			++ptr;
		}
	}
	return (int)(end - str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x81(%rbp)
je 0x7b960
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
setne %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x7b96c
jmp 0x7b97a
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x7b93c
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x7b992
movl $0x1, -0x4(%rbp)
jmp 0x7baa2
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x82(%rbp)
je 0x7b9be
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
setne %al
movb %al, -0x82(%rbp)
movb -0x82(%rbp), %al
testb $0x1, %al
jne 0x7b9ca
jmp 0x7b9d8
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x7b99a
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x7b9f0
movl $0x1, -0x4(%rbp)
jmp 0x7baa2
jmp 0x7b9f2
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x7ba94
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x7ba35
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x7ba35
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x7ba35
movq -0x38(%rbp), %rax
movsbl (%rax), %edi
callq 0x7b0f0
cmpl $0x0, %eax
je 0x7ba83
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jl 0x7ba49
movl $0x0, -0x4(%rbp)
jmp 0x7baa2
movq -0x38(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl $0x40, %edx
callq 0x7bab0
movq %rax, -0x38(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x7aed0
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdx
movl (%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rdx)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x7ba8f
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x7b9f2
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nop