LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__xformPremultiply(double*, double*)
static void nsvg__xformPremultiply(double* t, double* s)
{
	double s2[6];
	memcpy(s2, s, sizeof(double)*6);
	nsvg__xformMultiply(s2, t);
	memcpy(t, s2, sizeof(double)*6);
}

// Assembly:
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm9
movsd 0x10(%rsi), %xmm1
movsd 0x18(%rsi), %xmm6
movsd 0x20(%rsi), %xmm2
movsd 0x28(%rsi), %xmm4
movsd 0x10(%rdi), %xmm10
movapd %xmm9, %xmm8
mulsd %xmm10, %xmm8
movsd (%rdi), %xmm3
movsd 0x8(%rdi), %xmm7
movapd %xmm0, %xmm5
mulsd %xmm3, %xmm5
addsd %xmm8, %xmm5
movapd %xmm6, %xmm11
mulsd %xmm10, %xmm11
movapd %xmm1, %xmm8
mulsd %xmm3, %xmm8
addsd %xmm11, %xmm8
mulsd %xmm4, %xmm10
mulsd %xmm2, %xmm3
addsd %xmm10, %xmm3
addsd 0x20(%rdi), %xmm3
movsd 0x18(%rdi), %xmm10
mulsd %xmm10, %xmm9
mulsd %xmm7, %xmm0
addsd %xmm9, %xmm0
mulsd %xmm10, %xmm6
mulsd %xmm7, %xmm1
addsd %xmm6, %xmm1
mulsd %xmm10, %xmm4
mulsd %xmm7, %xmm2
addsd %xmm4, %xmm2
addsd 0x28(%rdi), %xmm2
movsd %xmm5, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm8, 0x10(%rdi)
movsd %xmm1, 0x18(%rdi)
movsd %xmm3, 0x20(%rdi)
movsd %xmm2, 0x28(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__parseColorRGB(char const*)
static unsigned int nsvg__parseColorRGB(const char* str)
{
	int r = -1, g = -1, b = -1;
	char s1[32]="", s2[32]="";
	sscanf(str + 4, "%d%[%%, \t]%d%[%%, \t]%d", &r, s1, &g, s2, &b);
	if (strchr(s1, '%')) {
		return NSVG_RGB((r*255)/100,(g*255)/100,(b*255)/100);
	} else {
		return NSVG_RGB(r,g,b);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq 0x1c(%rsp), %rbx
movl %eax, (%rbx)
leaq 0x18(%rsp), %r8
movl %eax, (%r8)
leaq 0x14(%rsp), %rcx
movl %eax, (%rcx)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
leaq 0x20(%rsp), %r9
movaps %xmm0, 0x10(%r9)
movaps %xmm0, (%r9)
addq $0x4, %rdi
movq %rcx, (%rsp)
leaq 0x6306(%rip), %rsi      # 0x40df7
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x7400
movq %r14, %rdi
movl $0x25, %esi
callq 0x7180
movl (%rbx), %edx
testq %rax, %rax
je 0x3ab5a
movl %edx, %eax
shll $0x8, %eax
subl %edx, %eax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
shrq $0x25, %rax
movl 0x18(%rsp), %ecx
movl %ecx, %edx
shll $0x8, %edx
subl %ecx, %edx
imulq $0x51eb851f, %rdx, %rcx # imm = 0x51EB851F
shrq $0x20, %rcx
andl $-0x20, %ecx
shll $0x3, %ecx
orl %eax, %ecx
movl 0x14(%rsp), %eax
movl %eax, %edx
shll $0x8, %edx
subl %eax, %edx
imulq $0x51eb851f, %rdx, %rax # imm = 0x51EB851F
shrq $0x25, %rax
jmp 0x3ab67
movl 0x18(%rsp), %ecx
shll $0x8, %ecx
orl %edx, %ecx
movl 0x14(%rsp), %eax
shll $0x10, %eax
orl %ecx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ad86
movslq 0xd000(%rdi), %rax
imulq $0x1a0, %rax, %rax      # imm = 0x1A0
addq %rdi, %rax
leaq 0x45fb(%rip), %rcx      # 0x3f328
movslq (%rcx,%rsi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
divsd 0x44e2(%rip), %xmm0     # 0x3f220
jmp 0x3ad5c
divsd 0x44d0(%rip), %xmm0     # 0x3f218
jmp 0x3ad5c
divsd 0x439e(%rip), %xmm0     # 0x3f0f0
jmp 0x3ad5c
divsd 0x445c(%rip), %xmm0     # 0x3f1b8
mulsd 0xd080(%rdi), %xmm0
retq
mulsd 0x178(%rax), %xmm0
mulsd 0x44b3(%rip), %xmm0     # 0x3f228
retq
divsd 0x4442(%rip), %xmm0     # 0x3f1c0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
retq
mulsd 0x178(%rax), %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/thierry7100[P]CutOptim/include/nanosvg.h
// Function: nsvg__xformMultiply(double*, double*)
static void nsvg__xformMultiply(double* t, double* s)
{
	double t0 = t[0] * s[0] + t[1] * s[2];
	double t2 = t[2] * s[0] + t[3] * s[2];
	double t4 = t[4] * s[0] + t[5] * s[2] + s[4];
	t[1] = t[0] * s[1] + t[1] * s[3];
	t[3] = t[2] * s[1] + t[3] * s[3];
	t[5] = t[4] * s[1] + t[5] * s[3] + s[5];
	t[0] = t0;
	t[2] = t2;
	t[4] = t4;
}

// Assembly:
movsd (%rdi), %xmm4
movsd 0x8(%rdi), %xmm6
movsd (%rsi), %xmm0
movsd 0x10(%rsi), %xmm8
movapd %xmm6, %xmm2
mulsd %xmm8, %xmm2
movapd %xmm4, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd 0x10(%rdi), %xmm7
movapd %xmm8, %xmm3
movapd %xmm7, %xmm2
mulsd %xmm0, %xmm2
movsd 0x20(%rdi), %xmm5
movsd 0x28(%rdi), %xmm9
mulsd %xmm9, %xmm8
mulsd %xmm5, %xmm0
addsd %xmm8, %xmm0
movsd 0x18(%rdi), %xmm8
mulsd %xmm8, %xmm3
addsd 0x20(%rsi), %xmm0
mulsd 0x18(%rsi), %xmm6
mulsd 0x8(%rsi), %xmm4
addsd %xmm6, %xmm4
movsd %xmm4, 0x8(%rdi)
mulsd 0x18(%rsi), %xmm8
mulsd 0x8(%rsi), %xmm7
addsd %xmm8, %xmm7
movsd %xmm7, 0x18(%rdi)
mulsd 0x18(%rsi), %xmm9
mulsd 0x8(%rsi), %xmm5
addsd %xmm3, %xmm2
addsd %xmm9, %xmm5
addsd 0x28(%rsi), %xmm5
movsd %xmm5, 0x28(%rdi)
movsd %xmm1, (%rdi)
movsd %xmm2, 0x10(%rdi)
movsd %xmm0, 0x20(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ae95
cmpl $0x28, %eax
je 0x3ae7e
incq %rbx
jmp 0x3ae6b
leaq (%r12,%rbx), %r13
movzbl (%r12,%rbx), %eax
testl %eax, %eax
je 0x3ae95
cmpl $0x29, %eax
je 0x3aeab
incq %rbx
jmp 0x3ae82
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 0x3ae9a
leaq 0x10(%rsp), %r15
movzbl (%r13), %eax
cmpq $0x2e, %rax
ja 0x3af08
movabsq $0x680000000000, %rcx   # imm = 0x680000000000
btq %rax, %rcx
jae 0x3af08
cmpl %ebp, (%r14)
jge 0x3af13
movq %r13, %rdi
movq %r15, %rsi
callq 0x3af17
movq %rax, %r13
movq %r15, %rdi
callq 0x3ab74
movslq (%r14), %rax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rcx,%rax,8)
cmpq %r12, %r13
jb 0x3aeb8
jmp 0x3ae9a
addb $-0x3a, %al
cmpb $-0xa, %al
jae 0x3aed3
incq %r13
jmp 0x3af01
xorl %ebx, %ebx
jmp 0x3ae9a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3af29
xorl %ecx, %ecx
cmpl $0x2b, %edx
jne 0x3af33
movb %dl, (%rsi)
incq %rax
movl $0x1, %ecx
movb (%rax), %dl
testb %dl, %dl
je 0x3af92
incq %rax
leal -0x3a(%rdx), %edi
cmpb $-0xa, %dil
jb 0x3af5d
cmpl $0x3e, %ecx
jg 0x3af52
movslq %ecx, %rdi
incl %ecx
movb %dl, (%rsi,%rdi)
movb (%rax), %dl
incq %rax
testb %dl, %dl
jne 0x3af3c
jmp 0x3af8f
cmpb $0x2e, %dl
jne 0x3af8f
cmpl $0x3e, %ecx
jg 0x3af6f
movslq %ecx, %rdi
incl %ecx
movb %dl, (%rsi,%rdi)
movb (%rax), %dl
leal -0x3a(%rdx), %edi
cmpb $-0xa, %dil
jb 0x3af92
cmpl $0x3e, %ecx
jg 0x3af87
movslq %ecx, %rdi
incl %ecx
movb %dl, (%rsi,%rdi)
movb 0x1(%rax), %dl
incq %rax
jmp 0x3af71
decq %rax
movzbl (%rax), %edx
movl %edx, %edi
orl $0x20, %edi
cmpl $0x65, %edi
jne 0x3aff7
cmpl $0x3e, %ecx
jg 0x3afac
movslq %ecx, %rdi
incl %ecx
movb %dl, (%rsi,%rdi)
movzbl 0x1(%rax), %edx
cmpl $0x2d, %edx
je 0x3afba
cmpl $0x2b, %edx
jne 0x3afcd
cmpl $0x3e, %ecx
jg 0x3afc7
movslq %ecx, %rdi
incl %ecx
movb %dl, (%rsi,%rdi)
addq $0x2, %rax
jmp 0x3afd0
incq %rax
movb (%rax), %dl
leal -0x3a(%rdx), %edi
cmpb $-0xa, %dil
jb 0x3aff7
cmpl $0x3e, %ecx
jg 0x3afe8
movslq %ecx, %rdi
incl %ecx
movb %dl, (%rsi,%rdi)
movb 0x1(%rax), %dl
incq %rax
leal -0x3a(%rdx), %edi
cmpb $-0xb, %dil
ja 0x3afdb
movslq %ecx, %rcx
movb $0x0, (%rsi,%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3b04e
movq %rsi, %r14
incq %rbx
leaq 0x5bb5(%rip), %r15      # 0x40bd7
movsbl %r12b, %ebp
movl $0x7, %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x74a0
cmpb $0x2c, %bpl
je 0x3b040
testq %rax, %rax
je 0x3b05a
movb (%rbx), %r12b
incq %rbx
testb %r12b, %r12b
jne 0x3b022
decq %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1(%rbx), %rdi
movzbl %r12b, %eax
leal -0x2d(%rax), %ecx
cmpl $0x2, %ecx
jb 0x3b08b
cmpl $0x2b, %eax
je 0x3b08b
testl %eax, %eax
jne 0x3b078
movq %rdi, %rbx
jmp 0x3b04e
leal -0x3a(%r12), %eax
cmpb $-0xa, %al
jae 0x3b08b
movb %r12b, (%r14)
movb $0x0, 0x1(%r14)
jmp 0x3b04e
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3af17
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7580
testq %rax, %rax
je 0x3ba1d
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 0x3b9ff
movq 0xd010(%rbx), %rcx
addq $0x38, %rcx
jmp 0x3ba06
leaq 0xd008(%rbx), %rcx
movq %rax, (%rcx)
incl 0xd028(%rbx)
movq %rax, 0xd010(%rbx)
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
callq 0x7adb
jmp 0x3ba16
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3222(%rip), %xmm0     # 0x3f030
andpd %xmm2, %xmm0
movsd 0x3356(%rip), %xmm3     # 0x3f170
ucomisd %xmm0, %xmm3
jbe 0x3be43
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 0x11bd(%rip), %xmm0     # 0x3d008
divsd %xmm2, %xmm0
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
movsd 0x10(%rsi), %xmm1
movapd 0x321c(%rip), %xmm2     # 0x3f080
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_O1/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 0x46bf(%rip), %rsi      # 0x40f35
movl $0xd, %edx
callq 0x74d0
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x7710
leaq 0x46b0(%rip), %rsi      # 0x40f43
movl $0xc, %edx
movq %rax, %rdi
callq 0x74d0
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x3c96c
cmpl $0x2, 0x8(%r14)
jl 0x3c8f5
movl $0x1, %r12d
movl $0x10, %r13d
leaq 0x468a(%rip), %r15      # 0x40f50
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x74d0
movq 0x10(%r14), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x3c96c
incq %r12
movslq 0x8(%r14), %rax
addq $0x10, %r13
cmpq %rax, %r12
jl 0x3c8c6
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x74d0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb059
testl %eax, %eax
jmp 0xb066
movb $0x1, %cl
cmpl $0x4, %r8d
jne 0xb069
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
sete %cl
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15294
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
cmpq %r15, %rdi
je 0x1528b
movq (%r15), %rsi
incq %rsi
callq 0x5360
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl (%rdi), %ecx
movl 0x28(%rdi), %eax
cmpl $0x8, %ecx
movl $0x8, %edx
cmovll %ecx, %edx
movl %ecx, %esi
subl %edx, %esi
addl $0x6, %esi
imulq $0x24924925, %rsi, %rdx # imm = 0x24924925
shrq $0x20, %rdx
subl %edx, %esi
shrl %esi
addl %edx, %esi
shrl $0x2, %esi
leal (,%rsi,8), %edx
subl %edx, %esi
addl %ecx, %esi
movslq %esi, %rcx
leaq 0x3408c(%rip), %rdx     # 0x49360
movl (%rdx,%rcx,4), %edx
cmpl $0xb, %edx
movl $0xb, %esi
cmovll %edx, %esi
addl $0x5, %esi
cmpl %esi, %eax
cmovll %eax, %esi
movl %eax, %edx
subl %esi, %edx
addl $0xb, %edx
movl $0xaaaaaaab, %esi       # imm = 0xAAAAAAAB
imulq %rdx, %rsi
shrq $0x23, %rsi
shll $0x2, %esi
leal (%rsi,%rsi,2), %esi
movl %edx, %r8d
subl %esi, %r8d
subl %edx, %r8d
addl %eax, %r8d
movslq %r8d, %rax
shlq $0x5, %rax
imulq $0x220, %rcx, %rcx      # imm = 0x220
leaq 0x9bfd46b(%rip), %rsi   # 0x9c12790
addq %rcx, %rsi
addq %rax, %rsi
addq $0x8, %rdi
jmp 0x51e0
// File: /workspace/github_cpp_makefile_star2_O1/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:
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
movslq %edi, %rax
movq 0x9bfd1b8(%rip), %r8    # 0x9c12758
xorl %r10d, %r10d
xorl %edx, %edx
divq %r8
movq 0x9bfd1a1(%rip), %rax   # 0x9c12750
movq (%rax,%rdx,8), %rax
testq %rax, %rax
je 0x155f5
movq (%rax), %r9
movq %rax, %r10
cmpl 0x8(%r9), %edi
je 0x155f5
movq %rdx, %rcx
movq %r9, %r11
movq (%r9), %r9
testq %r9, %r9
je 0x155f2
movslq 0x8(%r9), %rsi
movq %rsi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %r10d
cmpq %rcx, %rdx
jne 0x155f5
movq %r11, %r10
cmpl %esi, %edi
jne 0x155c7
jmp 0x155f5
xorl %r10d, %r10d
testq %r10, %r10
je 0x15602
cmpq $0x0, (%r10)
setne %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c186
testb %al, %al
je 0x15a75
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a9c6
jmp 0x15b44
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 0x1abd4
cmpl %ebp, 0x50(%r15)
jne 0x15aba
movl (%r14), %eax
leaq 0x20(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x1a9c6
jmp 0x15b0e
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1bdb6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
cmpq %rax, %rsi
je 0x15ae3
cmpl %ebp, 0x50(%rsi)
je 0x15af7
addq $0x58, %rsi
jmp 0x15ad3
leaq 0x8(%rsp), %rdi
callq 0xb1d6
movq %rbx, %rdi
callq 0x1aa88
jmp 0x15b0e
movl (%r14), %eax
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x1a9c6
leaq 0x8(%rsp), %rdi
callq 0xb1d6
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15b29
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x5360
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15b44
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 0xb1d6
jmp 0x15b66
jmp 0x15b63
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb116
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21355(%rip), %rsi     # 0x3bbf5
movq %r13, %rdi
callq 0x5100
testl %eax, %eax
je 0x1a924
movl %r12d, 0x48(%r15)
leaq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1c1a3
leaq 0x9bf91fd(%rip), %rdi   # 0x9c13ac8
leaq 0x28(%rsp), %rsi
callq 0x1c7a6
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 0x1a901
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5360
leaq 0x9bf91f8(%rip), %rdi   # 0x9c13b00
movq 0x8(%rsp), %rsi
callq 0x1c8ce
incl %r12d
leal (,%r12,8), %ecx
subl %r12d, %ecx
addl (%rax), %ecx
jmp 0x1a92e
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 0x1a966
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5360
jmp 0x1a966
jmp 0x1a963
movq %rax, %r15
movq 0x10(%rsp), %rax
movq (%rax), %rdi
cmpq 0x18(%rsp), %rdi
je 0x1a985
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5360
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq 0x20(%rsp), %rdi
je 0x1a9a4
movq 0x20(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5360
movq %r15, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl 0x48(%r12), %eax
movl %eax, 0x48(%r15)
movl 0x4c(%r12), %eax
movl %eax, 0x4c(%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 0x1aa74
movq (%rbp), %rsi
incq %rsi
callq 0x5360
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58f1
movq %r15, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20a42(%rip), %rcx     # 0x3b513
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5510
movq 0x30(%r15), %rdx
leaq 0x20c0c(%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 0x1c1a3
leaq 0x9bf8fae(%rip), %rdi   # 0x9c13ac8
leaq 0x8(%rsp), %rsi
callq 0x1c7a6
movl (%rax), %eax
addl $0x30, %eax
movl %eax, 0x4c(%r15)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ab48
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5360
movl 0x48(%r15), %ebp
leaq 0x9bf8fad(%rip), %rdi   # 0x9c13b00
movq %rbx, %rsi
callq 0x1c8ce
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 0x1aba3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5360
jmp 0x1aba3
jmp 0x1aba0
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x1abb7
movq (%r13), %rsi
incq %rsi
callq 0x5360
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1abcb
movq (%r12), %rsi
incq %rsi
callq 0x5360
movq %r15, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/joao18araujo[P]pierluigi/src/note.cpp
// Function: Note::Note(int, int)
Note::Note(int midi_number, int duration){
  this->valid = true;
  this->duration = duration;
  this->midi_number = midi_number;
  this->octave = (midi_number / N_SCALE) - 1;
  string note_with_accidental = number_to_notes_with_accidental[midi_number % N_SCALE];
  this->set_full_note(note_with_accidental);
  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 $0x48, %rsp
movq %rdi, %r14
movl $0x0, 0x4(%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movw $0x1, 0x54(%rdi)
movl %edx, (%rdi)
movl %esi, 0x4c(%rdi)
movslq %esi, %rax
imulq $0x2aaaaaab, %rax, %rcx # imm = 0x2AAAAAAB
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
leal (%rcx,%rdx), %esi
decl %esi
movl %esi, 0x48(%rdi)
addl %edx, %ecx
shll $0x2, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
cltq
shlq $0x5, %rax
leaq 0x9bf9031(%rip), %rcx   # 0x9c13c80
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xb544
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xb544
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x1ad72
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1acb2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5360
movl 0x48(%r14), %r15d
leaq 0x9bf8e43(%rip), %rdi   # 0x9c13b00
movq %rbx, %rsi
callq 0x1c8ce
leal (,%r15,8), %ecx
subl %r15d, %ecx
movl (%rax), %eax
addl %ecx, %eax
addl $0x7, %eax
movl %eax, 0x50(%r14)
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1acf2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5360
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1ad28
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5360
jmp 0x1ad28
movq %rax, (%rsp)
jmp 0x1ad3f
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1ad3f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5360
movq 0x28(%r14), %rdi
cmpq %r13, %rdi
je 0x1ad54
movq (%r13), %rsi
incq %rsi
callq 0x5360
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1ad68
movq (%r12), %rsi
incq %rsi
callq 0x5360
movq (%rsp), %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20965(%rip), %rdx     # 0x3b6fa
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xb62c
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 0x1c1a3
leaq 0x9bf8ccf(%rip), %rdi   # 0x9c13ac8
leaq 0x20(%rsp), %rsi
callq 0x1c7a6
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 0x1ae2e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5360
movl 0x48(%rbx), %r15d
leaq 0x9bf8cc7(%rip), %rdi   # 0x9c13b00
movq %r14, %rsi
callq 0x1c8ce
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 0x1ae6c
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 0x1aea1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5360
jmp 0x1aea1
jmp 0x1ae9e
jmp 0x1ae9e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1aeb7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5360
movq %rbx, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24334
addq $-0x58, %rsi
movq %rbx, %rdi
callq 0x1a9c6
jmp 0x2433c
movq %rbx, %rdi
callq 0x1aa88
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/joao18araujo[P]pierluigi/src/song_reader.cpp
// Function: SongReader::string_to_compass_time(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
CompassTime SongReader::string_to_compass_time(string line){
  if(!regex_match(line, regex("\\\\time \\d+\\/\\d+")))
    return CompassTime();

  int times, base_note;
  sscanf(line.c_str(), "\\time %d/%d\n", &times, &base_note);
  return CompassTime(times, base_note);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x1653f(%rip), %rsi     # 0x3b6af
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x26334
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x316c1
movl %eax, %ebp
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x251bc
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5360
leaq 0x20(%rsp), %rdi
callq 0x2639c
testb %bpl, %bpl
je 0x251f8
movq (%rbx), %rdi
leaq 0x164ea(%rip), %rsi     # 0x3b6bf
movq %rsp, %rbx
leaq 0x20(%rsp), %r14
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x5330
movl (%rbx), %ecx
movl (%r14), %eax
shlq $0x20, %rax
orq %rcx, %rax
jmp 0x25202
movabsq $0x400000004, %rax      # imm = 0x400000004
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x25224
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5360
leaq 0x20(%rsp), %rdi
callq 0x2639c
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonfonts/src/fonts.c
// Function: IsAvailable
static int IsAvailable(lua_State *L)
    {
    const char *name = luaL_checkstring(L, 1);
    font_t *font = font_search(L, name);
    lua_pushboolean(L, font !=NULL);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x10e0
movq %rax, %rdi
callq 0xed64
xorl %esi, %esi
testq %rax, %rax
setne %sil
movq %rbx, %rdi
callq 0x1140
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonfonts/src/fonts.c
// Function: List
static int List(lua_State *L)
    {
    int i, byname;
    rec_t *rec;

    byname = optboolean(L, 1, 0);

    lua_newtable(L);

    if(byname)
        {
        rec = first(" ");
        while(rec)
            {
            lua_pushboolean(L, 1);
            lua_setfield(L, -2, (const char*)rec->name);
            rec = next(rec);
            }
        }
    else
        {
        i = 1;
        rec = first(" ");
        while(rec)
            {
            lua_pushstring(L, (const char*)rec->name);
            lua_seti(L, -2, i++);
            rec = next(rec);
            }
        }

    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x11e0
movl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1090
callq 0x16c5
movq %rax, %r14
testl %ebp, %ebp
je 0xee38
testq %r14, %r14
je 0xee76
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1140
movq 0x20(%r14), %rdx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10a0
movq %r14, %rdi
callq 0xf364
movq %rax, %r14
testq %rax, %rax
jne 0xee08
jmp 0xee76
testq %r14, %r14
je 0xee76
movl $0x1, %r15d
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x11d0
leaq 0x1(%r15), %r12
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x10f0
movq %r14, %rdi
callq 0xf364
movq %rax, %r14
movq %r12, %r15
testq %rax, %rax
jne 0xee43
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonfonts/src/utils.c
// Function: moonfonts_Malloc
void *Malloc(lua_State *L, size_t size)
    {
    void *ptr = Malloc_(size);
    if(ptr==NULL)
        { luaL_error(L, errstring(ERR_MEMORY)); return NULL; }
    memset(ptr, 0, size);
    //DBG("Malloc %p\n", ptr);
    return ptr;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x185124f(%rip), %rax   # 0x1964118
testq %rax, %rax
je 0x112ee0
movq 0x185124b(%rip), %rdi   # 0x1964120
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq *%rax
jmp 0x112ee2
xorl %eax, %eax
testq %rax, %rax
je 0x112efb
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10b0
leaq 0x183a74c(%rip), %rsi   # 0x194d64e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1170
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonfonts/src/utils.c
// Function: moonfonts_Strdup
char *Strdup(lua_State *L, const char *s)
    {
    size_t len = strnlen(s, 256);
    char *ptr = (char*)Malloc(L, len + 1);
    if(len>0)
        memcpy(ptr, s, len);
    ptr[len]='\0';
    return ptr;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
callq 0x10d0
movq %rax, %r14
leaq 0x1(%rax), %rsi
movq %r15, %rdi
callq 0x1070
movq %rax, %r15
testq %r14, %r14
je 0x112faf
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1120
movb $0x0, (%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/stetre[P]moonfonts/src/utils.c
// Function: moonfonts_testboolean
int testboolean(lua_State *L, int arg, int *err)
    {
    if(!lua_isboolean(L, arg))
        { *err = ERR_TYPE; return 0; }
    *err = 0;
    return lua_toboolean(L, arg);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x11c0
cmpl $0x1, %eax
jne 0x113042
movl $0x0, (%rbx)
movq %r14, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x1030
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::empty() const
bool HierarchicalBlockSparseMatrix<Treal>::empty() const {
			if(nRows == 0 && nCols == 0 && submatrix.empty() && !children_exist())
			  return true;
			else
			  return false;
		}

// Assembly:
movl 0x4(%rdi), %eax
orl (%rdi), %eax
jne 0x4349
movq 0x70(%rdi), %rax
cmpq 0x78(%rdi), %rax
je 0x434c
xorl %eax, %eax
retq
cmpq $0x0, 0x28(%rdi)
jne 0x4349
cmpq $0x0, 0x38(%rdi)
jne 0x4349
cmpq $0x0, 0x48(%rdi)
jne 0x4349
movb $0x1, %al
cmpq $0x0, 0x58(%rdi)
je 0x434b
jmp 0x4349
// File: /workspace/github_cpp_makefile_star2_O1/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::resize(int, int, unsigned long*)
void HierarchicalBlockSparseMatrix<Treal>::resize(int nRows_, int nCols_, size_t* no_of_resizes) {
		assert(blocksize > 0);

		if(!empty()) clear();

		nRows_orig = nRows_; // only top level contains true size, rest have duplicates of nRows and nCols
		nCols_orig = nCols_;

		// lowest level
		if(nRows_ <= blocksize && nCols_ <= blocksize){
			nRows = blocksize;
			nCols = blocksize;
			submatrix.resize(blocksize*blocksize);
			if(no_of_resizes != NULL) (*no_of_resizes)++;
			return;
		}

		// actually, matrix is always kept square, with padding with zeros where necessary
		// the "virtual dimension" can be computed as blocksize * 2^P,
		// where P is such that blocksize * 2^(P-1) <= max(nRows_, nCols_) <= blocksize * 2^P

		int maxdim = ((nRows_ > nCols_) ? nRows_ : nCols_);

		//how many times block covers maxdim
		int n_covers = maxdim / blocksize;
		if(maxdim % blocksize != 0) n_covers += 1;

		// now we need to find P such that 2^(P-1) <= n_covers <= 2^P
		int P = 1;
		int two_to_power_P = 2;
		while(n_covers >  two_to_power_P){
			two_to_power_P *= 2;
			P += 1;
		}

		int virtual_size = blocksize * two_to_power_P;


		nRows = virtual_size;
		nCols = virtual_size;

	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x10(%rdi)
jle 0x4403
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
callq 0x4338
testb %al, %al
jne 0x4399
movq %rbx, %rdi
callq 0x4422
movl %r15d, 0x8(%rbx)
movl %ebp, 0xc(%rbx)
movl 0x10(%rbx), %esi
cmpl %r15d, %esi
setl %al
cmpl %ebp, %esi
setl %cl
orb %al, %cl
je 0x43dc
cmpl %ebp, %r15d
cmovgl %r15d, %ebp
movl %ebp, %eax
cltd
idivl %esi
cmpl $0x1, %edx
sbbl $-0x1, %eax
movl $0x2, %edx
movl %edx, %ecx
leal (%rcx,%rcx), %edx
cmpl %ecx, %eax
jg 0x43c9
imull %esi, %ecx
movl %ecx, (%rbx)
movl %ecx, 0x4(%rbx)
jmp 0x43f8
movl %esi, (%rbx)
movl %esi, 0x4(%rbx)
addq $0x70, %rbx
imull %esi, %esi
movq %rbx, %rdi
callq 0x699c
testq %r14, %r14
je 0x43f8
incq (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x615d(%rip), %rdi      # 0xa567
leaq 0x6164(%rip), %rsi      # 0xa575
leaq 0x61d4(%rip), %rcx      # 0xa5ec
movl $0x221, %edx            # imm = 0x221
callq 0x20a0
// File: /workspace/github_cpp_makefile_star2_O1/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::clear()
void HierarchicalBlockSparseMatrix<Treal>::clear() {

			if(empty()){
				return;
			}

			if(lowest_level()){
				submatrix.clear();
				nRows = 0;
				nCols = 0;
				if(children_exist()){
					throw std::runtime_error("Error in HierarchicalBlockSparseMatrix<Treal>::clear: children exist on leaf level.");
				}
				return;
			}

			for(int i = 0; i < 4; ++i){
				if(children[i] != NULL){
					children[i]->clear(); // smart pointer, no need to call delete explicitly!
					children[i] = NULL;
				}
			}
			nRows = 0;
			nCols = 0;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4338
testb %al, %al
jne 0x44e2
movq %rbx, %rdi
callq 0x6b36
testb %al, %al
je 0x44a5
movq 0x70(%rbx), %rax
cmpq %rax, 0x78(%rbx)
je 0x4450
movq %rax, 0x78(%rbx)
movq $0x0, (%rbx)
cmpq $0x0, 0x28(%rbx)
jne 0x4473
cmpq $0x0, 0x38(%rbx)
jne 0x4473
cmpq $0x0, 0x48(%rbx)
jne 0x4473
cmpq $0x0, 0x58(%rbx)
je 0x44e2
movl $0x10, %edi
callq 0x2070
movq %rax, %rbx
leaq 0x61dd(%rip), %rsi      # 0xa664
movq %rax, %rdi
callq 0x2060
movq 0x9b5a(%rip), %rsi      # 0xdff0
movq 0x9b23(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x21a0
movl $0x30, %r14d
movq -0x8(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x44d1
callq 0x4422
movq (%rbx,%r14), %rdi
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%rbx,%r14)
testq %rdi, %rdi
je 0x44d1
callq 0x6b64
addq $0x10, %r14
cmpq $0x70, %r14
jne 0x44ab
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_frob_squared() const
Treal HierarchicalBlockSparseMatrix<Treal>::get_frob_squared() const  {

			if(empty())
				throw std::runtime_error("Error in HierarchicalBlockSparseMatrix<Treal>::get_frob_squared: empty matrix occured.");

		    if(lowest_level()){

				Treal frob_squared = 0.0;
				for(int i = 0; i < submatrix.size(); ++i){
					frob_squared += submatrix[i] * submatrix[i];
				}
				return frob_squared;
			}
			else{

				Treal frob_squared = 0.0;

				for(int i = 0; i < 4; ++i){
					if(children[i] != NULL) frob_squared += children[i]->get_frob_squared();
				}

				return frob_squared;
			}

		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4338
testb %al, %al
jne 0x4594
movq %rbx, %rdi
callq 0x6b36
testb %al, %al
je 0x4554
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rcx
subq %rax, %rcx
je 0x4584
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorpd %xmm1, %xmm1
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
incq %rdx
cmpq %rdx, %rcx
jne 0x453d
jmp 0x4588
xorpd %xmm1, %xmm1
xorl %r14d, %r14d
movq 0x28(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x4578
movsd %xmm1, (%rsp)
callq 0x44fe
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
addq $0x10, %r14
cmpq $0x40, %r14
jne 0x455b
jmp 0x4588
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2070
movq %rax, %rbx
leaq 0x6110(%rip), %rsi      # 0xa6b8
movq %rax, %rdi
callq 0x2060
movq 0x9a39(%rip), %rsi      # 0xdff0
movq 0x9a02(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x21a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_nnz() const
size_t HierarchicalBlockSparseMatrix<Treal>::get_nnz() const  {
			if(empty())
				throw std::runtime_error("Error in HierarchicalBlockSparseMatrix<Treal>::get_nnz: empty matrix occured.");

		    if(lowest_level()){

                //this seems to be more logical!
				int nnz = 0;
				for(int i = 0; i < submatrix.size(); ++i){
					if(fabs(submatrix[i]) > 0.0) nnz += 1;
				}
				return nnz;
			}
			else{

				int nnz = 0.0;

				for(int i = 0; i < 4; ++i){
					if(children[i] != NULL) nnz += children[i]->get_nnz();
				}

				return nnz;
			}

		}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4338
testb %al, %al
jne 0x465a
movq %rbx, %rdi
callq 0x6b36
testb %al, %al
je 0x462e
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rcx
subq %rax, %rcx
je 0x4650
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
xorl %esi, %esi
ucomisd (%rax,%rdx,8), %xmm0
setne %sil
addl %esi, %ebp
incq %rdx
cmpq %rdx, %rcx
jne 0x4617
jmp 0x4652
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x28(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x4644
callq 0x45da
addl %eax, %ebp
addq $0x10, %r14
cmpq $0x40, %r14
jne 0x4633
jmp 0x4652
xorl %ebp, %ebp
movslq %ebp, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x2070
movq %rax, %rbx
leaq 0x6427(%rip), %rsi      # 0xaa95
movq %rax, %rdi
callq 0x2060
movq 0x9973(%rip), %rsi      # 0xdff0
movq 0x993c(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x21a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21c0
nop