LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__xformSetRotation(double*, double)
static void nsvg__xformSetRotation(double* t, double a)
{
	double cs = cos(a), sn = sin(a);
	t[0] = cs; t[1] = sn;
	t[2] = -sn; t[3] = cs;
	t[4] = 0.0; t[5] = 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x99f0
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x9120
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseUnits(char const*)
static int nsvg__parseUnits(const char* units)
{
	if (units[0] == 'p' && units[1] == 'x')
		return NSVG_UNITS_PX;
	else if (units[0] == 'p' && units[1] == 't')
		return NSVG_UNITS_PT;
	else if (units[0] == 'p' && units[1] == 'c')
		return NSVG_UNITS_PC;
	else if (units[0] == 'm' && units[1] == 'm')
		return NSVG_UNITS_MM;
	else if (units[0] == 'c' && units[1] == 'm')
		return NSVG_UNITS_CM;
	else if (units[0] == 'i' && units[1] == 'n')
		return NSVG_UNITS_IN;
	else if (units[0] == '%')
		return NSVG_UNITS_PERCENT;
	else if (units[0] == 'e' && units[1] == 'm')
		return NSVG_UNITS_EM;
	else if (units[0] == 'e' && units[1] == 'x')
		return NSVG_UNITS_EX;
	return NSVG_UNITS_USER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x70, %eax
jne 0x7bf9d
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x78, %eax
jne 0x7bf9d
movl $0x1, -0x4(%rbp)
jmp 0x7c0c3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x70, %eax
jne 0x7bfc2
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x74, %eax
jne 0x7bfc2
movl $0x2, -0x4(%rbp)
jmp 0x7c0c3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x70, %eax
jne 0x7bfe7
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x63, %eax
jne 0x7bfe7
movl $0x3, -0x4(%rbp)
jmp 0x7c0c3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6d, %eax
jne 0x7c00c
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x6d, %eax
jne 0x7c00c
movl $0x4, -0x4(%rbp)
jmp 0x7c0c3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x63, %eax
jne 0x7c031
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x6d, %eax
jne 0x7c031
movl $0x5, -0x4(%rbp)
jmp 0x7c0c3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x69, %eax
jne 0x7c053
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x6e, %eax
jne 0x7c053
movl $0x6, -0x4(%rbp)
jmp 0x7c0c3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x7c068
movl $0x7, -0x4(%rbp)
jmp 0x7c0c3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x65, %eax
jne 0x7c08a
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x6d, %eax
jne 0x7c08a
movl $0x8, -0x4(%rbp)
jmp 0x7c0c3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x65, %eax
jne 0x7c0ac
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x78, %eax
jne 0x7c0ac
movl $0x9, -0x4(%rbp)
jmp 0x7c0c3
jmp 0x7c0ae
jmp 0x7c0b0
jmp 0x7c0b2
jmp 0x7c0b4
jmp 0x7c0b6
jmp 0x7c0b8
jmp 0x7c0ba
jmp 0x7c0bc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__resetPath(NSVGparser*)
static void nsvg__resetPath(NSVGparser* p)
{
    nsvg__deletePathElts(p->FirstElt);
    p->LastElt = NULL;
    p->FirstElt = NULL;
	p->nElts = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xd008(%rax), %rdi
callq 0x7e1f0
movq -0x8(%rbp), %rax
movq $0x0, 0xd010(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xd008(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xd028(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x7c173
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x76fd0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
jne 0x7c16d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x7c17c
jmp 0x7c18a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7c137
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x7c19d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7c21b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x7c1d2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x7c1d2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x7c1d2
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x7b0f0
cmpl $0x0, %eax
je 0x7c1ea
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x40, %edx
callq 0x7bab0
movq %rax, -0x10(%rbp)
jmp 0x7c213
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7c21b
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__pathMoveTo(NSVGparser*, double*, double*, double*, int)
static void nsvg__pathMoveTo(NSVGparser* p, double* cpx, double* cpy, double* args, int rel)
{
	if (rel) {
		*cpx += args[0];
		*cpy += args[1];
	} else {
		*cpx = args[0];
		*cpy = args[1];
	}
	nsvg__moveTo(p, *cpx, *cpy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x7c2ad
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x7c2ce
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
callq 0x7dc30
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__getArgsPerElement(char)
static int nsvg__getArgsPerElement(char cmd)
{
	switch (cmd) {
		case 'v':
		case 'V':
		case 'h':
		case 'H':
			return 1;
		case 'm':
		case 'M':
		case 'l':
		case 'L':
		case 't':
		case 'T':
			return 2;
		case 'q':
		case 'Q':
		case 's':
		case 'S':
			return 4;
		case 'c':
		case 'C':
			return 6;
		case 'a':
		case 'A':
			return 7;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x35, %eax
ja 0x7c34d
movq -0x10(%rbp), %rax
leaq 0x8095(%rip), %rcx      # 0x843ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x7c354
movl $0x2, -0x4(%rbp)
jmp 0x7c354
movl $0x4, -0x4(%rbp)
jmp 0x7c354
movl $0x6, -0x4(%rbp)
jmp 0x7c354
movl $0x7, -0x4(%rbp)
jmp 0x7c354
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__pathLineTo(NSVGparser*, double*, double*, double*, int)
static void nsvg__pathLineTo(NSVGparser* p, double* cpx, double* cpy, double* args, int rel)
{
	if (rel) {
		*cpx += args[0];
		*cpy += args[1];
	} else {
		*cpx = args[0];
		*cpy = args[1];
	}
	nsvg__lineTo(p, *cpx, *cpy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x7c3ad
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x7c3ce
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
callq 0x7e230
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__pathHLineTo(NSVGparser*, double*, double*, double*, int)
static void nsvg__pathHLineTo(NSVGparser* p, double* cpx, double* cpy, double* args, int rel)
{
	if (rel)
		*cpx += args[0];
	else
		*cpx = args[0];
	nsvg__lineTo(p, *cpx, *cpy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x7c428
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x7c438
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
callq 0x7e230
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__pathVLineTo(NSVGparser*, double*, double*, double*, int)
static void nsvg__pathVLineTo(NSVGparser* p, double* cpx, double* cpy, double* args, int rel)
{
	if (rel)
		*cpy += args[0];
	else
		*cpy = args[0];
	nsvg__lineTo(p, *cpx, *cpy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x7c498
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x7c4a8
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
callq 0x7e230
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__pathCubicBezTo(NSVGparser*, double*, double*, double*, double*, double*, int)
static void nsvg__pathCubicBezTo(NSVGparser* p, double* cpx, double* cpy,
								 double* cpx2, double* cpy2, double* args, int rel)
{
	double x2, y2, cx1, cy1, cx2, cy2;

	if (rel) {
		cx1 = *cpx + args[0];
		cy1 = *cpy + args[1];
		cx2 = *cpx + args[2];
		cy2 = *cpy + args[3];
		x2 = *cpx + args[4];
		y2 = *cpy + args[5];
	} else {
		cx1 = args[0];
		cy1 = args[1];
		cx2 = args[2];
		cy2 = args[3];
		x2 = args[4];
		y2 = args[5];
	}

	nsvg__cubicBezTo(p, cx1,cy1, cx2,cy2, x2,y2);

	*cpx2 = cx2;
	*cpy2 = cy2;
	*cpx = x2;
	*cpy = y2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x0, 0x10(%rbp)
je 0x7c582
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd 0x20(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd 0x28(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x7c5d5
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x30(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x30(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x48(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
movsd -0x58(%rbp), %xmm2
movsd -0x60(%rbp), %xmm3
movsd -0x38(%rbp), %xmm4
movsd -0x40(%rbp), %xmm5
callq 0x7e3a0
movsd -0x58(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x60(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x40(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__pathCubicBezShortTo(NSVGparser*, double*, double*, double*, double*, double*, int)
static void nsvg__pathCubicBezShortTo(NSVGparser* p, double* cpx, double* cpy,
									  double* cpx2, double* cpy2, double* args, int rel)
{
	double x1, y1, x2, y2, cx1, cy1, cx2, cy2;

	x1 = *cpx;
	y1 = *cpy;
	if (rel) {
		cx2 = *cpx + args[0];
		cy2 = *cpy + args[1];
		x2 = *cpx + args[2];
		y2 = *cpy + args[3];
	} else {
		cx2 = args[0];
		cy2 = args[1];
		x2 = args[2];
		y2 = args[3];
	}

	cx1 = 2*x1 - *cpx2;
	cy1 = 2*y1 - *cpy2;

	nsvg__cubicBezTo(p, cx1,cy1, cx2,cy2, x2,y2);

	*cpx2 = cx2;
	*cpy2 = cy2;
	*cpx = x2;
	*cpy = y2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
cmpl $0x0, 0x10(%rbp)
je 0x7c6dc
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
jmp 0x7c713
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x30(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x40(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd (%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x58(%rbp), %xmm0
movsd -0x60(%rbp), %xmm1
movsd -0x68(%rbp), %xmm2
movsd -0x70(%rbp), %xmm3
movsd -0x48(%rbp), %xmm4
movsd -0x50(%rbp), %xmm5
callq 0x7e3a0
movsd -0x68(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x70(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x48(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x50(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__pathQuadBezTo(NSVGparser*, double*, double*, double*, double*, double*, int)
static void nsvg__pathQuadBezTo(NSVGparser* p, double* cpx, double* cpy,
								double* cpx2, double* cpy2, double* args, int rel)
{
	double x1, y1, x2, y2, cx, cy;
	double cx1, cy1, cx2, cy2;

	x1 = *cpx;
	y1 = *cpy;
	if (rel) {
		cx = *cpx + args[0];
		cy = *cpy + args[1];
		x2 = *cpx + args[2];
		y2 = *cpy + args[3];
	} else {
		cx = args[0];
		cy = args[1];
		x2 = args[2];
		y2 = args[3];
	}

	// Convert to cubic bezier
	cx1 = x1 + 2.0/3.0*(cx - x1);
	cy1 = y1 + 2.0/3.0*(cy - y1);
	cx2 = x2 + 2.0/3.0*(cx - x2);
	cy2 = y2 + 2.0/3.0*(cy - y2);

	nsvg__cubicBezTo(p, cx1,cy1, cx2,cy2, x2,y2);

	*cpx2 = cx;
	*cpy2 = cy;
	*cpx = x2;
	*cpy = y2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
cmpl $0x0, 0x10(%rbp)
je 0x7c87f
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
jmp 0x7c8b6
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x30(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x38(%rbp), %xmm1
movsd -0x58(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
movsd 0x796b(%rip), %xmm2     # 0x84238
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x40(%rbp), %xmm1
movsd -0x60(%rbp), %xmm0
subsd -0x40(%rbp), %xmm0
movsd 0x7947(%rip), %xmm2     # 0x84238
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x48(%rbp), %xmm1
movsd -0x58(%rbp), %xmm0
subsd -0x48(%rbp), %xmm0
movsd 0x7923(%rip), %xmm2     # 0x84238
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x78(%rbp)
movsd -0x50(%rbp), %xmm1
movsd -0x60(%rbp), %xmm0
subsd -0x50(%rbp), %xmm0
movsd 0x78ff(%rip), %xmm2     # 0x84238
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x68(%rbp), %xmm0
movsd -0x70(%rbp), %xmm1
movsd -0x78(%rbp), %xmm2
movsd -0x80(%rbp), %xmm3
movsd -0x48(%rbp), %xmm4
movsd -0x50(%rbp), %xmm5
callq 0x7e3a0
movsd -0x58(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x60(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x48(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x50(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__moveTo(NSVGparser*, double, double)
static void nsvg__moveTo(NSVGparser* p, double x, double y)
{
	if (p->nElts > 0)
	{
        fprintf(stderr, "nsvg__moveTo called with a non empty path !\n");
	}
	else
	{
        p->StartX = x;
        p->StartY = y;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xd028(%rax)
jle 0x7dc6d
movq 0x3a346(%rip), %rax     # 0xb7fa0
movq (%rax), %rdi
leaq 0x82ce(%rip), %rsi      # 0x85f32
movb $0x0, %al
callq 0x97c0
jmp 0x7dc8f
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0xd018(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0xd020(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__deletePathElts(NSVGPathElt*)
static void nsvg__deletePathElts(NSVGPathElt* Elt)
{
	while (Elt) {
		NSVGPathElt *next = Elt->next;
		free(Elt);
		Elt = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7e222
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9690
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7e1fc
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x38(%rbp)
movsd %xmm5, -0x40(%rbp)
movl $0x40, %edi
callq 0x9730
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x7e2cf
movq 0x39ce7(%rip), %rax     # 0xb7fa0
movq (%rax), %rdi
leaq 0x7c51(%rip), %rsi      # 0x85f14
movb $0x0, %al
callq 0x97c0
jmp 0x7e38c
movl -0xc(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, (%rax)
movq -0x48(%rbp), %rax
movq $0x0, 0x38(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x48(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x48(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x48(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x48(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movsd -0x38(%rbp), %xmm0
movq -0x48(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movsd -0x40(%rbp), %xmm0
movq -0x48(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd008(%rax)
jne 0x7e357
movq -0x48(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd008(%rax)
jmp 0x7e36a
movq -0x48(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0xd010(%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0xd028(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xd028(%rax)
movq -0x48(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd010(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__vecang(double, double, double, double)
static double nsvg__vecang(double ux, double uy, double vx, double vy)
{
	double r = nsvg__vecrat(ux,uy, vx,vy);
	if (r < -1.0) r = -1.0;
	if (r > 1.0) r = 1.0;
	return ((ux*vy < uy*vx) ? -1.0 : 1.0) * acos(r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm3
callq 0x7e600
movsd %xmm0, -0x28(%rbp)
movsd 0x5ca6(%rip), %xmm0     # 0x84108
ucomisd -0x28(%rbp), %xmm0
jbe 0x7e476
movsd 0x5c97(%rip), %xmm0     # 0x84108
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x5c75(%rip), %xmm1     # 0x840f8
ucomisd %xmm1, %xmm0
jbe 0x7e496
movsd 0x5c67(%rip), %xmm0     # 0x840f8
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
mulsd -0x18(%rbp), %xmm1
movsd 0x5c56(%rip), %xmm3     # 0x84108
movsd 0x5c3e(%rip), %xmm2     # 0x840f8
cmpltsd %xmm1, %xmm0
movaps %xmm0, %xmm1
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x94f0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm2
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x8(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x53fc(%rip), %xmm1     # 0x84290
ucomisd %xmm1, %xmm0
jbe 0x7eeb7
movsd 0x52f6(%rip), %xmm0     # 0x84198
ucomisd -0x20(%rbp), %xmm0
jbe 0x7eeb7
movq -0x10(%rbp), %rdi
callq 0x77000
jmp 0x7eff2
movsd 0x5239(%rip), %xmm0     # 0x840f8
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
mulsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x28(%rax), %xmm2
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x20(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
mulsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
mulsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm2
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x28(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
mulsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__findGradientData(NSVGparser*, char const*)
static NSVGgradientData* nsvg__findGradientData(NSVGparser* p, const char* id)
{
	NSVGgradientData* grad = p->gradients;
	while (grad) {
		if (strcmp(grad->id, id) == 0)
			return grad;
		grad = grad->next;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xd040(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7f9d3
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9770
cmpl $0x0, %eax
jne 0x7f9c2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7f9db
movq -0x20(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7f99f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__deleteGradientData(NSVGgradientData*)
static void nsvg__deleteGradientData(NSVGgradientData* grad)
{
	NSVGgradientData* next;
	while (grad != NULL) {
		next = grad->next;
		free(grad->stops);
		free(grad);
		grad = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7fa75
movq -0x8(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rdi
callq 0x9690
movq -0x8(%rbp), %rdi
callq 0x9690
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7fa3c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: Distance_bezier_segment(double, double, NSVGPathElt*)
static double Distance_bezier_segment(double x, double y, NSVGPathElt *Elt)
{
    //  Compute parameters of the line segment between Start and End
    double b = Elt->EndX - x;
    double a = y - Elt->EndY;
    double c = x * Elt->EndY - Elt->EndX*y;
    //  Compute distance between first control point and the line segment Start - End
    // Distance between point and line is (a * p.x + b * p.y + c)*(a * p.x + b * p.y + c)/(a*a + b*b)
    double d1 = a * Elt->BzCtrl1X + b * Elt->BzCtrl1Y + c;
    d1 *= d1;
    d1 /= a*a + b*b;
    //  Compute distance between second control point and the line segment Start - End
    // Distance between point and line is (a * p.x + b * p.y + c)*(a * p.x + b * p.y + c)/(a*a + b*b)
    double d2 = a * Elt->BzCtrl2X + b * Elt->BzCtrl2Y + c;
    d2 *= d2;
    d2 /= a*a + b*b;
    return(fmax(d1, d2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm2
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
mulsd -0x10(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm2
movsd -0x20(%rbp), %xmm1
movq -0x18(%rbp), %rax
mulsd 0x20(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movsd -0x20(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd 0x28(%rax), %xmm2
movsd -0x20(%rbp), %xmm1
movq -0x18(%rbp), %rax
mulsd 0x30(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movsd -0x20(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm3
movsd -0x40(%rbp), %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordsd %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
maxsd %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
popq %rbp
retq
// File: thierry7100[P]CutOptim/include/Geometry.h
// Function: Point::Transform(double, Point, Point)
inline void Transform(double angle, Point Centre, Point Translation)
	{
        double cos_a = cos(angle);
        double sin_a = sin(angle);
        double newx = (x - Centre.x)*cos_a - (y-Centre.y)*sin_a + Centre.x + Translation.x;
        double newy = (x - Centre.x)*sin_a + (y-Centre.y)*cos_a + Centre.y + Translation.y;
        newx = round(newx/my_Default_Precision)*my_Default_Precision;
        newy = round(newy/my_Default_Precision)*my_Default_Precision;
        x = newx;
        y = newy;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x8(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm4, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x99f0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x9120
movq -0x58(%rbp), %rax
movsd %xmm0, -0x40(%rbp)
movsd (%rax), %xmm0
subsd -0x10(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movsd 0x8(%rax), %xmm1
subsd -0x8(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x10(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd (%rax), %xmm0
subsd -0x10(%rbp), %xmm0
movsd -0x40(%rbp), %xmm2
movsd 0x8(%rax), %xmm1
subsd -0x8(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x8(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x48(%rbp), %xmm0
movsd 0x424d(%rip), %xmm1     # 0x840d8
divsd %xmm1, %xmm0
callq 0x9220
movsd 0x423c(%rip), %xmm1     # 0x840d8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x50(%rbp), %xmm0
movsd 0x4226(%rip), %xmm1     # 0x840d8
divsd %xmm1, %xmm0
callq 0x9220
movq -0x58(%rbp), %rax
movsd 0x4211(%rip), %xmm1     # 0x840d8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x5b18(%rip), %rsi      # 0x85fd3
callq 0x9530
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x9930
movq %rax, %rdi
leaq 0x5b08(%rip), %rsi      # 0x85fe1
callq 0x9530
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5b4c0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x80760
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x80552
movq -0x8(%rbp), %rdi
leaq 0x5acd(%rip), %rsi      # 0x85fee
callq 0x9530
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movslq -0x14(%rbp), %rsi
callq 0x5b4c0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x80760
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8050a
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x9670
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0xc8, %rdi
callq 0x10260
movl %eax, %ecx
movl -0x30(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
addq $0xc8, %rdi
callq 0x10290
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, 0xc8(%rax)
jne 0xfa4b
movb $0x1, %al
cmpl $0x1, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0xfa41
cmpl $0x3, -0x28(%rbp)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xfa79
movq -0x20(%rbp), %rax
cmpl $0x2, 0xc8(%rax)
je 0xfa65
movq -0x20(%rbp), %rax
cmpl $0x3, 0xc8(%rax)
jne 0xfa73
cmpl $0x1, -0x28(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xfa79
jmp 0xfa75
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: joao18araujo[P]pierluigi/src/first_species_counterpoint.cpp
// Function: FirstSpeciesCounterpoint::dfs_generate_counterpoint(Song&, bool, int, int)
Song FirstSpeciesCounterpoint::dfs_generate_counterpoint(Song & c_song, bool ascendant, int paralels, int same_movements){
  song = &c_song;
  Song counterpoint(c_song.scale, c_song.time);
  if(song->size() > 200 || paralels > 4 || same_movements > 600)
    return Song();

  FirstSpeciesCounterpoint::solve(0, paralels, same_movements, counterpoint, ascendant);
  return counterpoint;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d0(%rbp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
leaq 0x9c3830b(%rip), %rax   # 0x9c4b5e8
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x10110
movq -0x1c0(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rdx
leaq -0xf0(%rbp), %rdi
callq 0x165a0
jmp 0x13329
leaq -0x1a0(%rbp), %rdi
callq 0x101b0
leaq 0x9c382ac(%rip), %rax   # 0x9c4b5e8
movq (%rax), %rdi
callq 0x2dd20
movl %eax, -0x1d4(%rbp)
jmp 0x1334c
movl -0x1d4(%rbp), %eax
cmpl $0xc8, %eax
ja 0x13368
cmpl $0x4, -0x18(%rbp)
jg 0x13368
cmpl $0x258, -0x1c(%rbp)     # imm = 0x258
jle 0x133c2
movq -0x1d0(%rbp), %rdi
callq 0x16620
jmp 0x13376
movl $0x1, -0x1b8(%rbp)
jmp 0x13400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x101b0
jmp 0x1341c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x16720
jmp 0x1341c
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movzbl -0x11(%rbp), %r8d
andl $0x1, %r8d
xorl %edi, %edi
leaq -0xf0(%rbp), %rcx
callq 0x13430
jmp 0x133e1
movq -0x1d0(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x166a0
jmp 0x133f6
movl $0x1, -0x1b8(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x16720
movq -0x1c8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0x6820
nopl (%rax,%rax)
// File: joao18araujo[P]pierluigi/src/fourth_species_counterpoint.cpp
// Function: FourthSpeciesCounterpoint::dfs_generate_counterpoint(Song&, bool, int, int)
Song FourthSpeciesCounterpoint::dfs_generate_counterpoint(Song & c_song, bool ascendant, int paralels, int same_movements){
  song = &c_song;
  Song counterpoint(c_song.scale, c_song.time);
  if(song->size() > 200 || paralels > 4 || same_movements > 600)
    return Song();

  FourthSpeciesCounterpoint::solve(0, 0, paralels, same_movements, ascendant, counterpoint);
  FourthSpeciesCounterpoint::add_trailing_rests(counterpoint);
  return counterpoint;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d0(%rbp)
movb %dl, %al
movq %rdi, %rdx
movq %rdx, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
leaq 0x9c346ab(%rip), %rax   # 0x9c4b5e8
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x10110
movq -0x1c0(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rdx
leaq -0xf0(%rbp), %rdi
callq 0x165a0
jmp 0x16f89
leaq -0x1a0(%rbp), %rdi
callq 0x101b0
leaq 0x9c3464c(%rip), %rax   # 0x9c4b5e8
movq (%rax), %rdi
callq 0x2dd20
movl %eax, -0x1d4(%rbp)
jmp 0x16fac
movl -0x1d4(%rbp), %eax
cmpl $0xc8, %eax
ja 0x16fc8
cmpl $0x4, -0x18(%rbp)
jg 0x16fc8
cmpl $0x258, -0x1c(%rbp)     # imm = 0x258
jle 0x17028
movq -0x1d0(%rbp), %rdi
callq 0x16620
jmp 0x16fd6
movl $0x1, -0x1b8(%rbp)
jmp 0x17076
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x101b0
jmp 0x17092
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x16720
jmp 0x17092
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movzbl -0x11(%rbp), %r8d
andl $0x1, %r8d
xorl %esi, %esi
leaq -0xf0(%rbp), %r9
movl %esi, %edi
callq 0x170a0
jmp 0x17049
leaq -0xf0(%rbp), %rdi
callq 0xfa90
jmp 0x17057
movq -0x1d0(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x166a0
jmp 0x1706c
movl $0x1, -0x1b8(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x16720
movq -0x1c8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0x6820
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
movq %rdi, -0x50(%rbp)
callq 0x6650
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
movl 0x50(%rsi), %ecx
subl 0x50(%rdx), %ecx
movl %ecx, %edi
negl %edi
cmovnsl %edi, %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl 0x50(%rdx), %eax
subl 0x50(%rsi), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1bfa3
movl -0x1c(%rbp), %eax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cltd
idivl %ecx
movl %eax, -0x54(%rbp)
jmp 0x1bfaa
xorl %eax, %eax
movl %eax, -0x54(%rbp)
jmp 0x1bfaa
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movl -0x54(%rbp), %edx
movw %dx, 0x2c(%rdi)
movl 0x4c(%rax), %eax
movl 0x4c(%rcx), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, 0x28(%rdi)
callq 0x1c000
jmp 0x1bfd6
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x62d0
movq -0x28(%rbp), %rdi
callq 0x6820
nopw (%rax,%rax)
// File: joao18araujo[P]pierluigi/src/interval.cpp
// Function: Interval::classify_qualitative()
void Interval::classify_qualitative(){
  int note_diff = this->quantitative;
  int note_with_accidental_diff = this->half_tones;

  // printf("%d %d x ", note_diff, note_with_accidental_diff);
  while(note_diff > N_NOTES + 1)
    note_diff -= N_NOTES;

  while(note_with_accidental_diff > min(expected_semi_tones[note_diff] + 5, 16))
    note_with_accidental_diff -= N_SCALE;

  // printf("%d %d\n", note_diff, note_with_accidental_diff);
  this->qualitative = intervals[note_diff][note_with_accidental_diff];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %ecx
movl %ecx, -0xc(%rbp)
movl 0x28(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x8, -0xc(%rbp)
jle 0x1c030
movl -0xc(%rbp), %eax
subl $0x7, %eax
movl %eax, -0xc(%rbp)
jmp 0x1c01f
jmp 0x1c032
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x6645d(%rip), %rax     # 0x824a0
movl (%rax,%rcx,4), %eax
addl $0x5, %eax
movl %eax, -0x14(%rbp)
movl $0x10, -0x18(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1ccc0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl (%rcx), %eax
jle 0x1c075
movl -0x10(%rbp), %eax
subl $0xc, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c032
movq -0x20(%rbp), %rdi
movslq -0xc(%rbp), %rax
leaq 0x9c2f84c(%rip), %rsi   # 0x9c4b8d0
imulq $0x220, %rax, %rax      # imm = 0x220
addq %rax, %rsi
movslq -0x10(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
addq $0x8, %rdi
callq 0x6070
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0xc, -0xc(%rbp)
jle 0x1c237
movl -0xc(%rbp), %eax
subl $0xc, %eax
movl %eax, -0xc(%rbp)
jmp 0x1c226
leaq 0x9c2f652(%rip), %rdi   # 0x9c4b890
leaq -0xc(%rbp), %rsi
callq 0x1c970
movq %rax, -0x18(%rbp)
leaq 0x9c2f63e(%rip), %rdi   # 0x9c4b890
callq 0x1c9a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1c940
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq