LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: krig[P]easing/test_easing.cpp
// Function: void plotline<main::$_0>(main::$_0, char, char, float, int, int, float, std::vector<float, std::allocator<float>> const&, std::vector<char, std::allocator<char>>&)
void plotline(Fn fn, char head, char filler, float y, int from, int to, float step,
              vector<float> const& values, vector<char>& line) {
	line.clear();
	line.push_back(head);
	bool hit = false;
	for (int x = from; x < to; ++x) {
		if (fabs(values[x] - y) <= step) {
			hit = true;
			line.push_back('*');
		} else {
			line.push_back(filler);
		}
	}
	if (!hit) {
		int minx = from;
		for (int x = from + 1; x < to; ++x) {
			if (fabs(values[x] - y) < fabs(values[minx] - y))
				minx = x;
		}
		if (fabs(values[minx] - y) < step * 1.25)
			line[minx + 1] = '*';
	}
	line.push_back(0);
	cout << line.data() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movb %dil, %sil
movb %sil, -0x2(%rbp)
movb %al, -0x3(%rbp)
movss %xmm0, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movss %xmm1, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe310
movq -0x28(%rbp), %rdi
leaq -0x2(%rbp), %rsi
callq 0xe330
movb $0x0, -0x29(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x9c4e
movq -0x20(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0xe3c0
movss (%rax), %xmm0
subss -0x8(%rbp), %xmm0
callq 0xe3a0
movaps %xmm0, %xmm1
movss -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jb 0x9c34
movb $0x1, -0x29(%rbp)
movq -0x28(%rbp), %rdi
movb $0x2a, -0x31(%rbp)
leaq -0x31(%rbp), %rsi
callq 0xe3e0
jmp 0x9c41
movq -0x28(%rbp), %rdi
leaq -0x3(%rbp), %rsi
callq 0xe330
jmp 0x9c43
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x9bed
testb $0x1, -0x29(%rbp)
jne 0x9d18
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x9cc7
movq -0x20(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0xe3c0
movss (%rax), %xmm0
subss -0x8(%rbp), %xmm0
callq 0xe3a0
movss %xmm0, -0x44(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x38(%rbp), %rsi
callq 0xe3c0
movss (%rax), %xmm0
subss -0x8(%rbp), %xmm0
callq 0xe3a0
movss -0x44(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x9cba
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x9cbc
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x9c67
movq -0x20(%rbp), %rdi
movslq -0x38(%rbp), %rsi
callq 0xe3c0
movss (%rax), %xmm0
subss -0x8(%rbp), %xmm0
callq 0xe3a0
cvtss2sd %xmm0, %xmm1
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x7319(%rip), %xmm2     # 0x11010
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x9d16
movq -0x28(%rbp), %rdi
movl -0x38(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0xe410
movb $0x2a, (%rax)
jmp 0x9d18
movq -0x28(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq -0x3d(%rbp), %rsi
callq 0xe3e0
movq -0x28(%rbp), %rdi
callq 0xe430
movq %rax, %rsi
movq 0xb29c(%rip), %rdi      # 0x14fd8
callq 0x10e0
movq %rax, %rdi
movq 0xb27d(%rip), %rsi      # 0x14fc8
callq 0x1100
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: krig[P]easing/./easing.hpp
// Function: float easing::cubicInOut<float>(float)
T cubicInOut(T t) {
		if (t < T(0.5)) {
			return 4. * t * t * t;
		} else {
			const T f = (2. * t) - 2.;
			return 0.5 * f * f * f + 1.;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
movss 0x1e37(%rip), %xmm0     # 0x11008
ucomiss -0x8(%rbp), %xmm0
jbe 0xf211
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1e48(%rip), %xmm0     # 0x11030
mulsd %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xf277
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
movsd 0x1e12(%rip), %xmm1     # 0x11038
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1ddc(%rip), %xmm0     # 0x11020
mulsd %xmm1, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movsd 0x1dbe(%rip), %xmm1     # 0x11028
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nop
// File: krig[P]easing/./easing.hpp
// Function: float easing::quinticInOut<float>(float)
T quinticInOut(T t) {
		if (t < 0.5) {
			return 16. * t * t * t * t * t;
		} else {
			T f = ((2. * t) - 2.);
			return  0.5 * f * f * f * f * f + 1.;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1c66(%rip), %xmm0     # 0x11020
ucomisd %xmm1, %xmm0
jbe 0xf417
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1c6f(%rip), %xmm0     # 0x11040
mulsd %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xf497
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
movsd 0x1c0c(%rip), %xmm1     # 0x11038
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1bd6(%rip), %xmm0     # 0x11020
mulsd %xmm1, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movsd 0x1b9e(%rip), %xmm1     # 0x11028
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nop
// File: krig[P]easing/./easing.hpp
// Function: float easing::circularInOut<float>(float)
T circularInOut(T t) {
		if (t < 0.5) {
			return 0.5 * (1 - sqrt(1 - 4. * (t * t)));
		} else {
			return 0.5 * (sqrt(-((2. * t) - 3.) * ((2. * t) - 1.)) + 1.);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x19f2(%rip), %xmm0     # 0x11020
ucomisd %xmm1, %xmm0
jbe 0xf682
movss -0x8(%rbp), %xmm0
mulss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x1a1e(%rip), %xmm1     # 0x11068
mulsd %xmm1, %xmm0
movsd 0x19d2(%rip), %xmm1     # 0x11028
addsd %xmm1, %xmm0
callq 0x10b0
movsd 0x19c1(%rip), %xmm1     # 0x11028
subsd %xmm0, %xmm1
movsd 0x19ad(%rip), %xmm0     # 0x11020
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xf6f8
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
movsd 0x19c9(%rip), %xmm1     # 0x11060
addsd %xmm1, %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm1
movsd 0x1991(%rip), %xmm2     # 0x11058
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
callq 0x10b0
movaps %xmm0, %xmm1
movsd 0x1949(%rip), %xmm0     # 0x11028
addsd %xmm0, %xmm1
movsd 0x1935(%rip), %xmm0     # 0x11020
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: krig[P]easing/./easing.hpp
// Function: float easing::exponentialInOut<float>(float)
T exponentialInOut(T t) {
		if (t <= 0. || t >= 1.)
			return t;

		if (t < 0.5) {
			return 0.5 * pow(2., (20. * t) - 10.);
		} else {
			return -0.5 * pow(2., (-20. * t) + 10.) + 1.;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jae 0xf836
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x17f8(%rip), %xmm1     # 0x11028
ucomisd %xmm1, %xmm0
jb 0xf845
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xf8f3
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x17ca(%rip), %xmm0     # 0x11020
ucomisd %xmm1, %xmm0
jbe 0xf8a4
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1823(%rip), %xmm0     # 0x11090
mulsd %xmm0, %xmm1
movsd 0x17ff(%rip), %xmm0     # 0x11078
addsd %xmm0, %xmm1
movsd 0x1793(%rip), %xmm0     # 0x11018
callq 0x1150
movaps %xmm0, %xmm1
movsd 0x178b(%rip), %xmm0     # 0x11020
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xf8f3
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x17d3(%rip), %xmm0     # 0x11088
mulsd %xmm0, %xmm1
movsd 0x17af(%rip), %xmm0     # 0x11070
addsd %xmm0, %xmm1
movsd 0x174b(%rip), %xmm0     # 0x11018
callq 0x1150
movsd 0x17a6(%rip), %xmm1     # 0x11080
mulsd %xmm1, %xmm0
movsd 0x1742(%rip), %xmm1     # 0x11028
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: krig[P]easing/./easing.hpp
// Function: float easing::elasticInOut<float>(float)
T elasticInOut(T t) {
		if (t < 0.5) {
			return 0.5 * sin(13. * M_PI_2 * (2. * t)) * pow(2., 10. * ((2. * t) - 1.));
		} else {
			return 0.5 * (sin(-13. * M_PI_2 * ((2. * t - 1) + 1)) * pow(2., -10. * (2. * t - 1.)) + 2.);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1612(%rip), %xmm0     # 0x11020
ucomisd %xmm1, %xmm0
jbe 0xfa9e
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x15ef(%rip), %xmm1     # 0x11018
mulsd %xmm0, %xmm1
movsd 0x1663(%rip), %xmm0     # 0x11098
mulsd %xmm1, %xmm0
callq 0x1040
movaps %xmm0, %xmm1
movsd 0x15d7(%rip), %xmm0     # 0x11020
mulsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
movsd 0x15f1(%rip), %xmm1     # 0x11058
addsd %xmm1, %xmm0
movsd 0x15fd(%rip), %xmm1     # 0x11070
mulsd %xmm0, %xmm1
movsd 0x1599(%rip), %xmm0     # 0x11018
callq 0x1150
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xfb35
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
addsd %xmm1, %xmm1
movsd 0x15a5(%rip), %xmm0     # 0x11058
addsd %xmm0, %xmm1
movsd 0x1569(%rip), %xmm0     # 0x11028
addsd %xmm0, %xmm1
movsd 0x15d5(%rip), %xmm0     # 0x110a0
mulsd %xmm1, %xmm0
callq 0x1040
movsd %xmm0, -0x18(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
movsd 0x156a(%rip), %xmm1     # 0x11058
addsd %xmm1, %xmm0
movsd 0x157e(%rip), %xmm1     # 0x11078
mulsd %xmm0, %xmm1
movsd 0x1512(%rip), %xmm0     # 0x11018
callq 0x1150
movsd -0x18(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x14fc(%rip), %xmm0     # 0x11018
addsd %xmm0, %xmm1
movsd 0x14f8(%rip), %xmm0     # 0x11020
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: krig[P]easing/./easing.hpp
// Function: float easing::backInOut<float>(float)
T backInOut(T t) {
		if (t < 0.5) {
			const T f = 2. * t;
			return 0.5 * (f * f * f - f * sin(f * M_PI));
		} else {
			const T f = (1. - (2.*t - 1.));
			return 0.5 * (1. - (f * f * f - f * sin(f * M_PI))) + 0.5;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1382(%rip), %xmm0     # 0x11020
ucomisd %xmm1, %xmm0
jbe 0xfd4c
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x135f(%rip), %xmm0     # 0x11018
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
mulss -0xc(%rbp), %xmm0
mulss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x1353(%rip), %xmm1     # 0x11050
mulsd %xmm1, %xmm0
callq 0x1040
movsd -0x20(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x18(%rbp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x12e6(%rip), %xmm0     # 0x11020
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xfe0b
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
addsd %xmm1, %xmm1
movsd 0x12f7(%rip), %xmm0     # 0x11058
addsd %xmm0, %xmm1
movsd 0x12bb(%rip), %xmm0     # 0x11028
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
mulss -0x10(%rbp), %xmm0
mulss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x129f(%rip), %xmm1     # 0x11050
mulsd %xmm1, %xmm0
callq 0x1040
movsd -0x30(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x123a(%rip), %xmm0     # 0x11028
subsd %xmm1, %xmm0
movsd 0x1226(%rip), %xmm1     # 0x11020
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: krig[P]easing/./easing.hpp
// Function: double easing::bounceOut<double>(double)
T bounceOut(T t) {
		if (t < 4. / 11.) {
			return (121. * t * t) / 16.;
		} else if (t < 8. / 11.) {
			return (363. / 40. * t * t) - (99 / 10. * t) + 17 / 5.;
		} else if (t < 9. / 10.) {
			return (4356. / 361. * t * t) - (35442. / 1805. * t) + 16061. / 1805.;
		} else {
			return (54. / 5. * t * t) - (513. / 25. * t) + 268. / 25.;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd 0x1237(%rip), %xmm0     # 0x110a8
ucomisd -0x10(%rbp), %xmm0
jbe 0xfea0
movsd 0x1288(%rip), %xmm0     # 0x11108
mulsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd 0x11ae(%rip), %xmm1     # 0x11040
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xffb2
movsd 0x1208(%rip), %xmm0     # 0x110b0
ucomisd -0x10(%rbp), %xmm0
jbe 0xff03
movsd 0x1249(%rip), %xmm0     # 0x11100
mulsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movsd 0x122f(%rip), %xmm1     # 0x110f8
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 0x11fb(%rip), %xmm1     # 0x110f0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xffb2
movsd 0x11ad(%rip), %xmm0     # 0x110b8
ucomisd -0x10(%rbp), %xmm0
jbe 0xff63
movsd 0x11ce(%rip), %xmm0     # 0x110e8
mulsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movsd 0x11b4(%rip), %xmm1     # 0x110e0
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 0x1180(%rip), %xmm1     # 0x110d8
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xffb2
movsd 0x1165(%rip), %xmm0     # 0x110d0
mulsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movsd 0x114b(%rip), %xmm1     # 0x110c8
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 0x1117(%rip), %xmm1     # 0x110c0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: krig[P]easing/./easing.hpp
// Function: float easing::bounceInOut<float>(float)
T bounceInOut(T t) {
		if (t < 0.5) {
			return 0.5 * bounceIn(t * 2.);
		} else {
			return 0.5 * bounceOut(t * 2. - 1.) + 0.5;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xe72(%rip), %xmm0      # 0x11020
ucomisd %xmm1, %xmm0
jbe 0x101e8
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xe53(%rip), %xmm1      # 0x11018
mulsd %xmm1, %xmm0
callq 0x10230
movaps %xmm0, %xmm1
movsd 0xe47(%rip), %xmm0      # 0x11020
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x1021f
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
movsd 0xe5b(%rip), %xmm1      # 0x11058
addsd %xmm1, %xmm0
callq 0xfe60
movsd 0xe12(%rip), %xmm1      # 0x11020
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: krig[P]easing/./easing.hpp
// Function: float easing::perlinInOut<float>(float)
T perlinInOut(T t) {
		T t3 = t * t * t;
		T t4 = t3 * t;
		T t5 = t4 * t;
		return 6. * t5 - 15. * t4 + 10. * t3;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
mulss -0x4(%rbp), %xmm0
mulss -0x4(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
mulss -0x4(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
mulss -0x4(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm2
movsd 0xe53(%rip), %xmm0      # 0x11118
mulsd %xmm2, %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0xe28(%rip), %xmm2      # 0x11110
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xd6f(%rip), %xmm2      # 0x11070
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_32.cc
// Function: print(std::ostream&, QueryResult const&)
ostream& print(ostream& os, const QueryResult& qr)
{
	os << qr.sought << " occurs " << qr.lines->size() << " "
		<< "time(s)" << endl;

	for (auto num : *qr.lines) {
		ConstStrBlobPtr p(qr.file, num + 1);
		os << "\t(line " << num + 1 << ") "
			<< p.deref() << endl;
	}

	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x31d0
movq %rax, %rdi
leaq 0x5b73(%rip), %rsi      # 0xa03d
callq 0x31f0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x49b0
movq %rax, %rdi
callq 0x4c10
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x3060
movq %rax, %rdi
leaq 0x5b59(%rip), %rsi      # 0xa057
callq 0x31f0
movq %rax, %rdi
leaq 0x5b39(%rip), %rsi      # 0xa046
callq 0x31f0
movq %rax, %rdi
movq 0xba74(%rip), %rsi      # 0xff90
callq 0x3230
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x4c30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4c60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4c90
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4cc0
testb $0x1, %al
jne 0x4562
jmp 0x4634
leaq -0x20(%rbp), %rdi
callq 0x4cf0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
movq -0x30(%rbp), %rdx
incq %rdx
leaq -0x48(%rbp), %rdi
callq 0x4d10
movq -0x8(%rbp), %rdi
leaq 0x5ab9(%rip), %rsi      # 0xa04e
callq 0x31f0
movq %rax, -0x68(%rbp)
jmp 0x45a0
movq -0x68(%rbp), %rdi
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3060
movq %rax, -0x70(%rbp)
jmp 0x45b6
movq -0x70(%rbp), %rdi
leaq 0x5a95(%rip), %rsi      # 0xa056
callq 0x31f0
movq %rax, -0x78(%rbp)
jmp 0x45cc
leaq -0x48(%rbp), %rdi
callq 0x4d50
movq %rax, -0x80(%rbp)
jmp 0x45db
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x31d0
movq %rax, -0x88(%rbp)
jmp 0x45f1
movq -0x88(%rbp), %rdi
movq 0xb991(%rip), %rsi      # 0xff90
callq 0x3230
jmp 0x4606
leaq -0x48(%rbp), %rdi
callq 0x4e20
leaq -0x20(%rbp), %rdi
callq 0x4e40
jmp 0x454c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4e20
jmp 0x4641
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3340
nopw (%rax,%rax)
// File: rfotino[P]consolite-compiler/src/compiler.cpp
// Function: main
int main(int argc, char **argv) {
  if (3 != argc) {
    usage(argv[0]);
    return 1;
  }

  try {
    // Creates a stream of tokens from the input file
    Tokenizer tokenizer(argv[1]);
    // Parses the tokens into an abstract syntax tree
    Parser parser(&tokenizer);
    if (!parser.parse()) {
      return 1;
    }
    // Compiles the syntax tree to the output file
    if (!parser.output(argv[2])) {
      return 1;
    }
  } catch (char const *error) {
    std::cout << "Error: " << error << std::endl;
    return 1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp            # imm = 0x340
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x3, %eax
cmpl -0x8(%rbp), %eax
je 0x8acb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x8a40
movl $0x1, -0x4(%rbp)
jmp 0x8c7a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x70(%rbp), %rdi
callq 0x6ac50
jmp 0x8ade
leaq -0x318(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x99f0
jmp 0x8af0
leaq -0x318(%rbp), %rdi
callq 0xb1d0
movb %al, -0x329(%rbp)
jmp 0x8b04
movb -0x329(%rbp), %al
testb $0x1, %al
jne 0x8b62
jmp 0x8b10
movl $0x1, -0x4(%rbp)
movl $0x1, -0x31c(%rbp)
jmp 0x8ba7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x8bdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x8bd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x318(%rbp), %rdi
callq 0x8c90
jmp 0x8bd2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x318(%rbp), %rdi
callq 0xbb40
movb %al, -0x32a(%rbp)
jmp 0x8b7e
movb -0x32a(%rbp), %al
testb $0x1, %al
jne 0x8b9d
jmp 0x8b8a
movl $0x1, -0x4(%rbp)
movl $0x1, -0x31c(%rbp)
jmp 0x8ba7
movl $0x0, -0x31c(%rbp)
leaq -0x318(%rbp), %rdi
callq 0x8c90
leaq -0x70(%rbp), %rdi
callq 0x8cf0
movl -0x31c(%rbp), %eax
testl %eax, %eax
je 0x8bcd
jmp 0x8bc8
jmp 0x8c7a
jmp 0x8c73
leaq -0x70(%rbp), %rdi
callq 0x8cf0
movl -0x7c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x8c86
movq -0x78(%rbp), %rdi
callq 0x8190
movq %rax, -0x328(%rbp)
movq 0x9539e(%rip), %rdi     # 0x9dfa0
leaq 0x6640d(%rip), %rsi     # 0x6f016
callq 0x83d0
movq %rax, -0x338(%rbp)
jmp 0x8c17
movq -0x338(%rbp), %rdi
movq -0x328(%rbp), %rsi
callq 0x83d0
movq %rax, -0x340(%rbp)
jmp 0x8c33
movq -0x340(%rbp), %rdi
movq 0x9531f(%rip), %rsi     # 0x9df60
callq 0x8430
jmp 0x8c48
movl $0x1, -0x4(%rbp)
movl $0x1, -0x31c(%rbp)
callq 0x8670
jmp 0x8c7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x8670
jmp 0x8c86
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x340, %rsp            # imm = 0x340
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x8750
nop
// File: rfotino[P]consolite-compiler/src/parser.cpp
// Function: Parser::addLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Parser::addLabel(const std::string& label) {
  if (this->hasLabel(label)) {
    return false;
  }
  _assignedLabels.insert(label);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0xccd0
testb $0x1, %al
jne 0xc387
jmp 0xc38d
movb $0x0, -0x1(%rbp)
jmp 0xc3ac
movq -0x30(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movq -0x18(%rbp), %rsi
callq 0xddf0
movq %rax, -0x28(%rbp)
movb %dl, -0x20(%rbp)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rfotino[P]consolite-compiler/src/parser.cpp
// Function: Parser::getUnusedLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Parser::getUnusedLabel(const std::string& label) {
  if (!this->hasLabel(label)) {
    this->addLabel(label);
    return label;
  }
  int i = 1;
  while (this->hasLabel(label + std::to_string(i))) {
    i++;
  }
  this->addLabel(label + std::to_string(i));
  return label + std::to_string(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
movq -0x18(%rbp), %rsi
callq 0xccd0
testb $0x1, %al
jne 0xc425
movq -0xd8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc360
movq -0xe8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x81b0
jmp 0xc5d8
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xf8(%rbp)
movl -0x1c(%rbp), %esi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0xde80
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0xde30
jmp 0xc463
movq -0xd8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xccd0
movb %al, -0xf9(%rbp)
jmp 0xc47b
leaq -0x40(%rbp), %rdi
callq 0x8848
leaq -0x60(%rbp), %rdi
callq 0x8848
movb -0xf9(%rbp), %al
testb $0x1, %al
jne 0xc499
jmp 0xc4d5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc42c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xc4c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8848
leaq -0x60(%rbp), %rdi
callq 0x8848
jmp 0xc5e8
movq -0x18(%rbp), %rax
movq %rax, -0x110(%rbp)
movl -0x1c(%rbp), %esi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xde80
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0xde30
jmp 0xc512
movq -0xd8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xc360
jmp 0xc527
leaq -0x90(%rbp), %rdi
callq 0x8848
leaq -0xb0(%rbp), %rdi
callq 0x8848
movq -0x18(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x1c(%rbp), %esi
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0xde80
movq -0xe8(%rbp), %rdi
movq -0x120(%rbp), %rsi
movq -0x118(%rbp), %rdx
callq 0xde30
jmp 0xc57c
leaq -0xd0(%rbp), %rdi
callq 0x8848
jmp 0xc5d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xc5b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x8848
leaq -0xb0(%rbp), %rdi
callq 0x8848
jmp 0xc5e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x8848
jmp 0xc5e8
movq -0xe0(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x8750
nopw %cs:(%rax,%rax)
// File: rfotino[P]consolite-compiler/src/parser.cpp
// Function: Parser::writeln(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Parser::writeln(const std::string& line) {
  // If there is a pending PUSH instruction, first write it
  // to the outfile.
  if (!_pendingPushReg.empty()) {
    _outfile << "        PUSH " << _pendingPushReg << std::endl;
    _pendingPushReg = "";
  }
  // Then write the new line.
  _outfile << line << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x238, %rdi            # imm = 0x238
callq 0x8690
testb $0x1, %al
jne 0xcca5
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
leaq 0x624d4(%rip), %rsi     # 0x6f13b
callq 0x83d0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x238, %rsi            # imm = 0x238
callq 0x8390
movq %rax, %rdi
movq 0x912d7(%rip), %rsi     # 0x9df60
callq 0x8430
movq -0x18(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
leaq 0x634bf(%rip), %rsi     # 0x7015f
callq 0x8580
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x8390
movq %rax, %rdi
movq 0x912a0(%rip), %rsi     # 0x9df60
callq 0x8430
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rfotino[P]consolite-compiler/src/parser.cpp
// Function: Parser::writeData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void Parser::writeData(const std::string& data, int dataLength) {
  this->writeln("        " + data);
  _bytePos += dataLength * DATA_SIZE;
  while (0 != _bytePos % INST_SIZE) {
    _bytePos++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x623fc(%rip), %rsi     # 0x6f132
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xdc30
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xcc30
jmp 0xcd52
leaq -0x38(%rbp), %rdi
callq 0x8848
movq -0x58(%rbp), %rax
movl -0x14(%rbp), %edx
shll %edx
movzwl 0x290(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x290(%rax)
movq -0x58(%rbp), %rax
movzwl 0x290(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl %edx, %eax
je 0xcdbc
movq -0x58(%rbp), %rax
movw 0x290(%rax), %cx
addw $0x1, %cx
movw %cx, 0x290(%rax)
jmp 0xcd74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8848
jmp 0xcdc2
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x8750
nopl (%rax,%rax)
// File: rfotino[P]consolite-compiler/src/syntax.cpp
// Function: FunctionToken::toAsmLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string FunctionToken::toAsmLabel(const std::string& srcLabel) {
  for (auto label : _labels) {
    if (srcLabel == label->name()) {
      return label->getAsmLabel();
    }
  }
  return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0xa8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x34720
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x34750
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x34780
testb $0x1, %al
jne 0x2abe3
jmp 0x2acb7
leaq -0x28(%rbp), %rdi
callq 0x347c0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x347e0
movq -0x98(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x34810
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x34830
jmp 0x2ac24
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x154d0
movb %al, -0x99(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8848
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x2ac4f
jmp 0x2ac8c
leaq -0x40(%rbp), %rdi
callq 0x34810
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x349c0
jmp 0x2ac69
movl $0x1, -0x70(%rbp)
jmp 0x2ac93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x10150
jmp 0x2ad12
movl $0x0, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x10150
movl -0x70(%rbp), %eax
testl %eax, %eax
je 0x2aca7
jmp 0x2aca5
jmp 0x2ad05
jmp 0x2aca9
leaq -0x28(%rbp), %rdi
callq 0x34890
jmp 0x2abcd
leaq -0x71(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x8760
movq -0x88(%rbp), %rdi
movq -0xa8(%rbp), %rdx
leaq 0x45483(%rip), %rsi     # 0x7015f
callq 0xced0
jmp 0x2ace3
leaq -0x71(%rbp), %rdi
callq 0x8460
jmp 0x2ad05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x71(%rbp), %rdi
callq 0x8460
jmp 0x2ad12
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x8750
nopl (%rax,%rax)
// File: rfotino[P]consolite-compiler/src/syntax.cpp
// Function: ExprStatement::parse(Tokenizer*, std::vector<std::shared_ptr<FunctionToken>, std::allocator<std::shared_ptr<FunctionToken>>> const&, std::vector<std::shared_ptr<GlobalVarToken>, std::allocator<std::shared_ptr<GlobalVarToken>>> const&, std::vector<std::shared_ptr<ParamToken>, std::allocator<std::shared_ptr<ParamToken>>> const&, std::vector<std::shared_ptr<LocalVarToken>, std::allocator<std::shared_ptr<LocalVarToken>>> const&)
bool ExprStatement::parse(
      Tokenizer *tokenizer,
      const std::vector<std::shared_ptr<FunctionToken>>& functions,
      const std::vector<std::shared_ptr<GlobalVarToken>>& globals,
      const std::vector<std::shared_ptr<ParamToken>>& parameters,
      const std::vector<std::shared_ptr<LocalVarToken>>& localVars) {
  _lineNum = tokenizer->peekNext().line();
  // An expression statement is just an expression followed by a semicolon.
  if (!_expr.parse(tokenizer, functions, globals, parameters, localVars)) {
    return false;
  }
  if (!_expect(tokenizer, ";")) {
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x6bae0
movq -0xa8(%rbp), %rdi
callq 0x32270
movl %eax, -0xa0(%rbp)
jmp 0x2f606
movq -0xb0(%rbp), %rax
movl -0xa0(%rbp), %ecx
movl %ecx, 0x8(%rax)
leaq -0x68(%rbp), %rdi
callq 0x99b0
movq -0xb0(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x1d9b0
testb $0x1, %al
jne 0x2f66a
movb $0x0, -0x1(%rbp)
jmp 0x2f734
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x99b0
jmp 0x2f742
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x99(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x8760
movq -0xb8(%rbp), %rdx
leaq 0x405bb(%rip), %rsi     # 0x6fc51
leaq -0x98(%rbp), %rdi
callq 0xced0
jmp 0x2f6a4
movq -0xc0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
movl $0x1, %edx
callq 0x6da60
movb %al, -0xc1(%rbp)
jmp 0x2f6c4
movb -0xc1(%rbp), %al
xorb $-0x1, %al
movb %al, -0xc2(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x8848
leaq -0x99(%rbp), %rdi
callq 0x8460
movb -0xc2(%rbp), %al
testb $0x1, %al
jne 0x2f6f6
jmp 0x2f730
movb $0x0, -0x1(%rbp)
jmp 0x2f734
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x2f722
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x8848
leaq -0x99(%rbp), %rdi
callq 0x8460
jmp 0x2f742
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x8750
nopl (%rax,%rax)
// File: rfotino[P]consolite-compiler/src/tokenizer.cpp
// Function: Tokenizer::Tokenizer(char*)
Tokenizer::Tokenizer(char *filename) : _offset(0), _lineNum(1),
                                       _hasNext(false) {
  std::ifstream inputStream(filename);
  inputStream.seekg(0, std::ios::end);
  _data.reserve(inputStream.tellg());
  inputStream.seekg(0, std::ios::beg);
  _data.assign(std::istreambuf_iterator<char>(inputStream),
               std::istreambuf_iterator<char>());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x268(%rbp)
movl $0x0, (%rdi)
movl $0x1, 0x4(%rdi)
movb $0x0, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x270(%rbp)
callq 0x6bb50
movq -0x268(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x260(%rbp)
callq 0x8590
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x87a0
jmp 0x6acbd
xorl %eax, %eax
movl %eax, %esi
leaq -0x218(%rbp), %rdi
movl $0x2, %edx
callq 0x8570
jmp 0x6acd4
movq -0x268(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x288(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x8720
movq %rdx, -0x280(%rbp)
movq %rax, -0x278(%rbp)
jmp 0x6ad02
movq -0x280(%rbp), %rax
movq -0x278(%rbp), %rcx
movq %rcx, -0x238(%rbp)
movq %rax, -0x230(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x6bb90
movq %rax, -0x290(%rbp)
jmp 0x6ad33
movq -0x290(%rbp), %rsi
movq -0x288(%rbp), %rdi
callq 0x8640
jmp 0x6ad48
xorl %edx, %edx
movl %edx, %esi
leaq -0x218(%rbp), %rdi
callq 0x8570
jmp 0x6ad5a
movq -0x268(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x298(%rbp)
leaq -0x248(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x6bc60
leaq -0x258(%rbp), %rdi
callq 0x6bcc0
movq -0x298(%rbp), %rdi
movq -0x248(%rbp), %rsi
movl -0x240(%rbp), %edx
movq -0x258(%rbp), %rcx
movl -0x250(%rbp), %r8d
callq 0x6bbb0
jmp 0x6adb4
leaq -0x218(%rbp), %rdi
callq 0x8100
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x6adfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x8100
movq -0x260(%rbp), %rdi
callq 0x8848
movq -0x270(%rbp), %rdi
callq 0x99b0
movq -0x220(%rbp), %rdi
callq 0x8750
nop
// File: rfotino[P]consolite-compiler/src/util.cpp
// Function: toHexStr[abi:cxx11](unsigned short, int)
std::string toHexStr(uint16_t value, int digits) {
  std::string str;
  for (int i = 0; i < digits; i++) {
    uint8_t next = value & 0xf;
    value >>= 4;
    str = (char)(next <= 9 ? '0' + next : 'a' - 10 + next) + str;
  }
  return "0x" + str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movw %si, %ax
movq %rdi, %rcx
movq %rcx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %edx, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8590
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x6ca11
movzwl -0xa(%rbp), %eax
andl $0xf, %eax
movb %al, -0x35(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x4, %eax
movw %ax, -0xa(%rbp)
movzbl -0x35(%rbp), %eax
cmpl $0x9, %eax
jg 0x6c9ba
movzbl -0x35(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x7c(%rbp)
jmp 0x6c9c4
movzbl -0x35(%rbp), %eax
addl $0x57, %eax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movsbl %al, %esi
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x6ddd0
jmp 0x6c9d9
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x84e0
leaq -0x58(%rbp), %rdi
callq 0x8848
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6c984
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8848
jmp 0x6ca3d
movq -0x78(%rbp), %rdi
leaq 0x4be8(%rip), %rsi      # 0x71604
leaq -0x30(%rbp), %rdx
callq 0xdc30
jmp 0x6ca27
leaq -0x30(%rbp), %rdi
callq 0x8848
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x8750
nopw %cs:(%rax,%rax)
// File: rfotino[P]consolite-compiler/src/util.cpp
// Function: getParameter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<ParamToken>, std::allocator<std::shared_ptr<ParamToken>>> const&)
std::shared_ptr<ParamToken> getParameter(
      const std::string& name,
      const std::vector<std::shared_ptr<ParamToken>>& parameters) {
  for (auto param : parameters) {
    if (param->name() == name) {
      return param;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe960
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe990
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xed70
testb $0x1, %al
jne 0x6d37a
jmp 0x6d425
movb $0x0, -0x31(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xede0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0xee60
movq -0x78(%rbp), %rdi
callq 0x34080
movq %rax, %rsi
addq $0x10, %rsi
leaq -0x58(%rbp), %rdi
callq 0xdaa0
jmp 0x6d3ae
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x154d0
movb %al, -0x79(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8848
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x6d3d0
jmp 0x6d3f4
movb $0x1, -0x31(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0x6d3fb
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0xd400
jmp 0x6d43f
movl $0x0, -0x68(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x6d40a
movq -0x78(%rbp), %rdi
callq 0xd400
movl -0x68(%rbp), %eax
testl %eax, %eax
je 0x6d415
jmp 0x6d413
jmp 0x6d432
jmp 0x6d417
leaq -0x28(%rbp), %rdi
callq 0xee00
jmp 0x6d364
movq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6df20
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x8750
nopl (%rax,%rax)
// File: rfotino[P]consolite-compiler/src/util.cpp
// Function: getLocal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<LocalVarToken>, std::allocator<std::shared_ptr<LocalVarToken>>> const&)
std::shared_ptr<LocalVarToken> getLocal(
      const std::string& name,
      const std::vector<std::shared_ptr<LocalVarToken>>& locals) {
  for (auto local : locals) {
    if (local->name() == name) {
      return local;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6df40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6df70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6dfa0
testb $0x1, %al
jne 0x6d4aa
jmp 0x6d555
movb $0x0, -0x31(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6dfe0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x34620
movq -0x78(%rbp), %rdi
callq 0x34650
movq %rax, %rsi
addq $0x10, %rsi
leaq -0x58(%rbp), %rdi
callq 0xdaa0
jmp 0x6d4de
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x154d0
movb %al, -0x79(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8848
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x6d500
jmp 0x6d524
movb $0x1, -0x31(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0x6d52b
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x10dc0
jmp 0x6d56f
movl $0x0, -0x68(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x6d53a
movq -0x78(%rbp), %rdi
callq 0x10dc0
movl -0x68(%rbp), %eax
testl %eax, %eax
je 0x6d545
jmp 0x6d543
jmp 0x6d562
jmp 0x6d547
leaq -0x28(%rbp), %rdi
callq 0x6e000
jmp 0x6d494
movq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6e020
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x8750
nopl (%rax,%rax)
// File: rfotino[P]consolite-compiler/src/util.cpp
// Function: getFunction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<FunctionToken>, std::allocator<std::shared_ptr<FunctionToken>>> const&)
std::shared_ptr<FunctionToken> getFunction(
      const std::string& name,
      const std::vector<std::shared_ptr<FunctionToken>>& functions) {
  for (auto func : functions) {
    if (func->name() == name) {
      return func;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6e040
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6e070
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6e0a0
testb $0x1, %al
jne 0x6d5da
jmp 0x6d681
movb $0x0, -0x31(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6e0e0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0xdbb0
movq -0x78(%rbp), %rdi
callq 0xd780
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0xdbe0
jmp 0x6d60a
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x154d0
movb %al, -0x79(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8848
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x6d62c
jmp 0x6d650
movb $0x1, -0x31(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0x6d657
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x94c0
jmp 0x6d69b
movl $0x0, -0x68(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x6d666
movq -0x78(%rbp), %rdi
callq 0x94c0
movl -0x68(%rbp), %eax
testl %eax, %eax
je 0x6d671
jmp 0x6d66f
jmp 0x6d68e
jmp 0x6d673
leaq -0x28(%rbp), %rdi
callq 0x6e100
jmp 0x6d5c4
movq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34700
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x8750
nopw %cs:(%rax,%rax)
// File: rfotino[P]consolite-compiler/src/util.cpp
// Function: getGlobal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<GlobalVarToken>, std::allocator<std::shared_ptr<GlobalVarToken>>> const&)
std::shared_ptr<GlobalVarToken> getGlobal(
     const std::string& name,
     const std::vector<std::shared_ptr<GlobalVarToken>>& globals) {
  for (auto global : globals) {
    if (global->name() == name) {
      return global;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6e120
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6e150
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6e180
testb $0x1, %al
jne 0x6d70a
jmp 0x6d7b5
movb $0x0, -0x31(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6e1c0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0xda70
movq -0x78(%rbp), %rdi
callq 0xd830
movq %rax, %rsi
addq $0x10, %rsi
leaq -0x58(%rbp), %rdi
callq 0xdaa0
jmp 0x6d73e
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x154d0
movb %al, -0x79(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8848
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x6d760
jmp 0x6d784
movb $0x1, -0x31(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0x6d78b
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x9880
jmp 0x6d7cf
movl $0x0, -0x68(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x6d79a
movq -0x78(%rbp), %rdi
callq 0x9880
movl -0x68(%rbp), %eax
testl %eax, %eax
je 0x6d7a5
jmp 0x6d7a3
jmp 0x6d7c2
jmp 0x6d7a7
leaq -0x28(%rbp), %rdi
callq 0x6e1e0
jmp 0x6d6f4
movq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6e200
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x8750
nopl (%rax,%rax)
// File: rfotino[P]consolite-compiler/src/util.cpp
// Function: getLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<LabelStatement>, std::allocator<std::shared_ptr<LabelStatement>>> const&)
std::shared_ptr<LabelStatement> getLabel(
      const std::string& name,
      const std::vector<std::shared_ptr<LabelStatement>>& labels) {
  for (auto label : labels) {
    if (label->name() == name) {
      return label;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6e220
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6e250
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6e280
testb $0x1, %al
jne 0x6d83a
jmp 0x6d8e1
movb $0x0, -0x31(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6e2c0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x347e0
movq -0x78(%rbp), %rdi
callq 0x34810
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x34830
jmp 0x6d86a
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x154d0
movb %al, -0x79(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8848
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x6d88c
jmp 0x6d8b0
movb $0x1, -0x31(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0x6d8b7
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x10150
jmp 0x6d8fb
movl $0x0, -0x68(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x6d8c6
movq -0x78(%rbp), %rdi
callq 0x10150
movl -0x68(%rbp), %eax
testl %eax, %eax
je 0x6d8d1
jmp 0x6d8cf
jmp 0x6d8ee
jmp 0x6d8d3
leaq -0x28(%rbp), %rdi
callq 0x6e2e0
jmp 0x6d824
movq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6e300
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x8750
nopw %cs:(%rax,%rax)
// File: rfotino[P]consolite-compiler/src/util.cpp
// Function: error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void _error(const std::string& msg, int lineNum) {
  // TODO: It would be nice to have error messages that showed you
  // the source line and pointed to the token causing an error.
  std::cerr << "Error:";
  if (0 < lineNum) {
    std::cerr << lineNum << ":";
  }
  std::cerr << " " << msg << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x30672(%rip), %rdi     # 0x9dfe8
leaq 0x3cbd(%rip), %rsi      # 0x7163a
callq 0x83d0
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jge 0x6d9a7
movl -0xc(%rbp), %esi
movq 0x30655(%rip), %rdi     # 0x9dfe8
callq 0x8710
movq %rax, %rdi
leaq 0x3ca6(%rip), %rsi      # 0x71648
callq 0x83d0
movq 0x3063a(%rip), %rdi     # 0x9dfe8
leaq 0x1784(%rip), %rsi      # 0x6f139
callq 0x83d0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x8390
movq %rax, %rdi
movq 0x30590(%rip), %rsi     # 0x9df60
callq 0x8430
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)