LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7700
xorl %ebx, %ebx
cmpq $0x0, 0x8(%r14)
je 0x30bb2
testl %r12d, %r12d
je 0x30b9c
movq (%r15), %rsi
movq %rsp, %rdi
movl $0x10, %edx
callq 0x7070
leaq 0x70(%rsp), %rdi
callq 0x7110
testb %al, %al
je 0x30bb2
movq %rsp, %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x30a82
movl $0x1, %ebx
movq %rsp, %rdi
callq 0x75d0
jmp 0x30bb2
movl $0x1, %ebx
movq 0x203e8(%rip), %rsi     # 0x50f90
movq %r14, %rdi
movl %ebp, %edx
callq 0x30a82
movq 0x203af(%rip), %rax     # 0x50f68
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x73a0
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 0x7610
movq %rbx, %rdi
callq 0x7740
// File: /workspace/github_cpp_makefile_star2_O3/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 0x34866
movq 0x10(%rcx), %rdx
movq (%rcx), %rdi
movq 0x68(%rdx), %rcx
addl 0x8(%rcx), %eax
movq %rdi, %rcx
cmpq %rsi, %rdi
jne 0x34850
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, 0x180(%rdi,%r15)
movsd 0x3de6(%rip), %xmm0     # 0x3c008
movupd %xmm0, 0x188(%rdi,%r15)
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x38250
addq $0x10, %r14
movq -0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x38acd
movq (%r14), %rsi
addq $0x10, %r14
testq %rsi, %rsi
jne 0x38238
movq 0xd040(%rbx), %r14
testq %r14, %r14
je 0x3833c
movslq 0x110(%r14), %rsi
incq %rsi
movl %esi, 0x110(%r14)
movq 0x118(%r14), %rdi
shlq $0x4, %rsi
callq 0x76d0
movq %rax, 0x118(%r14)
testq %rax, %rax
je 0x3833c
addq %r15, %rbx
movl 0x110(%r14), %ecx
leal -0x1(%rcx), %esi
movsd 0x190(%rbx), %xmm0
cmpl $0x2, %ecx
jl 0x3830e
movl %esi, %edi
movq %rax, %r8
addq $0x8, %r8
xorl %edx, %edx
movsd (%r8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x382cf
incq %rdx
addq $0x10, %r8
cmpq %rdx, %rdi
jne 0x382b6
jmp 0x3830e
cmpl %edx, %esi
jle 0x3830c
leaq -0x1(%rcx), %rax
shlq $0x4, %rcx
addq $-0x10, %rcx
movq 0x118(%r14), %rsi
movupd -0x10(%rsi,%rcx), %xmm0
movupd %xmm0, (%rsi,%rcx)
decq %rax
addq $-0x10, %rcx
cmpq %rdx, %rax
jg 0x382df
movq 0x118(%r14), %rax
movsd 0x190(%rbx), %xmm0
movl %edx, %esi
movslq %esi, %rcx
movsd 0x188(%rbx), %xmm1
mulsd 0x5f87(%rip), %xmm1     # 0x3e2a8
shlq $0x4, %rcx
cvttsd2si %xmm1, %rdx
shll $0x18, %edx
orl 0x180(%rbx), %edx
movl %edx, (%rax,%rcx)
movsd %xmm0, 0x8(%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x38397
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rbx
leaq 0x7a3e(%rip), %r15      # 0x3fda1
movq %r12, %rdi
movq %r15, %rsi
callq 0x75a0
movq -0x8(%rbx), %rdx
movq %r14, %rdi
testl %eax, %eax
je 0x38383
movq %r12, %rsi
callq 0x38acd
jmp 0x3838b
movq %rdx, %rsi
callq 0x3960c
movq (%rbx), %r12
addq $0x10, %rbx
testq %r12, %r12
jne 0x38363
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x38662
movq 0x38(%rdi), %r15
callq 0x7530
movq %r15, %rdi
testq %r15, %r15
jne 0x38651
movl $0x0, 0xd028(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq (%r13), %rsi
testq %rsi, %rsi
je 0x38766
xorl %ebp, %ebp
leaq 0x30(%rsp), %r12
xorl %r15d, %r15d
movq %r13, 0x28(%rsp)
movq 0x8(%r13,%rbp,8), %rdx
movq %rbx, %rdi
callq 0x38acd
testl %eax, %eax
jne 0x386b5
movq (%r13,%rbp,8), %rdi
leaq 0x78c0(%rip), %rsi      # 0x3ff6c
callq 0x75a0
testl %eax, %eax
je 0x386cd
movq 0x28(%rsp), %r13
movq 0x10(%r13,%rbp,8), %rsi
addq $0x2, %rbp
testq %rsi, %rsi
jne 0x3868f
jmp 0x38766
movq %rbp, %rax
orq $0x1, %rax
movq (%r13,%rax,8), %r13
cmpb $0x0, (%r13)
je 0x386b5
xorl %r14d, %r14d
movq %r13, %rdi
movq %r12, %rsi
callq 0x3a171
movq %rax, %r13
movq %r12, %rdi
callq 0x39d04
movl %r14d, %eax
movsd %xmm0, 0x10(%rsp,%rax,8)
testl %r14d, %r14d
je 0x38730
testl %r15d, %r15d
je 0x38738
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 0x3a969
jmp 0x3874d
movl $0x1, %r14d
jmp 0x38753
cmpl $0x0, 0xd028(%rbx)
jg 0x3875f
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0xd018(%rbx)
incl %r15d
xorl %r14d, %r14d
cmpb $0x0, (%r13)
jne 0x386e3
jmp 0x386b5
callq 0x7ac7
jmp 0x3874d
movsbl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x3a260
movq %rbx, %rdi
callq 0x3a63b
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3a087
movzbl (%rax), %ecx
cmpl $0x68, %ecx
jg 0x3959d
cmpl $0x25, %ecx
je 0x395c6
cmpl $0x63, %ecx
je 0x395da
cmpl $0x65, %ecx
jne 0x395ec
movb 0x1(%rax), %al
xorl %ecx, %ecx
cmpb $0x78, %al
sete %cl
leal (%rcx,%rcx,8), %ecx
cmpb $0x6d, %al
movl $0x8, %ebx
cmovnel %ecx, %ebx
jmp 0x395ee
cmpl $0x69, %ecx
je 0x395cd
cmpl $0x6d, %ecx
je 0x395e1
cmpl $0x70, %ecx
jne 0x395ec
movzbl 0x1(%rax), %eax
cmpl $0x63, %eax
je 0x39605
cmpl $0x74, %eax
je 0x395fe
movl $0x1, %ebx
cmpl $0x78, %eax
jne 0x395ec
jmp 0x395ee
movl $0x7, %ebx
jmp 0x395ee
movl $0x6, %ebx
cmpb $0x6e, 0x1(%rax)
jne 0x395ec
jmp 0x395ee
movl $0x5, %ebx
jmp 0x395e6
movl $0x4, %ebx
cmpb $0x6d, 0x1(%rax)
je 0x395ee
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x39d04
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
movl $0x2, %ebx
jmp 0x395ee
movl $0x3, %ebx
jmp 0x395ee
// File: /workspace/github_cpp_makefile_star2_O3/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)
movb (%rsi), %bl
testb %bl, %bl
je 0x397f4
movq %rsi, %r14
leaq 0x663e(%rip), %r15      # 0x3fc73
movsbl %bl, %esi
movl $0x7, %edx
movq %r15, %rdi
callq 0x74b0
testq %rax, %rax
je 0x39657
movb 0x1(%r14), %bl
incq %r14
testb %bl, %bl
jne 0x39635
xorl %ebx, %ebx
movq %r14, %r12
testb %bl, %bl
je 0x39670
movzbl %bl, %eax
cmpl $0x3b, %eax
je 0x39670
movb 0x1(%r12), %bl
incq %r12
jmp 0x3965a
movq %r12, %r13
cmpq %r14, %r12
jbe 0x396a2
movq %r12, %r13
movsbl (%r13), %esi
cmpl $0x3b, %esi
je 0x39697
movl $0x7, %edx
movq %r15, %rdi
callq 0x74b0
testq %rax, %rax
je 0x396a2
decq %r13
cmpq %r14, %r13
ja 0x3967b
movq %r14, %r13
leaq 0x1(%r13), %rax
movq %r14, %rbp
movq %r14, %rbx
movq %r14, %r15
movq %rax, 0x8(%rsp)
cmpq %rax, %r14
jae 0x39714
movq %r14, %rax
cmpb $0x3a, (%rax)
je 0x396cf
leaq 0x1(%rax), %rbp
cmpq %r13, %rax
movq %rbp, %rax
jb 0x396bc
jmp 0x396d2
movq %rax, %rbp
cmpq %r14, %rbp
jbe 0x39709
movq %rbp, %r15
movsbl (%r15), %esi
cmpl $0x3a, %esi
je 0x396f9
movl $0x7, %edx
leaq 0x6584(%rip), %rdi      # 0x3fc73
callq 0x74b0
testq %rax, %rax
je 0x39711
decq %r15
cmpq %r14, %r15
ja 0x396da
movq %rbp, %rbx
movq %r14, %r15
jmp 0x39714
movq %rbp, %rbx
movq %rbp, %r15
jmp 0x39714
movq %rbp, %rbx
subl %r14d, %r15d
incl %r15d
movl $0x1ff, %eax            # imm = 0x1FF
cmpl %eax, %r15d
cmovll %r15d, %eax
testl %r15d, %r15d
je 0x39740
movslq %eax, %r15
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7390
jmp 0x39743
movl %eax, %r15d
movb $0x0, 0x10(%rsp,%r15)
movq 0x8(%rsp), %r15
cmpq %r15, %rbp
jae 0x39789
leaq 0x6519(%rip), %r14      # 0x3fc73
movsbl (%rbp), %esi
cmpl $0x3a, %esi
je 0x39775
movl $0x7, %edx
movq %r14, %rdi
callq 0x74b0
testq %rax, %rax
je 0x39783
leaq 0x1(%rbp), %rbx
cmpq %r13, %rbp
movq %rbx, %rbp
jb 0x3975a
jmp 0x39786
movq %rbp, %rbx
movq %rbx, %rbp
subl %ebx, %r15d
movl $0x1ff, %eax            # imm = 0x1FF
cmpl %eax, %r15d
cmovll %r15d, %eax
testl %r15d, %r15d
leaq 0x210(%rsp), %rbx
je 0x397b8
movslq %eax, %r15
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x7390
jmp 0x397bb
movl %eax, %r15d
movb $0x0, 0x210(%rsp,%r15)
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x38acd
cmpb $0x1, (%r12)
sbbq $-0x1, %r12
movb (%r12), %bl
movq %r12, %r14
testb %bl, %bl
leaq 0x6485(%rip), %r15      # 0x3fc73
jne 0x39635
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x39810
leaq -0x1(%rbx), %r14
movq %r14, %rdi
callq 0x71d0
testq %rax, %rax
sete %cl
cmpb $0x23, %bpl
setne %dl
orb %cl, %dl
jne 0x398ab
movl $0x0, 0x4(%rsp)
movb (%rbx), %al
testb %al, %al
je 0x39911
xorl %r15d, %r15d
leaq 0x641e(%rip), %r14      # 0x3fc73
movsbl %al, %esi
movl $0x7, %edx
movq %r14, %rdi
callq 0x74b0
testq %rax, %rax
jne 0x39876
movb 0x1(%rbx,%r15), %al
incq %r15
testb %al, %al
jne 0x39855
cmpl $0x3, %r15d
je 0x3991b
cmpl $0x6, %r15d
jne 0x39911
leaq 0x65e7(%rip), %rsi      # 0x3fe78
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x7410
movl (%r14), %eax
jmp 0x3995b
cmpq $0x4, %rax
setb %al
cmpb $0x72, %bpl
setne %cl
orb %al, %cl
jne 0x398e0
cmpb $0x67, (%rbx)
jne 0x398e0
cmpb $0x62, 0x1(%rbx)
jne 0x398e0
cmpb $0x28, 0x2(%rbx)
jne 0x398e0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x39c31
movl $0x8, %ebx
leaq 0x17f34(%rip), %r15     # 0x51820
movq -0x8(%rbx,%r15), %rdi
movq %r14, %rsi
callq 0x75a0
testl %eax, %eax
je 0x39915
addq $0x10, %rbx
cmpq $0xa8, %rbx
jne 0x398ec
movl $0x808080, %eax         # imm = 0x808080
jmp 0x39975
xorl %eax, %eax
jmp 0x3995b
movl (%rbx,%r15), %eax
jmp 0x39975
leaq 0x6556(%rip), %rsi      # 0x3fe78
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x7410
movl (%r14), %ecx
movl %ecx, %eax
andl $0xf, %eax
movl %ecx, %edx
shll $0x4, %edx
andl $0xf00, %edx            # imm = 0xF00
orl %eax, %edx
shll $0x8, %ecx
andl $0xf0000, %ecx          # imm = 0xF0000
orl %edx, %ecx
movl %ecx, %eax
shll $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10, %ecx
movzbl %cl, %ecx
movl %eax, %edx
andl $0xff00, %edx           # imm = 0xFF00
orl %ecx, %edx
movzbl %al, %eax
shll $0x10, %eax
orl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movzbl (%rsi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x39aec
cmpl $0x6e, %ecx
je 0x39aec
movq %rdx, %rbx
movq %rsi, %r14
xorl %r12d, %r12d
leaq 0x62ba(%rip), %r13      # 0x3fc73
movq %rdx, 0x8(%rsp)
movb $0x0, 0x20(%rsp)
movb (%r14), %r15b
testb %r15b, %r15b
je 0x399f2
movsbl %r15b, %ebp
movl $0x7, %edx
movq %r13, %rdi
movl %ebp, %esi
callq 0x74b0
cmpb $0x2c, %bpl
je 0x399e9
testq %rax, %rax
je 0x399f6
movb 0x1(%r14), %r15b
incq %r14
jmp 0x399c6
xorl %eax, %eax
jmp 0x39a39
xorl %ebx, %ebx
movsbl %r15b, %ebp
movl $0x7, %edx
movq %r13, %rdi
movl %ebp, %esi
callq 0x74b0
cmpb $0x2c, %bpl
je 0x39a31
testq %rax, %rax
jne 0x39a31
cmpl $0x3e, %ebx
jg 0x39a25
movslq %ebx, %rax
incl %ebx
movb %r15b, 0x20(%rsp,%rax)
movb 0x1(%r14), %r15b
incq %r14
testb %r15b, %r15b
jne 0x399f8
movslq %ebx, %rax
movq 0x8(%rsp), %rbx
movb $0x0, 0x20(%rsp,%rax)
cmpb $0x0, 0x20(%rsp)
je 0x39abb
cmpl $0x7, %r12d
jg 0x39ab1
movq 0x10(%rsp), %r15
movsd 0xd060(%r15), %xmm0
movsd 0xd068(%r15), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
divsd 0x475e(%rip), %xmm0     # 0x3e1d8
movsd %xmm0, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x39560
xorpd %xmm1, %xmm1
movq %r15, %rdi
movl %eax, %esi
movsd 0x18(%rsp), %xmm2
callq 0x39e80
andpd 0x458a(%rip), %xmm0     # 0x3e030
movslq %r12d, %rax
incl %r12d
movlpd %xmm0, (%rbx,%rax,8)
cmpb $0x0, (%r14)
jne 0x399be
testl %r12d, %r12d
jle 0x39aea
movl %r12d, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
addsd (%rbx,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x39ac9
xorl %eax, %eax
movsd 0x47d0(%rip), %xmm1     # 0x3e2b0
ucomisd %xmm0, %xmm1
cmovbl %r12d, %eax
jmp 0x39aec
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x638c(%rip), %rsi      # 0x3fe92
callq 0x75a0
testl %eax, %eax
je 0x39b3a
leaq 0x6381(%rip), %rsi      # 0x3fe97
movq %rbx, %rdi
callq 0x75a0
testl %eax, %eax
je 0x39b3e
leaq 0x6374(%rip), %rsi      # 0x3fe9d
movq %rbx, %rdi
callq 0x75a0
testl %eax, %eax
sete %al
addb %al, %al
jmp 0x39b40
xorl %eax, %eax
jmp 0x39b40
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6357(%rip), %rsi      # 0x3fea4
callq 0x75a0
testl %eax, %eax
je 0x39b81
leaq 0x633a(%rip), %rsi      # 0x3fe97
movq %rbx, %rdi
callq 0x75a0
testl %eax, %eax
je 0x39b85
leaq 0x633a(%rip), %rsi      # 0x3feaa
movq %rbx, %rdi
callq 0x75a0
testl %eax, %eax
sete %al
addb %al, %al
jmp 0x39b87
xorl %eax, %eax
jmp 0x39b87
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__atof(char const*)
static double nsvg__atof(const char* s)
{
	char* cur = (char*)s;
	char* end = NULL;
	double res = 0.0, sign = 1.0;
	long long intPart = 0, fracPart = 0;
	char hasIntPart = 0, hasFracPart = 0;

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

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

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

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

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

	return res * sign;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x39d38
movsd 0x22e0(%rip), %xmm0     # 0x3c008
movsd %xmm0, 0x10(%rsp)
cmpl $0x2b, %eax
jne 0x39d49
incq %r14
jmp 0x39d49
incq %r14
movsd 0x449d(%rip), %xmm0     # 0x3e1e0
movsd %xmm0, 0x10(%rsp)
movb (%r14), %al
leal -0x3a(%rax), %ecx
cmpb $-0xa, %cl
jae 0x39d5f
xorpd %xmm1, %xmm1
xorl %ebp, %ebp
movq %r14, %rbx
jmp 0x39d9a
leaq 0x8(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x70c0
movq (%rbx), %rbx
cmpq %rbx, %r14
setne %bpl
jne 0x39d86
xorpd %xmm1, %xmm1
jmp 0x39d98
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm1
movb (%rbx), %al
cmpb $0x2e, %al
jne 0x39e0f
movb 0x1(%rbx), %al
incq %rbx
addb $-0x3a, %al
cmpb $-0xa, %al
jb 0x39e0f
movsd %xmm1, (%rsp)
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa, %edx
callq 0x70c0
movq (%r14), %r14
cmpq %r14, %rbx
je 0x39e0a
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r14, %rax
subq %rbx, %rax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd 0x2228(%rip), %xmm0     # 0x3c018
callq 0x7730
movsd 0x18(%rsp), %xmm2
divsd %xmm0, %xmm2
movsd (%rsp), %xmm1
addsd %xmm2, %xmm1
jmp 0x39e1b
movsd (%rsp), %xmm1
xorpd %xmm0, %xmm0
movq %rbx, %r14
testb %bpl, %bpl
je 0x39e77
movzbl (%r14), %eax
orl $0x20, %eax
cmpl $0x65, %eax
jne 0x39e6d
movsd %xmm1, (%rsp)
incq %r14
leaq 0x8(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x75b0
cmpq (%rbx), %r14
je 0x39e68
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd 0x21c0(%rip), %xmm0     # 0x3c018
callq 0x7730
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
jmp 0x39e6d
movsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__convertToPixels(NSVGparser*, NSVGcoordinate, double, double)
static double nsvg__convertToPixels(NSVGparser* p, NSVGcoordinate c, double orig, double length)
{
	NSVGattrib* attr = nsvg__getAttr(p);
	switch (c.units) {
		case NSVG_UNITS_USER:		return c.value;
		case NSVG_UNITS_PX:			return c.value;
		case NSVG_UNITS_PT:			return c.value / 72.0 * p->dpi;
		case NSVG_UNITS_PC:			return c.value / 6.0 * p->dpi;
		case NSVG_UNITS_MM:			return c.value / 25.4 * p->dpi;
		case NSVG_UNITS_CM:			return c.value / 2.54 * p->dpi;
		case NSVG_UNITS_IN:			return c.value * p->dpi;
		case NSVG_UNITS_EM:			return c.value * attr->fontSize;
		case NSVG_UNITS_EX:			return c.value * attr->fontSize * 0.52; // x-height of Helvetica.
		case NSVG_UNITS_PERCENT:	return orig + c.value / 100.0 * length;
		default:					return c.value;
	}
	return c.value;
}

// Assembly:
addl $-0x2, %esi
cmpl $0x7, %esi
ja 0x39ef9
movslq 0xd000(%rdi), %rax
imulq $0x1a0, %rax, %rax      # imm = 0x1A0
addq %rdi, %rax
leaq 0x4528(%rip), %rcx      # 0x3e3c8
movslq (%rcx,%rsi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
divsd 0x440f(%rip), %xmm0     # 0x3e2c0
jmp 0x39ecf
divsd 0x43fd(%rip), %xmm0     # 0x3e2b8
jmp 0x39ecf
divsd 0x41cb(%rip), %xmm0     # 0x3e090
jmp 0x39ecf
divsd 0x4389(%rip), %xmm0     # 0x3e258
mulsd 0xd080(%rdi), %xmm0
retq
mulsd 0x178(%rax), %xmm0
mulsd 0x43e0(%rip), %xmm0     # 0x3e2c8
retq
divsd 0x43af(%rip), %xmm0     # 0x3e2a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
retq
mulsd 0x178(%rax), %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
movl $0x0, (%rcx)
xorl %ebx, %ebx
movzbl (%r12,%rbx), %eax
testl %eax, %eax
je 0x3a002
cmpl $0x28, %eax
je 0x39fe8
incq %rbx
jmp 0x39fd5
leaq (%r12,%rbx), %r13
testb %al, %al
je 0x3a002
movzbl %al, %eax
cmpl $0x29, %eax
je 0x3a018
movb 0x1(%r12,%rbx), %al
incq %rbx
jmp 0x39fec
movl $0x1, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %rbx, %r12
cmpq %r12, %r13
jae 0x3a007
xorl %eax, %eax
leaq 0x10(%rsp), %r15
movzbl (%r13), %ecx
cmpq $0x2e, %rcx
ja 0x3a076
movabsq $0x680000000000, %rdx   # imm = 0x680000000000
btq %rcx, %rdx
jae 0x3a076
cmpl %ebp, %eax
jge 0x3a083
movq %r13, %rdi
movq %r15, %rsi
callq 0x3a087
movq %rax, %r13
movq %r15, %rdi
callq 0x39d04
movslq (%r14), %rcx
leal 0x1(%rcx), %eax
movl %eax, (%r14)
movq 0x8(%rsp), %rdx
movsd %xmm0, (%rdx,%rcx,8)
cmpq %r12, %r13
jb 0x3a027
jmp 0x3a007
addb $-0x3a, %cl
cmpb $-0xa, %cl
jae 0x3a042
incq %r13
jmp 0x3a06f
xorl %ebx, %ebx
jmp 0x3a007
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseNumber(char const*, char*, int)
static const char* nsvg__parseNumber(const char* s, char* it, const int size)
{
	const int last = size-1;
	int i = 0;

	// sign
	if (*s == '-' || *s == '+') {
		if (i < last) it[i++] = *s;
		s++;
	}
	// integer part
	while (*s && nsvg__isdigit(*s)) {
		if (i < last) it[i++] = *s;
		s++;
	}
	if (*s == '.') {
		// decimal point
		if (i < last) it[i++] = *s;
		s++;
		// fraction part
		while (*s && nsvg__isdigit(*s)) {
			if (i < last) it[i++] = *s;
			s++;
		}
	}
	// exponent
	if (*s == 'e' || *s == 'E') {
		if (i < last) it[i++] = *s;
		s++;
		if (*s == '-' || *s == '+') {
			if (i < last) it[i++] = *s;
			s++;
		}
		while (*s && nsvg__isdigit(*s)) {
			if (i < last) it[i++] = *s;
			s++;
		}
	}
	it[i] = '\0';

	return s;
}

// Assembly:
movq %rdi, %rax
movzbl (%rdi), %edx
cmpl $0x2d, %edx
je 0x3a099
xorl %ecx, %ecx
cmpl $0x2b, %edx
jne 0x3a0a6
movb %dl, (%rsi)
movb 0x1(%rax), %dl
incq %rax
movl $0x1, %ecx
testb %dl, %dl
je 0x3a14b
incq %rax
leal -0x3a(%rdx), %edi
cmpb $-0xa, %dil
jb 0x3a0d5
cmpl $0x3e, %ecx
jg 0x3a0c7
movslq %ecx, %rdi
incl %ecx
movb %dl, (%rsi,%rdi)
movb (%rax), %dl
incq %rax
testb %dl, %dl
jne 0x3a0b1
decq %rax
jmp 0x3a14b
cmpb $0x2e, %dl
jne 0x3a10c
cmpl $0x3e, %ecx
jg 0x3a0e8
movslq %ecx, %rdx
incl %ecx
movb $0x2e, (%rsi,%rdx)
movb (%rax), %dl
testb %dl, %dl
je 0x3a14b
leal -0x3a(%rdx), %edi
cmpb $-0xa, %dil
jb 0x3a10f
cmpl $0x3e, %ecx
jg 0x3a104
movslq %ecx, %rdi
incl %ecx
movb %dl, (%rsi,%rdi)
movb 0x1(%rax), %dl
incq %rax
jmp 0x3a0ea
decq %rax
movzbl %dl, %edi
orl $0x20, %edi
cmpl $0x65, %edi
jne 0x3a14b
cmpl $0x3e, %ecx
jg 0x3a127
movslq %ecx, %rdi
incl %ecx
movb %dl, (%rsi,%rdi)
movzbl 0x1(%rax), %edx
cmpl $0x2d, %edx
je 0x3a135
cmpl $0x2b, %edx
jne 0x3a153
cmpl $0x3e, %ecx
jg 0x3a142
movslq %ecx, %rdi
incl %ecx
movb %dl, (%rsi,%rdi)
movb 0x2(%rax), %dl
addq $0x2, %rax
jmp 0x3a156
movslq %ecx, %rcx
movb $0x0, (%rsi,%rcx)
retq
incq %rax
leal -0x3a(%rdx), %edi
cmpb $-0xa, %dil
jb 0x3a14b
cmpl $0x3e, %ecx
jg 0x3a16c
movslq %ecx, %rdi
incl %ecx
movb %dl, (%rsi,%rdi)
movb 0x1(%rax), %dl
jmp 0x3a153
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__getNextPathItem(char const*, char*)
static const char* nsvg__getNextPathItem(const char* s, char* it)
{
	it[0] = '\0';
	// Skip white spaces and commas
	while (*s && (nsvg__isspace(*s) || *s == ',')) s++;
	if (!*s) return s;
	if (*s == '-' || *s == '+' || *s == '.' || nsvg__isdigit(*s)) {
		s = nsvg__parseNumber(s, it, 64);
	} else {
		// Parse command
		it[0] = *s++;
		it[1] = '\0';
		return s;
	}

	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb $0x0, (%rsi)
movb (%rdi), %r12b
testb %r12b, %r12b
je 0x3a1c0
movq %rsi, %r14
incq %rbx
leaq 0x5adf(%rip), %r15      # 0x3fc73
movsbl %r12b, %ebp
movl $0x7, %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x74b0
cmpb $0x2c, %bpl
je 0x3a1b2
testq %rax, %rax
je 0x3a1cc
movb (%rbx), %r12b
incq %rbx
testb %r12b, %r12b
jne 0x3a194
decq %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x2e, %r12b
ja 0x3a1fc
movzbl %r12b, %eax
movabsq $0x680000000000, %rcx   # imm = 0x680000000000
btq %rax, %rcx
jae 0x3a1fc
decq %rbx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3a087
leal -0x3a(%r12), %eax
cmpb $-0xa, %al
jae 0x3a1e6
movb %r12b, (%r14)
movb $0x0, 0x1(%r14)
jmp 0x3a1c0
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__addElt(NSVGparser*, int, double, double, double, double, double, double)
static void nsvg__addElt(NSVGparser *p, int Type, double x, double y, double bz1_x, double bz1_y, double bz2_x, double bz2_y)
{
    NSVGPathElt *cElt = (NSVGPathElt *)malloc(sizeof(NSVGPathElt));
    if ( cElt == NULL )
    {
        fprintf(stderr, "No more memory, nsvg__addElt\n");
        return;
    }
    cElt->Type = Type;
    cElt->next = NULL;
    cElt->EndX = x;
    cElt->EndY = y;
    cElt->BzCtrl1X = bz1_x;
    cElt->BzCtrl1Y = bz1_y;
    cElt->BzCtrl2X = bz2_x;
    cElt->BzCtrl2Y = bz2_y;
    if ( p->FirstElt == NULL )
        p->FirstElt = cElt;
    else
        p->LastElt->next = cElt;
    p->nElts++;
    p->LastElt = cElt;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movsd %xmm5, 0x30(%rsp)
movsd %xmm4, 0x28(%rsp)
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movl $0x40, %edi
callq 0x7590
testq %rax, %rax
je 0x3aa2c
movl %ebp, (%rax)
movq $0x0, 0x38(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rax)
cmpq $0x0, 0xd008(%rbx)
je 0x3aa0e
movq 0xd010(%rbx), %rcx
addq $0x38, %rcx
jmp 0x3aa15
leaq 0xd008(%rbx), %rcx
movq %rax, (%rcx)
incl 0xd028(%rbx)
movq %rax, 0xd010(%rbx)
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
callq 0x7ae9
jmp 0x3aa25
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__xformInverse(double*, double*)
static void nsvg__xformInverse(double* inv, double* t)
{
	double invdet, det = t[0] * t[3] - t[2] * t[1];
	if (det > -1e-6 && det < 1e-6) {
		nsvg__xformIdentity(t);
		return;
	}
	invdet = 1.0 / det;
	inv[0] = (t[3] * invdet);
	inv[2] = (-t[2] * invdet);
	inv[4] = ((t[2] * t[5] - t[3] * t[4]) * invdet);
	inv[1] = -t[1] * invdet;
	inv[3] = (t[0] * invdet);
	inv[5] = ((t[1] * t[4] - t[0] * t[5]) * invdet);
}

// Assembly:
movsd 0x8(%rsi), %xmm0
movsd 0x18(%rsi), %xmm1
mulsd 0x10(%rsi), %xmm0
movsd (%rsi), %xmm2
mulsd %xmm1, %xmm2
subsd %xmm0, %xmm2
movapd 0x31f0(%rip), %xmm0     # 0x3e030
andpd %xmm2, %xmm0
movsd 0x33bc(%rip), %xmm3     # 0x3e208
ucomisd %xmm0, %xmm3
jbe 0x3ae75
leaq 0x8(%rsi), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rsi)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
movq %rcx, 0x18(%rsi)
movupd %xmm0, 0x20(%rsi)
retq
movsd 0x118b(%rip), %xmm0     # 0x3c008
divsd %xmm2, %xmm0
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
movsd 0x10(%rsi), %xmm1
movapd 0x322a(%rip), %xmm2     # 0x3e0c0
xorpd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdi)
movsd 0x10(%rsi), %xmm1
movsd 0x20(%rsi), %xmm3
mulsd 0x18(%rsi), %xmm3
mulsd 0x28(%rsi), %xmm1
subsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rdi)
movsd 0x8(%rsi), %xmm1
xorpd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdi)
movsd (%rsi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rdi)
movsd 0x8(%rsi), %xmm1
movsd 0x28(%rsi), %xmm2
mulsd (%rsi), %xmm2
mulsd 0x20(%rsi), %xmm1
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/Geometry.h
// Function: operator<<(std::ostream&, Polygon const&)
ostream& operator<<(ostream& output,const Polygon& Poly)
        {
            output<<"Polygon with " << Poly.nVertices << " vertices : " ;
            output << Poly._Vertices[0];
            for ( int i = 1; i < Poly.nVertices; i++ )
                output << ", " << Poly._Vertices[i];
            output << '\n';
            return output;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4814(%rip), %rsi      # 0x3ffb3
movl $0xd, %edx
callq 0x74e0
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x7720
leaq 0x4805(%rip), %rsi      # 0x3ffc1
movl $0xc, %edx
movq %rax, %rdi
callq 0x74e0
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x3b894
cmpl $0x2, 0x8(%r14)
jl 0x3b81e
movl $0x1, %r12d
movl $0x10, %r13d
leaq 0x47df(%rip), %r15      # 0x3ffce
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x74e0
movq 0x10(%r14), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x3b894
incq %r12
movslq 0x8(%r14), %rax
addq $0x10, %r13
cmpq %rax, %r12
jl 0x3b7ef
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x74e0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/joao18araujo[P]pierluigi/src/counterpoint.cpp
// Function: Counterpoint::is_thesis(Note&, int, Song*)
bool Counterpoint::is_thesis(Note & note, int offset, Song * song){
  // printf("%d %d\n", song->time.compass_duration(), song->time.base_note_duration());
  int compass_position = (note.absolute_time + offset) % song->time.compass_duration();
  int time = compass_position / song->time.base_note_duration() + 1;

  if(song->time.times == 4){
    return (time == 1 || time == 3);
  }else if(song->time.times == 2 || song->time.times == 3){
    return time ==  1;
  }

  return true;
}

// Assembly:
movq %rdx, %rcx
addl 0x4(%rdi), %esi
movl $0x20, %eax
xorl %edx, %edx
idivl 0xcc(%rcx)
movl %eax, %edi
movl 0xc8(%rcx), %r8d
movl %r8d, %ecx
imull %eax, %ecx
movl %esi, %eax
cltd
idivl %ecx
movl %edx, %eax
cltd
idivl %edi
leal -0x2(%r8), %ecx
cmpl $0x2, %ecx
jae 0xb033
testl %eax, %eax
jmp 0xb040
movb $0x1, %cl
cmpl $0x4, %r8d
jne 0xb043
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
sete %cl
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/joao18araujo[P]pierluigi/src/interval.cpp
// Function: Interval::Interval(Note, Note)
Interval::Interval(Note first, Note second){
  this->quantitative = abs(first.note_number - second.note_number) + 1;
  int diff = second.note_number - first.note_number;
  this->direction = (diff ? diff/abs(diff) : 0);
  this->half_tones = abs(first.midi_number - second.midi_number);

  classify_qualitative();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movl 0x50(%rsi), %eax
xorl %ecx, %ecx
xorl %edi, %edi
subl 0x50(%rdx), %eax
setle %dil
leal -0x1(%rdi,%rdi), %edi
cmovel %ecx, %edi
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
incl %ecx
movl %ecx, (%rbx)
movw %di, 0x2c(%rbx)
movl 0x4c(%rsi), %eax
subl 0x4c(%rdx), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movl %ecx, 0x28(%rbx)
movq %rbx, %rdi
callq 0x15308
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
cmpq %r15, %rdi
je 0x152ff
movq (%r15), %rsi
incq %rsi
callq 0x5360
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/joao18araujo[P]pierluigi/src/interval.cpp
// Function: Interval::is_dissonant()
bool Interval::is_dissonant(){
  // int quant = this->quantitative;
  int note_with_accidental_diff = this->half_tones;
  while(note_with_accidental_diff > N_SCALE)
    note_with_accidental_diff -= N_SCALE;


  // while(quant > N_NOTES + 1)
  //   quant -= N_NOTES;
  return dissonant_half_tones.find(note_with_accidental_diff) != dissonant_half_tones.end();
}

// Assembly:
pushq %rax
movl 0x28(%rdi), %eax
cmpl $0xc, %eax
movl $0xc, %ecx
cmovll %eax, %ecx
movl %eax, %edx
subl %ecx, %edx
addl $0xb, %edx
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
imulq %rdx, %rcx
shrq $0x23, %rcx
shll $0x2, %ecx
leal (%rcx,%rcx,2), %ecx
movl %edx, %edi
subl %ecx, %edi
subl %edx, %edi
addl %eax, %edi
leaq 0x4(%rsp), %rsi
movl %edi, (%rsi)
leaq 0x9bfd125(%rip), %rdi   # 0x9c12750
callq 0x16078
testq %rax, %rax
setne %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/joao18araujo[P]pierluigi/src/interval.cpp
// Function: Interval::interval_to_note(Note, Interval)
Note Interval::interval_to_note(Note note, Interval interval){
  if(note.rest()){
    return note;
  }

  int midi_number = note.midi_number + interval.half_tones * interval.direction;
  int note_number = note.note_number + (interval.quantitative - 1) * interval.direction;
  Note n(midi_number);

  if(n.note_number == note_number){
    n.duration = note.duration;
    return n;
  }else{
    vector<Note> notes = n.enarmonies();
    for(auto & other_note : notes){
      if(other_note.note_number == note_number){
        other_note.duration = note.duration;
        return other_note;
      }
    }
  }

  return Note();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1c1fa
testb %al, %al
je 0x15ae1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1aa22
jmp 0x15bb0
movswl 0x2c(%r15), %eax
movl 0x28(%r15), %esi
imull %eax, %esi
addl 0x4c(%r14), %esi
movl (%r15), %ebp
decl %ebp
imull %eax, %ebp
addl 0x50(%r14), %ebp
leaq 0x20(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x1ac26
cmpl %ebp, 0x50(%r15)
jne 0x15b26
movl (%r14), %eax
leaq 0x20(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x1aa22
jmp 0x15b7a
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1bdf4
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
cmpq %rax, %rsi
je 0x15b4f
cmpl %ebp, 0x50(%rsi)
je 0x15b63
addq $0x58, %rsi
jmp 0x15b3f
leaq 0x8(%rsp), %rdi
callq 0xb1a2
movq %rbx, %rdi
callq 0x1aada
jmp 0x15b7a
movl (%r14), %eax
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x1aa22
leaq 0x8(%rsp), %rdi
callq 0xb1a2
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15b95
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x5360
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15bb0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5360
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb1a2
jmp 0x15bd2
jmp 0x15bcf
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb0e0
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/joao18araujo[P]pierluigi/src/note.cpp
// Function: Note::Note(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, bool)
Note::Note(const string note, const string accidental, const int octave, const int duration, bool linked) {
  this->valid = true;
  this->note = note;

  this->accidental = accidental;
  this->duration = duration;
  this->linked = linked;

  if(note != "r"){
    this->octave = octave;
    this->midi_number = (octave + 1) * N_SCALE + notes_with_accidental_to_number[this->full_note()];
    this->note_number = (octave + 1) * N_NOTES + notes_to_number[this->note];
  }else{
    this->octave = 0;
    this->midi_number = 0;
    this->note_number = 0;
  }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movl $0x0, 0x4(%rdi)
addq $0x8, %rdi
leaq 0x18(%r15), %rax
movq %rax, 0x20(%rsp)
movq %rax, 0x8(%r15)
xorl %eax, %eax
movq %rax, 0x10(%r15)
movb %al, 0x18(%r15)
leaq 0x28(%r15), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x38(%r15), %rcx
movq %rcx, 0x18(%rsp)
movq %rcx, 0x28(%r15)
movq %rax, 0x30(%r15)
movb %al, 0x38(%r15)
movw $0x1, 0x54(%r15)
movq %rdi, 0x8(%rsp)
callq 0x51e0
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x51e0
movl %r14d, (%r15)
movb %bpl, 0x55(%r15)
leaq 0x212f9(%rip), %rsi     # 0x3bbf5
movq %r13, %rdi
callq 0x5100
testl %eax, %eax
je 0x1a980
movl %r12d, 0x48(%r15)
leaq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1c217
leaq 0x9bf91a1(%rip), %rdi   # 0x9c13ac8
leaq 0x28(%rsp), %rsi
callq 0x1c818
leal 0x4(,%r12,4), %ecx
leal (%rcx,%rcx,2), %ecx
addl (%rax), %ecx
movl %ecx, 0x4c(%r15)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a95d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5360
leaq 0x9bf919c(%rip), %rdi   # 0x9c13b00
movq 0x8(%rsp), %rsi
callq 0x1c936
incl %r12d
leal (,%r12,8), %ecx
subl %r12d, %ecx
addl (%rax), %ecx
jmp 0x1a98a
movq $0x0, 0x48(%r15)
xorl %ecx, %ecx
movl %ecx, 0x50(%r15)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a9c2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5360
jmp 0x1a9c2
jmp 0x1a9bf
movq %rax, %r15
movq 0x10(%rsp), %rax
movq (%rax), %rdi
cmpq 0x18(%rsp), %rdi
je 0x1a9e1
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5360
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq 0x20(%rsp), %rdi
je 0x1aa00
movq 0x20(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5360
movq %r15, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/joao18araujo[P]pierluigi/src/note.cpp
// Function: Note::Note(Note const&)
Note::Note(const Note & note){
  this->valid = true;
  this->duration = note.duration;
  this->note = note.note;
  this->accidental = note.accidental;
  this->octave = note.octave;
  this->midi_number = note.midi_number;
  this->note_number = note.note_number;
  this->linked = note.linked;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r15
movl $0x0, 0x4(%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r14
movq %r14, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r13
leaq 0x38(%rdi), %rbp
movq %rbp, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movw $0x1, 0x54(%rdi)
movl (%rsi), %eax
movl %eax, (%rdi)
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x51e0
leaq 0x28(%r12), %rsi
movq %r13, %rdi
callq 0x51e0
movq 0x48(%r12), %rax
movq %rax, 0x48(%r15)
movl 0x50(%r12), %eax
movl %eax, 0x50(%r15)
movb 0x55(%r12), %al
movb %al, 0x55(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x1aac7
movq (%rbp), %rsi
incq %rsi
callq 0x5360
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58eb
movq %r15, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/joao18araujo[P]pierluigi/src/note.cpp
// Function: Note::Note()
Note::Note(){
  this->valid = false;
  this->duration = 0;
  this->note = "c";
  this->accidental = "";
  this->octave = BELOW_MIDDLE_C_OCTAVE;
  this->midi_number = (octave + 1) * N_SCALE + notes_with_accidental_to_number[this->full_note()];
  this->note_number = (octave + 1) * N_NOTES + notes_to_number[this->note];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movw $0x0, 0x54(%rdi)
movq %rax, (%rdi)
leaq 0x209f0(%rip), %rcx     # 0x3b513
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5510
movq 0x30(%r15), %rdx
leaq 0x20bba(%rip), %rcx     # 0x3b6fa
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5510
movl $0x3, 0x48(%r15)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1c217
leaq 0x9bf8f5c(%rip), %rdi   # 0x9c13ac8
leaq 0x8(%rsp), %rsi
callq 0x1c818
movl (%rax), %eax
addl $0x30, %eax
movl %eax, 0x4c(%r15)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ab9a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5360
movl 0x48(%r15), %ebp
leaq 0x9bf8f5b(%rip), %rdi   # 0x9c13b00
movq %rbx, %rsi
callq 0x1c936
leal (,%rbp,8), %ecx
subl %ebp, %ecx
movl (%rax), %eax
addl %ecx, %eax
addl $0x7, %eax
movl %eax, 0x50(%r15)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1abf5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5360
jmp 0x1abf5
jmp 0x1abf2
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x1ac09
movq (%r13), %rsi
incq %rsi
callq 0x5360
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1ac1d
movq (%r12), %rsi
incq %rsi
callq 0x5360
movq %r15, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/joao18araujo[P]pierluigi/src/note.cpp
// Function: Note::set_full_note(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Note::set_full_note(string s){
  string only_note = "";
  only_note += s[0];
  this->note = only_note;
  s.erase(s.begin());
  this->accidental = s;
  this->midi_number = (octave + 1) * N_SCALE + notes_with_accidental_to_number[this->full_note()];
  this->note_number = (octave + 1) * N_NOTES + notes_to_number[this->note];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x20913(%rip), %rdx     # 0x3b6fa
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xb5f8
movq (%r15), %rax
movsbl (%rax), %esi
movq %r14, %rdi
callq 0x52e0
leaq 0x8(%rbx), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x51e0
movl $0x1, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x5400
leaq 0x28(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x51e0
movl 0x48(%rbx), %r15d
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1c217
leaq 0x9bf8c7d(%rip), %rdi   # 0x9c13ac8
leaq 0x20(%rsp), %rsi
callq 0x1c818
leal (%r15,%r15,2), %ecx
leal 0xc(,%rcx,4), %ecx
addl (%rax), %ecx
movl %ecx, 0x4c(%rbx)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ae80
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5360
movl 0x48(%rbx), %r15d
leaq 0x9bf8c75(%rip), %rdi   # 0x9c13b00
movq %r14, %rsi
callq 0x1c936
leal (,%r15,8), %ecx
subl %r15d, %ecx
movl (%rax), %eax
addl %ecx, %eax
addl $0x7, %eax
movl %eax, 0x50(%rbx)
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1aebe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5360
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1aef3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5360
jmp 0x1aef3
jmp 0x1aef0
jmp 0x1aef0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1af09
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5360
movq %rbx, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/joao18araujo[P]pierluigi/src/song.cpp
// Function: Song::back()
Note Song::back() {
  if(notes.size() > 0)
    return notes.back();
  else
    return Note();
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
cmpq (%rax), %rsi
je 0x2435c
addq $-0x58, %rsi
movq %rbx, %rdi
callq 0x1aa22
jmp 0x24364
movq %rbx, %rdi
callq 0x1aada
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)