LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/src/Geometry.cpp
// Function: Polygon::ReCalcBoundingBox()
void Polygon::ReCalcBoundingBox()
{
    BoundingBox.A = _Vertices[0];
    BoundingBox.B = _Vertices[0];
    for ( int i = 1; i < nVertices - 1; i++)
    {
        if ( _Vertices[i].x < BoundingBox.A.x ) BoundingBox.A.x = _Vertices[i].x ;
        if ( _Vertices[i].y < BoundingBox.A.y ) BoundingBox.A.y = _Vertices[i].y ;
        if ( _Vertices[i].x > BoundingBox.B.x ) BoundingBox.B.x = _Vertices[i].x ;
        if ( _Vertices[i].y > BoundingBox.B.y ) BoundingBox.B.y = _Vertices[i].y ;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x83a0
movq 0x10(%rbx), %rax
leaq 0x58(%rbx), %rcx
movups (%rax), %xmm0
movups %xmm0, 0x58(%rbx)
leaq 0x68(%rbx), %rdx
movups (%rax), %xmm0
movups %xmm0, 0x68(%rbx)
movslq 0x8(%rbx), %rsi
decq %rsi
movsd 0x58(%rbx), %xmm0
movsd 0x60(%rbx), %xmm1
movsd 0x68(%rbx), %xmm2
movsd 0x70(%rbx), %xmm3
addq $0x18, %rax
pushq $0x1
popq %rdi
cmpq %rsi, %rdi
jge 0x28dee
movsd -0x8(%rax), %xmm4
ucomisd %xmm4, %xmm0
jbe 0x28dac
movsd %xmm4, (%rcx)
movapd %xmm4, %xmm0
movsd (%rax), %xmm4
ucomisd %xmm4, %xmm1
jbe 0x28dbf
movsd %xmm4, 0x60(%rbx)
movapd %xmm4, %xmm1
movsd -0x8(%rax), %xmm4
ucomisd %xmm2, %xmm4
jbe 0x28dd2
movsd %xmm4, (%rdx)
movapd %xmm4, %xmm2
movsd (%rax), %xmm4
ucomisd %xmm3, %xmm4
jbe 0x28de5
movsd %xmm4, 0x70(%rbx)
movapd %xmm4, %xmm3
incq %rdi
addq $0x10, %rax
jmp 0x28d94
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: CheckOKAngles(double, double, double)
bool CheckOKAngles(double alpha, double beta, double a)
{
    //  First case, alpha is negative
    if ( alpha < 0 )
    {
        if ( beta < alpha )
        {
            //  Beta is also < 0
            //  In this case, OK if a >= alpha or a <= beta
            return (a >= alpha - angle_precision || a <= beta + angle_precision);
        }
        //  For all other cases, OK if a is betwen alpha and beta
        return (a >= alpha - angle_precision && a <= beta + angle_precision);
    }
    else
    {
    //  Alpha is positive.
        if ( beta >= alpha )
        {
            //  In this case beta is also positive, OK between alpha and beta
            return ( a >= alpha - angle_precision && a <= beta + angle_precision);
        }
        //  All other cases, NOK is between beta and alpha, so OK if >= alpha or <= beta
        return ( a >= alpha - angle_precision || a <= beta + angle_precision );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movaps %xmm2, -0x10(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
callq 0x83a0
movsd -0x18(%rbp), %xmm3
movsd -0x20(%rbp), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm3, %xmm0
movsd 0xb2be(%rip), %xmm0     # 0x3c220
addsd %xmm3, %xmm0
movsd 0xb25a(%rip), %xmm1     # 0x3c1c8
addsd %xmm2, %xmm1
jbe 0x30f8f
ucomisd %xmm2, %xmm3
ja 0x30f95
movapd -0x10(%rbp), %xmm2
cmplepd %xmm2, %xmm0
cmplepd %xmm1, %xmm2
andpd %xmm0, %xmm2
jmp 0x30fa8
ucomisd %xmm3, %xmm2
jae 0x30f7a
movapd -0x10(%rbp), %xmm2
cmplepd %xmm2, %xmm0
cmplepd %xmm1, %xmm2
orpd %xmm0, %xmm2
movd %xmm2, %eax
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/thierry7100[P]CutOptim/src/SvgDoc.cpp
// Function: SvgDoc::ComputeRefPoint(int, int, int)
Point SvgDoc::ComputeRefPoint(int FirstPos, int xSize, int ySize)
{
Point A;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
callq 0x83a0
movsd 0x5fa0(%rip), %xmm0     # 0x3a008
movapd %xmm0, %xmm1
cmpl $0x4, %r15d
jl 0x34098
movsd 0x18(%rbx), %xmm1
cvtsi2sd %r12d, %xmm2
subsd %xmm2, %xmm1
cmpl $0x7, %r15d
ja 0x34090
mulsd 0x7fb2(%rip), %xmm1     # 0x3c040
jmp 0x34098
addsd 0x8108(%rip), %xmm1     # 0x3c1a0
andl $0x3, %r15d
je 0x340cd
cvtsi2sd %r14d, %xmm2
cmpl $0x1, %r15d
jne 0x340bc
movsd 0x10(%rbx), %xmm0
subsd %xmm2, %xmm0
mulsd 0x7f86(%rip), %xmm0     # 0x3c040
jmp 0x340cd
movsd 0x10(%rbx), %xmm0
subsd %xmm2, %xmm0
addsd 0x80d3(%rip), %xmm0     # 0x3c1a0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movss %xmm0, -0x30(%rbp)
movb %dil, -0x2b(%rbp)
movb %sil, -0x2a(%rbp)
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x5b08
movq %rax, 0x8(%rbx)
leaq -0x2b(%rbp), %rsi
movq %rbx, %rdi
callq 0x82f8
xorl %r13d, %r13d
leaq -0x29(%rbp), %r12
xorl %r15d, %r15d
cmpq $0x3c, %r13
je 0x5b6b
movq (%r14), %rax
movss (%rax,%r13,4), %xmm0
subss -0x30(%rbp), %xmm0
andps 0x3617(%rip), %xmm0     # 0x9150
movss 0x34c7(%rip), %xmm1     # 0x9008
ucomiss %xmm0, %xmm1
jae 0x5b54
movq %rbx, %rdi
leaq -0x2a(%rbp), %rsi
callq 0x82f8
jmp 0x5b66
movb $0x2a, -0x29(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8450
movb $0x1, %r15b
incq %r13
jmp 0x5b1e
testb $0x1, %r15b
jne 0x5be1
movq (%r14), %rax
xorl %edx, %edx
pushq $0x1
popq %rcx
movss -0x30(%rbp), %xmm2
movaps 0x35cb(%rip), %xmm3     # 0x9150
movslq %edx, %rsi
cmpq $0x3c, %rcx
je 0x5bb6
movss (%rax,%rcx,4), %xmm0
subss %xmm2, %xmm0
andps %xmm3, %xmm0
movss (%rax,%rsi,4), %xmm1
subss %xmm2, %xmm1
andps %xmm3, %xmm1
ucomiss %xmm0, %xmm1
movl %ecx, %esi
ja 0x5baf
movl %edx, %esi
incq %rcx
movl %esi, %edx
jmp 0x5b85
movss (%rax,%rsi,4), %xmm0
subss -0x30(%rbp), %xmm0
andps 0x3589(%rip), %xmm0     # 0x9150
cvtss2sd %xmm0, %xmm0
movsd 0x349d(%rip), %xmm1     # 0x9070
ucomisd %xmm0, %xmm1
jbe 0x5be1
movq (%rbx), %rax
movb $0x2a, 0x1(%rax,%rsi)
leaq -0x31(%rbp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x8450
movq (%rbx), %rsi
movq 0x63de(%rip), %rdi      # 0xbfd8
callq 0x10c0
movq %rax, %rdi
callq 0x1050
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa67(%rip), %xmm1      # 0x901c
ucomiss %xmm0, %xmm1
cvtss2sd %xmm0, %xmm1
jbe 0x85d4
movsd 0xab2(%rip), %xmm0      # 0x9078
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
jmp 0x8604
addsd %xmm1, %xmm1
addsd 0xa40(%rip), %xmm1      # 0x9020
cvtsd2ss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xa58(%rip), %xmm0      # 0x9048
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd 0xa34(%rip), %xmm0      # 0x9038
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cvtss2sd %xmm0, %xmm1
movss 0x9c5(%rip), %xmm2      # 0x901c
ucomiss %xmm0, %xmm2
jbe 0x867a
movsd 0xa1c(%rip), %xmm0      # 0x9080
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
jmp 0x86b2
addsd %xmm1, %xmm1
addsd 0x99a(%rip), %xmm1      # 0x9020
cvtsd2ss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x9b2(%rip), %xmm0      # 0x9048
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd 0x986(%rip), %xmm0      # 0x9038
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movss 0x958(%rip), %xmm1      # 0x901c
ucomiss %xmm0, %xmm1
jbe 0x86f0
mulss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x9b7(%rip), %xmm0      # 0x9090
addsd 0x957(%rip), %xmm0      # 0x9038
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x8728
sqrtsd %xmm0, %xmm1
jmp 0x8731
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
movsd 0x988(%rip), %xmm1      # 0x9088
addsd %xmm0, %xmm1
xorpd 0xa34(%rip), %xmm1      # 0x9140
addsd 0x914(%rip), %xmm0      # 0x9028
mulsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x873f
sqrtsd %xmm0, %xmm0
jmp 0x8744
callq 0x1080
movapd %xmm0, %xmm1
movsd 0x8ff(%rip), %xmm0      # 0x9038
subsd %xmm1, %xmm0
jmp 0x874c
callq 0x1080
addsd 0x8ec(%rip), %xmm0      # 0x9038
mulsd 0x8f4(%rip), %xmm0      # 0x9048
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x87d1
pushq %rbp
movq %rsp, %rbp
ucomiss 0x897(%rip), %xmm0      # 0x9004
jae 0x87d0
cvtss2sd %xmm0, %xmm1
movss 0x8a1(%rip), %xmm2      # 0x901c
ucomiss %xmm0, %xmm2
jbe 0x87a3
mulsd 0x920(%rip), %xmm1      # 0x90a8
addsd 0x8d0(%rip), %xmm1      # 0x9060
movapd %xmm1, %xmm0
callq 0x10a0
mulsd 0x8a7(%rip), %xmm0      # 0x9048
jmp 0x87cc
mulsd 0x8ed(%rip), %xmm1      # 0x9098
addsd 0x8a5(%rip), %xmm1      # 0x9058
movapd %xmm1, %xmm0
callq 0x10a0
mulsd 0x8dc(%rip), %xmm0      # 0x90a0
addsd 0x86c(%rip), %xmm0      # 0x9038
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
cvtss2sd %xmm0, %xmm2
movss 0x792(%rip), %xmm1      # 0x901c
addsd %xmm2, %xmm2
ucomiss %xmm0, %xmm1
jbe 0x88d7
movsd %xmm2, -0x10(%rbp)
movsd 0x810(%rip), %xmm0      # 0x90b0
mulsd %xmm2, %xmm0
callq 0x1030
mulsd 0x797(%rip), %xmm0      # 0x9048
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
addsd 0x765(%rip), %xmm0      # 0x9028
mulsd 0x78d(%rip), %xmm0      # 0x9058
callq 0x10a0
mulsd -0x8(%rbp), %xmm0
jmp 0x8929
addsd 0x749(%rip), %xmm2      # 0x9028
movsd %xmm2, -0x10(%rbp)
movsd 0x74c(%rip), %xmm0      # 0x9038
addsd %xmm2, %xmm0
mulsd 0x7c0(%rip), %xmm0      # 0x90b8
callq 0x1030
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd 0x751(%rip), %xmm0      # 0x9060
callq 0x10a0
mulsd -0x8(%rbp), %xmm0
addsd 0x72f(%rip), %xmm0      # 0x9050
mulsd 0x71f(%rip), %xmm0      # 0x9048
cvtsd2ss %xmm0, %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
movss 0x625(%rip), %xmm1      # 0x901c
ucomiss %xmm0, %xmm1
jbe 0x8a46
addss %xmm0, %xmm0
movaps %xmm0, %xmm1
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
movsd %xmm1, -0x10(%rbp)
cvtss2sd %xmm0, %xmm1
movsd %xmm1, -0x8(%rbp)
movsd 0x61b(%rip), %xmm0      # 0x9040
mulsd %xmm1, %xmm0
callq 0x1030
movsd -0x10(%rbp), %xmm1
mulsd -0x8(%rbp), %xmm0
subsd %xmm0, %xmm1
mulsd 0x604(%rip), %xmm1      # 0x9048
jmp 0x8abe
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
addsd 0x5d2(%rip), %xmm0      # 0x9028
movsd 0x5da(%rip), %xmm1      # 0x9038
subsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movaps %xmm0, %xmm1
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
movsd %xmm1, -0x10(%rbp)
cvtss2sd %xmm0, %xmm1
movsd %xmm1, -0x8(%rbp)
movsd 0x5b5(%rip), %xmm0      # 0x9040
mulsd %xmm1, %xmm0
callq 0x1030
movsd 0x59c(%rip), %xmm1      # 0x9038
mulsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
subsd %xmm0, %xmm2
subsd %xmm2, %xmm1
movsd 0x592(%rip), %xmm0      # 0x9048
mulsd %xmm0, %xmm1
addsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/krig[P]easing/./easing.hpp
// Function: float easing::bounceOut<float>(float)
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
cvtss2sd %xmm0, %xmm0
movsd 0x4f8(%rip), %xmm1      # 0x90c0
ucomisd %xmm0, %xmm1
jbe 0x8beb
movsd 0x54a(%rip), %xmm1      # 0x9120
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x542(%rip), %xmm1      # 0x9128
jmp 0x8c7b
movsd 0x4d5(%rip), %xmm1      # 0x90c8
ucomisd %xmm0, %xmm1
jbe 0x8c1f
movsd 0x507(%rip), %xmm1      # 0x9108
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x4ff(%rip), %xmm0      # 0x9110
addsd %xmm1, %xmm0
addsd 0x4fb(%rip), %xmm0      # 0x9118
jmp 0x8c77
movsd 0x4a9(%rip), %xmm1      # 0x90d0
ucomisd %xmm0, %xmm1
jbe 0x8c53
movsd 0x4bb(%rip), %xmm1      # 0x90f0
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x4b3(%rip), %xmm0      # 0x90f8
addsd %xmm1, %xmm0
addsd 0x4af(%rip), %xmm0      # 0x9100
jmp 0x8c77
movsd 0x47d(%rip), %xmm1      # 0x90d8
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x475(%rip), %xmm0      # 0x90e0
addsd %xmm1, %xmm0
addsd 0x471(%rip), %xmm0      # 0x90e8
movapd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movaps %xmm0, %xmm1
cvtss2sd %xmm0, %xmm0
movss 0x388(%rip), %xmm2      # 0x901c
addsd %xmm0, %xmm0
ucomiss %xmm1, %xmm2
jbe 0x8cac
callq 0x8ccf
mulsd 0x39e(%rip), %xmm0      # 0x9048
jmp 0x8cc9
addsd 0x374(%rip), %xmm0      # 0x9028
callq 0x8af3
movsd 0x387(%rip), %xmm1      # 0x9048
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movaps %xmm0, %xmm1
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm2
mulss %xmm0, %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
cvtss2sd %xmm1, %xmm1
mulsd 0x40b(%rip), %xmm1      # 0x9130
mulsd 0x40b(%rip), %xmm0      # 0x9138
addsd %xmm1, %xmm0
mulsd 0x31f(%rip), %xmm2      # 0x9058
addsd %xmm0, %xmm2
cvtsd2ss %xmm2, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_32.cc
// Function: TextQuery::TextQuery(std::basic_ifstream<char, std::char_traits<char>>&)
TextQuery::TextQuery(ifstream& is)
{
	string text;
	while (getline(is, text)) {
		file.push_back(text);
		int n = file.size() - 1;
		istringstream line(text);
		string word;
		while (line >> word) {
			word = clean_str(word);
			/**
			 * if the key is not already present,
			 * a new element is created and inserted
			 * into the map for that key.
			*/
			auto& lines = wm[word];
			if (!lines)
				lines.reset(new set<line_no>);
			lines->insert(n);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
callq 0x2f7c
leaq 0x18(%rbx), %rax
andl $0x0, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq %rax, 0x30(%rbx)
andq $0x0, 0x38(%rbx)
movq %rbx, -0x30(%rbp)
leaq 0x10(%rbx), %r14
leaq -0x70(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %r15
leaq -0xa0(%rbp), %r12
movq -0x38(%rbp), %rdi
callq 0x2050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2973
movq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rbx
movq %rbx, %rsi
callq 0x2e00
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %r13
leaq -0x220(%rbp), %rdi
movq %rbx, %rsi
pushq $0x8
popq %rdx
callq 0x22c0
subq -0x40(%rbp), %r13
leaq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
andq $0x0, -0x58(%rbp)
movb $0x0, -0x50(%rbp)
shlq $0x1b, %r13
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %rax, %r13
sarq $0x20, %r13
leaq -0x220(%rbp), %rdi
movq %r15, %rsi
callq 0x2230
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2956
movq %r12, %rdi
movq %r15, %rsi
callq 0x29da
movq %r15, %rdi
movq %r12, %rsi
callq 0x2220
movq %r12, %rdi
callq 0x20d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e0e
movq %rax, %rbx
movq (%rax), %rdi
testq %rdi, %rdi
jne 0x2942
pushq $0x30
popq %rdi
callq 0x21d0
movq %rax, %rcx
addq $0x8, %rcx
andl $0x0, 0x8(%rax)
andq $0x0, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2e78
movq (%rbx), %rdi
movq %r13, -0xa0(%rbp)
movq %r12, %rsi
callq 0x3b6c
jmp 0x28be
movq %r15, %rdi
callq 0x20d0
leaq -0x220(%rbp), %rdi
callq 0x20e0
leaq -0x80(%rbp), %rsi
jmp 0x2845
leaq -0x80(%rbp), %rdi
callq 0x20d0
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2990
movq %rax, %rbx
jmp 0x29b3
jmp 0x299b
jmp 0x299b
jmp 0x299b
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20d0
leaq -0x220(%rbp), %rdi
callq 0x20e0
leaq -0x80(%rbp), %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x2746
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x26a8
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
callq 0x21b0
leaq 0x13ff(%rip), %rsi      # 0x403d
movq %rax, %rdi
callq 0x21c0
movq 0x20(%r14), %rcx
movq 0x28(%rcx), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x13fa(%rip), %rsi      # 0x4057
movq %rax, %rdi
callq 0x21c0
leaq 0x13da(%rip), %rsi      # 0x4046
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20f0
movq 0x20(%r14), %rbx
movq 0x18(%rbx), %r12
addq $0x8, %rbx
addq $0x30, %r14
leaq -0x48(%rbp), %r13
cmpq %rbx, %r12
je 0x2d0a
movq 0x20(%r12), %r15
incq %r15
movq %r13, %rdi
movq %r14, %rsi
callq 0x344c
movq %r15, -0x38(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x1397(%rip), %rsi      # 0x404e
callq 0x21c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x1385(%rip), %rsi      # 0x4056
callq 0x21c0
movq %rax, %r15
movq %r13, %rdi
callq 0x2efc
movq %r15, %rdi
movq %rax, %rsi
callq 0x21b0
movq %rax, %rdi
callq 0x20f0
leaq -0x40(%rbp), %rdi
callq 0x35c6
movq %r12, %rdi
callq 0x2210
movq %rax, %r12
jmp 0x2c90
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x35c6
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x2f8, %rsp            # imm = 0x2F8
movq %rsi, %rbx
cmpl $0x3, %edi
jne 0x77e4
movq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x27630
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x7b38
leaq 0x60(%rsp), %rdi
callq 0x87a4
testb %al, %al
je 0x77f1
movq 0x10(%rbx), %rsi
leaq 0x60(%rsp), %rdi
callq 0x8c5e
xorb $0x1, %al
movzbl %al, %ebx
jmp 0x77f4
movq (%rbx), %rdi
callq 0x775c
pushq $0x1
popq %rbx
jmp 0x7806
pushq $0x1
popq %rbx
leaq 0x60(%rsp), %rdi
callq 0x788c
movq %rsp, %rdi
callq 0x78c8
movl %ebx, %eax
addq $0x2f8, %rsp            # imm = 0x2F8
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rbx
jmp 0x7833
movq %rdx, %r14
movq %rax, %rbx
jmp 0x783b
movq %rdx, %r14
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x788c
movq %rsp, %rdi
callq 0x78c8
cmpl $0x1, %r14d
jne 0x7884
movq %rbx, %rdi
callq 0x7120
movq %rax, %rbx
movq 0x3774d(%rip), %rdi     # 0x3efa0
leaq 0x217bc(%rip), %rsi     # 0x29016
callq 0x72a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x72a0
movq %rax, %rdi
callq 0x7170
callq 0x74a0
jmp 0x77ec
movq %rax, %rbx
callq 0x74a0
movq %rbx, %rdi
callq 0x7510
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x945c
movl %eax, %ebp
testb %al, %al
jne 0x900f
addq $0x258, %r14            # imm = 0x258
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb206
xorb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x945c
testb %al, %al
je 0x908d
movq %rbx, 0x20(%rsp)
pushq $0x1
popq %rbp
leaq 0x28(%rsp), %r12
movq %rsp, %r13
movq %r12, %rdi
movl %ebp, %esi
callq 0x9a52
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x9a2e
movq %r15, %rdi
movq %r13, %rsi
callq 0x945c
movl %eax, %ebx
movq %r13, %rdi
callq 0x75c8
movq %r12, %rdi
callq 0x75c8
testb %bl, %bl
je 0x90a8
incl %ebp
jmp 0x9050
movq %r15, %rdi
movq %r14, %rsi
callq 0x8fe8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73e0
movq %rbx, %rax
jmp 0x910d
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9a52
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9a2e
movq %rsp, %rsi
movq %r15, %rdi
callq 0x8fe8
movq %rsp, %rdi
callq 0x75c8
leaq 0x28(%rsp), %rdi
callq 0x75c8
movq %rsp, %rbx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9a52
movq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9a2e
movq %rsp, %rdi
callq 0x75c8
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x913d
jmp 0x912d
jmp 0x9128
movq %rax, %rbx
jmp 0x9138
movq %rax, %rbx
movq %rsp, %rdi
callq 0x75c8
leaq 0x28(%rsp), %rdi
callq 0x75c8
movq %rbx, %rdi
callq 0x7510
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x240(%rdi)
je 0x9440
leaq 0x238(%r14), %r15
leaq 0x38(%r14), %rdi
leaq 0x1fd1e(%rip), %rsi     # 0x29137
callq 0x72a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x7280
movq %rax, %rdi
callq 0x7170
leaq 0x20c97(%rip), %rsi     # 0x2a0cf
movq %r15, %rdi
callq 0x7580
addq $0x38, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7280
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7170
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x1fca3(%rip), %rsi     # 0x2912e
movq %rsp, %r15
movq %r15, %rdi
callq 0x9980
movq %rbx, %rdi
movq %r15, %rsi
callq 0x93f2
movq %rsp, %rdi
callq 0x75c8
movl 0x290(%rbx), %eax
movl %r14d, %ecx
addl %r14d, %ecx
leal (%rax,%r14,2), %edx
subl %eax, %ecx
andl $0x3, %ecx
addl %edx, %ecx
movw %cx, 0x290(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x75c8
movq %rbx, %rdi
callq 0x7510
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/syntax.cpp
// Function: OperatorToken::maybeUnary()
bool OperatorToken::maybeUnary() {
  static std::vector<std::string> validOps = { "-", "*", "&", "~", "!", "+" };
  for (auto op : validOps) {
    if (_op == op) {
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r15
movb 0x3375a(%rip), %al      # 0x3f768
testb %al, %al
je 0xc070
movq 0x33737(%rip), %rax     # 0x3f750
movq 0x33738(%rip), %r12     # 0x3f758
addq $0x10, %r15
leaq 0x10(%rsp), %rbx
movq %rax, %r14
cmpq %r12, %rax
je 0xc05a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73e0
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb1d0
movl %eax, %ebp
movq %rbx, %rdi
callq 0x75c8
leaq 0x20(%r14), %rax
testb %bpl, %bpl
je 0xc029
cmpq %r12, %r14
setne %al
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x336f1(%rip), %rdi     # 0x3f768
callq 0x7530
testl %eax, %eax
je 0xc012
leaq 0x1d54d(%rip), %rsi     # 0x295d4
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x9502
leaq 0x30(%rsp), %r14
leaq 0x1d531(%rip), %rsi     # 0x295d6
leaq 0xe(%rsp), %rdx
movq %r14, %rdi
callq 0x9502
leaq 0x50(%rsp), %r14
leaq 0x1d528(%rip), %rsi     # 0x295e6
leaq 0xd(%rsp), %rdx
movq %r14, %rdi
callq 0x9502
leaq 0x70(%rsp), %r14
leaq 0x1d507(%rip), %rsi     # 0x295de
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x9502
leaq 0x90(%rsp), %r14
leaq 0x1d4ed(%rip), %rsi     # 0x295e0
leaq 0xb(%rsp), %rdx
movq %r14, %rdi
callq 0x9502
leaq 0xb0(%rsp), %r14
leaq 0x1d4c3(%rip), %rsi     # 0x295d2
leaq 0xa(%rsp), %rdx
movq %r14, %rdi
callq 0x9502
leaq 0x3362d(%rip), %rdi     # 0x3f750
leaq 0x10(%rsp), %rsi
pushq $0x6
popq %rdx
leaq 0x9(%rsp), %rcx
callq 0x182d4
movl $0xa0, %ebx
leaq (%rsp,%rbx), %rdi
addq $0x10, %rdi
callq 0x75c8
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0xc13a
leaq 0xc1b6(%rip), %rdi      # 0x1830e
leaq 0x335f1(%rip), %rsi     # 0x3f750
leaq 0x33182(%rip), %rdx     # 0x3f2e8
callq 0x7270
leaq 0x335f6(%rip), %rdi     # 0x3f768
callq 0x7200
jmp 0xc012
movq %rax, %r15
movl $0xa0, %r12d
leaq (%rsp,%r12), %rdi
addq $0x10, %rdi
callq 0x75c8
addq $-0x20, %r12
cmpq $-0x20, %r12
jne 0xc185
movb $0x1, %al
jmp 0xc1ad
jmp 0xc1a8
jmp 0xc1a8
jmp 0xc1a8
jmp 0xc1a8
movq %rax, %r15
xorl %eax, %eax
cmpq %r14, %rbx
sete %cl
orb %al, %cl
jne 0xc1cd
addq $-0x20, %r14
movq %r14, %rdi
callq 0x75c8
cmpq %rbx, %r14
jne 0xc1b7
jmp 0xc1cd
movq %rax, %r15
leaq 0x33594(%rip), %rdi     # 0x3f768
callq 0x71f0
movq %r15, %rdi
callq 0x7510
nop
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/syntax.cpp
// Function: OperatorToken::precedence() const
int OperatorToken::precedence() const {
  if ("[" == _op) {
    return 1;
  } else if (isUnary()) {
    return 2;
  } else if ("*" == _op || "/" == _op || "%" == _op) {
    return 3;
  } else if ("+" == _op || "-" == _op) {
    return 4;
  } else if ("<<" == _op || ">>" == _op) {
    return 5;
  } else if ("<" == _op || "<=" == _op || ">" == _op || ">=" == _op) {
    return 6;
  } else if ("==" == _op || "!=" == _op) {
    return 7;
  } else if ("&" == _op) {
    return 8;
  } else if ("^" == _op) {
    return 9;
  } else if ("|" == _op) {
    return 10;
  } else if ("&&" == _op) {
    return 11;
  } else if ("||" == _op) {
    return 12;
  } else if ("=" == _op) {
    return 13;
  }
  return -1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
leaq 0x1d400(%rip), %rdi     # 0x295f4
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
je 0xc207
pushq $0x1
jmp 0xc34d
cmpb $0x1, 0x30(%r14)
jne 0xc34b
leaq 0x1d3bd(%rip), %rdi     # 0x295d6
movq %rbx, %rsi
callq 0x97dd
pushq $0x3
popq %rbp
testb %al, %al
jne 0xc34e
leaq 0x1d3a5(%rip), %rdi     # 0x295d8
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
jne 0xc34e
leaq 0x1d390(%rip), %rdi     # 0x295da
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
jne 0xc34e
leaq 0x1d371(%rip), %rdi     # 0x295d2
movq %rbx, %rsi
callq 0x97dd
pushq $0x4
popq %rbp
testb %al, %al
jne 0xc34e
leaq 0x1d359(%rip), %rdi     # 0x295d4
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
jne 0xc34e
leaq 0x1d364(%rip), %rdi     # 0x295f6
movq %rbx, %rsi
callq 0x97dd
pushq $0x5
popq %rbp
testb %al, %al
jne 0xc34e
leaq 0x1d34d(%rip), %rdi     # 0x295f9
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
jne 0xc34e
leaq 0x1d334(%rip), %rdi     # 0x295f7
movq %rbx, %rsi
callq 0x97dd
pushq $0x6
popq %rbp
testb %al, %al
jne 0xc34e
leaq 0x1d30f(%rip), %rdi     # 0x295e8
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
jne 0xc34e
leaq 0x1d30e(%rip), %rdi     # 0x295fa
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
jne 0xc34e
leaq 0x1d2ec(%rip), %rdi     # 0x295eb
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
jne 0xc34e
leaq 0x1d2dc(%rip), %rdi     # 0x295ee
movq %rbx, %rsi
callq 0x97dd
pushq $0x7
popq %rbp
testb %al, %al
jne 0xc34e
leaq 0x1d2c9(%rip), %rdi     # 0x295f1
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
jne 0xc34e
leaq 0x1d2ab(%rip), %rdi     # 0x295e6
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
je 0xc355
pushq $0x8
jmp 0xc34d
pushq $0x2
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1d280(%rip), %rdi     # 0x295dc
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
je 0xc36c
pushq $0x9
jmp 0xc34d
leaq 0x1d270(%rip), %rdi     # 0x295e3
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
je 0xc383
pushq $0xa
jmp 0xc34d
leaq 0x1d25b(%rip), %rdi     # 0x295e5
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
je 0xc39a
pushq $0xb
jmp 0xc34d
leaq 0x1d241(%rip), %rdi     # 0x295e2
movq %rbx, %rsi
callq 0x97dd
testb %al, %al
je 0xc3b1
pushq $0xc
jmp 0xc34d
leaq 0x1d23a(%rip), %rdi     # 0x295f2
movq %rbx, %rsi
callq 0x97dd
movzbl %al, %ebp
decl %ebp
orl $0xd, %ebp
jmp 0xc34e
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/syntax.cpp
// Function: ExprToken::_flagNonRegs()
void ExprToken::_flagNonRegs() {
  std::stack<std::shared_ptr<Token>> operands;
  for (auto token : _postfix) {
    auto op = std::dynamic_pointer_cast<OperatorToken>(token);
    if (nullptr != op) {
      std::shared_ptr<Token> rhs = operands.top();
      operands.pop();
      if (op->isBinary()) {
        operands.pop();
      }
      // Check if it is an address-of operation
      if (op->isUnary() && "&" == op->str()) {
        auto var = std::dynamic_pointer_cast<Variable>(rhs);
        if (nullptr != var) {
          var->flagNonReg();
        }
      }
      // Push something back onto the stack.
      operands.push(nullptr);
    } else {
      operands.push(token);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x58(%rsp), %r12
movq %r12, %rdi
callq 0x18390
movq 0x10(%rbx), %rbp
movq 0x18(%rbx), %r13
leaq 0x28(%rsp), %r14
leaq 0x20(%rsp), %r15
leaq 0x30(%rsp), %rbx
cmpq %r13, %rbp
je 0x10c43
movq %r15, %rdi
movq %rbp, %rsi
callq 0x18b56
movq %rsp, %rdi
movq %r15, %rsi
callq 0x183d8
cmpq $0x0, (%rsp)
je 0x10c1d
movq 0x88(%rsp), %rsi
cmpq 0x90(%rsp), %rsi
jne 0x10b68
movq 0xa0(%rsp), %rax
movq -0x8(%rax), %rsi
movl $0x200, %eax            # imm = 0x200
addq %rax, %rsi
addq $-0x10, %rsi
leaq 0x10(%rsp), %rdi
callq 0x18b56
movq %r12, %rdi
callq 0x252f8
movq (%rsp), %rsi
movb 0x30(%rsi), %al
cmpb $0x1, %al
jne 0x10b98
movq %r12, %rdi
callq 0x252f8
movq (%rsp), %rsi
movb 0x30(%rsi), %al
testb $0x1, %al
jne 0x10bf4
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x73e0
leaq 0x18a37(%rip), %rdi     # 0x295e6
movq %rbx, %rsi
callq 0x97dd
movl %eax, %r14d
movq %rbx, %rdi
callq 0x75c8
testb %r14b, %r14b
leaq 0x28(%rsp), %r14
je 0x10bf4
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x18619
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x10bea
movb $0x0, 0x80(%rax)
leaq 0x38(%rsp), %rdi
callq 0x7a34
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x24fc4
leaq 0x38(%rsp), %rdi
callq 0x7a34
leaq 0x18(%rsp), %rdi
callq 0x7a34
jmp 0x10c28
movq %r12, %rdi
movq %r15, %rsi
callq 0x25628
leaq 0x8(%rsp), %rdi
callq 0x7a34
movq %r14, %rdi
callq 0x7a34
addq $0x10, %rbp
jmp 0x10b18
leaq 0x58(%rsp), %rdi
callq 0x18a04
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x10c76
movq %rax, %rbx
jmp 0x10c80
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x7a34
leaq 0x18(%rsp), %rdi
callq 0x7a34
leaq 0x8(%rsp), %rdi
callq 0x7a34
leaq 0x28(%rsp), %rdi
callq 0x7a34
leaq 0x58(%rsp), %rdi
callq 0x18a04
movq %rbx, %rdi
callq 0x7510
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/syntax.cpp
// Function: GlobalVarToken::output(Parser*)
void GlobalVarToken::output(Parser *parser) {
  // Write out a label for the global variable.
  parser->writeln(_name + ":");
  if (_type.isArray()) {
    // The address for the array's elements will be the current byte
    // position plus the instruction size.
    parser->writeData(toHexStr(parser->getBytePos() + INST_SIZE), 1);
    // Write out the array's elements as hex values.
    std::string dataOutput;
    for (size_t i = 0; i < _arrayValues.size(); i++) {
      dataOutput += toHexStr(_arrayValues[i]);
      if (i + 1 < _arrayValues.size()) {
        dataOutput += " ";
      }
    }
    parser->writeData(dataOutput, _arrayValues.size());
  } else {
    // Not an array, just write out the single hex value.
    parser->writeData(toHexStr(_value), 1);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70(%rdi), %rsi
leaq 0x18fa1(%rip), %rdx     # 0x2b630
movq %rsp, %r15
movq %r15, %rdi
callq 0x99f6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x93f2
movq %rsp, %rdi
callq 0x75c8
cmpb $0x1, 0x68(%r14)
jne 0x12772
movl 0x290(%rbx), %eax
addl $0x4, %eax
movzwl %ax, %esi
movq %rsp, %r15
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0x27ea7
pushq $0x1
popq %rdx
movq %rbx, 0x20(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9472
movq %rsp, %r15
movq %r15, %rdi
callq 0x75c8
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %ebx, %ebx
leaq 0x28(%rsp), %r12
pushq $0x4
popq %rbp
leaq 0x16a23(%rip), %r13     # 0x29135
movq 0x98(%r14), %rax
movq 0xa0(%r14), %rdx
subq %rax, %rdx
sarq %rdx
cmpq %rdx, %rbx
jae 0x12798
movzwl (%rax,%rbx,2), %esi
movq %r12, %rdi
movl %ebp, %edx
callq 0x27ea7
movq %r15, %rdi
movq %r12, %rsi
callq 0x75a0
movq %r12, %rdi
callq 0x75c8
incq %rbx
movq 0xa0(%r14), %rax
subq 0x98(%r14), %rax
sarq %rax
cmpq %rax, %rbx
jae 0x12712
movq %r15, %rdi
movq %r13, %rsi
callq 0x7570
jmp 0x12712
movzwl 0x92(%r14), %esi
movq %rsp, %r14
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x27ea7
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9472
jmp 0x127a5
movq %rsp, %rsi
movq 0x20(%rsp), %rdi
callq 0x9472
movq %rsp, %rdi
callq 0x75c8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x127c6
jmp 0x127c6
jmp 0x127c6
jmp 0x127c6
jmp 0x127c6
movq %rax, %rbx
jmp 0x127d8
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x75c8
movq %rsp, %rdi
callq 0x75c8
movq %rbx, %rdi
callq 0x7510
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rdi, (%rsp)
movq 0xa8(%rsi), %r12
movq 0xb0(%rsi), %r14
leaq 0x8(%rsp), %r13
leaq 0x18(%rsp), %rbp
cmpq %r14, %r12
je 0x14c21
movq %r13, %rdi
movq %r12, %rsi
callq 0x18ef4
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
movq %rbp, %rdi
callq 0x73e0
movq %r15, %rdi
movq %rbp, %rsi
callq 0xb1d0
movl %eax, %ebx
movq %rbp, %rdi
callq 0x75c8
testb %bl, %bl
jne 0x14c3b
leaq 0x10(%rsp), %rdi
callq 0x7a34
addq $0x10, %r12
jmp 0x14bd7
leaq 0x154a7(%rip), %rsi     # 0x2a0cf
leaq 0x18(%rsp), %rdx
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x9502
jmp 0x14c5a
movq 0x8(%rsp), %rsi
addq $0x30, %rsi
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x73e0
leaq 0x10(%rsp), %rdi
callq 0x7a34
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14c6e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7a34
movq %rbx, %rdi
callq 0x7510
nop
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/syntax.cpp
// Function: BreakStatement::parse(Tokenizer*, bool)
bool BreakStatement::parse(Tokenizer *tokenizer, bool inLoop) {
  _lineNum = tokenizer->peekNext().line();
  if (!_expect(tokenizer, "break")) {
    return false;
  } else if (!_expect(tokenizer, ";")) {
    return false;
  } else if (!inLoop) {
    _error("Must be within a loop statement to use 'break;'.", _lineNum);
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x279a6
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
movq %r15, %rdi
callq 0x7b20
leaq 0x14381(%rip), %rsi     # 0x29f16
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9502
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x286c3
movl %eax, %r15d
leaq 0x8(%rsp), %rdi
callq 0x75c8
testb %r15b, %r15b
je 0x15c30
leaq 0x13ff4(%rip), %rsi     # 0x29bc1
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9502
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x286c3
movl %eax, %r14d
leaq 0x8(%rsp), %rdi
callq 0x75c8
movl %r14d, %eax
xorb $0x1, %al
orb %bpl, %al
jne 0x15c33
leaq 0x14325(%rip), %rsi     # 0x29f2f
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9502
movl 0x8(%rbx), %esi
leaq 0x8(%rsp), %rdi
callq 0x285f3
leaq 0x8(%rsp), %rdi
callq 0x75c8
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15c49
jmp 0x15c58
jmp 0x15c49
jmp 0x15c58
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x75c8
jmp 0x15c5b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7510
nop
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/syntax.cpp
// Function: ContinueStatement::parse(Tokenizer*, bool)
bool ContinueStatement::parse(Tokenizer *tokenizer, bool inLoop) {
  _lineNum = tokenizer->peekNext().line();
  if (!_expect(tokenizer, "continue")) {
    return false;
  } else if (!_expect(tokenizer, ";")) {
    return false;
  } else if (!inLoop) {
    _error("Must be within a loop statement to use 'continue;'.", _lineNum);
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x279a6
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
movq %r15, %rdi
callq 0x7b20
leaq 0x1428d(%rip), %rsi     # 0x29f26
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9502
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x286c3
movl %eax, %r15d
leaq 0x8(%rsp), %rdi
callq 0x75c8
testb %r15b, %r15b
je 0x15d34
leaq 0x13ef0(%rip), %rsi     # 0x29bc1
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9502
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x286c3
movl %eax, %r14d
leaq 0x8(%rsp), %rdi
callq 0x75c8
movl %r14d, %eax
xorb $0x1, %al
orb %bpl, %al
jne 0x15d37
leaq 0x14252(%rip), %rsi     # 0x29f60
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x9502
movl 0x8(%rbx), %esi
leaq 0x8(%rsp), %rdi
callq 0x285f3
leaq 0x8(%rsp), %rdi
callq 0x75c8
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15d4d
jmp 0x15d5c
jmp 0x15d4d
jmp 0x15d5c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x75c8
jmp 0x15d5f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7510
nop
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/syntax.cpp
// Function: GotoStatement::parse(Tokenizer*)
bool GotoStatement::parse(Tokenizer *tokenizer) {
  _lineNum = tokenizer->peekNext().line();
  // Make sure the first token is the "goto" keyword.
  if (!_expect(tokenizer, "goto")) {
    return false;
  }
  // Get the label.
  AtomToken labelToken = tokenizer->getNext();
  if (labelToken.str().empty()) {
    _error("Unexpected EOF.", labelToken.line());
    return false;
  } else if (!isValidName(labelToken.str())) {
    _error("Invalid label name in goto statement.", labelToken.line());
    return false;
  }
  _label = labelToken.str();
  // Get the trailing ";" token.
  if (!_expect(tokenizer, ";")) {
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x279a6
movl 0x8(%r15), %eax
movl %eax, 0x8(%r14)
movq %r15, %rdi
callq 0x7b20
leaq 0x13dbe(%rip), %rsi     # 0x29dc2
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x9502
leaq 0x30(%rsp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x286c3
movl %eax, %ebp
leaq 0x30(%rsp), %rdi
callq 0x75c8
testb %bpl, %bpl
je 0x160f7
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x2772c
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x73e0
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %r12
callq 0x75c8
testq %r12, %r12
je 0x160fb
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x73e0
leaq 0x10(%rsp), %rdi
callq 0x2804b
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x75c8
testb %bpl, %bpl
je 0x16121
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x73e0
addq $0x10, %r14
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7360
movq %r15, %rdi
callq 0x75c8
leaq 0x13af7(%rip), %rsi     # 0x29bc1
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x9502
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x286c3
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x75c8
jmp 0x16151
xorl %ebx, %ebx
jmp 0x1615b
leaq 0x138d5(%rip), %rsi     # 0x299d7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x9502
movl 0x38(%rsp), %esi
leaq 0x10(%rsp), %rdi
callq 0x285f3
jmp 0x16145
leaq 0x13ef1(%rip), %rsi     # 0x2a019
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x9502
movl 0x38(%rsp), %esi
leaq 0x10(%rsp), %rdi
callq 0x285f3
leaq 0x10(%rsp), %rdi
callq 0x75c8
xorl %ebx, %ebx
leaq 0x30(%rsp), %rdi
callq 0x7b20
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16178
jmp 0x16178
jmp 0x16189
jmp 0x16189
jmp 0x16189
jmp 0x16178
jmp 0x16189
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x75c8
jmp 0x1618c
jmp 0x16189
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x7b20
jmp 0x161aa
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x75c8
jmp 0x161aa
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7510
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/syntax.cpp
// Function: LabelStatement::parse(Tokenizer*)
bool LabelStatement::parse(Tokenizer *tokenizer) {
  _lineNum = tokenizer->peekNext().line();
  // Make sure it is a valid label declaration.
  AtomToken t = tokenizer->getNext();
  if (t.str().empty()) {
    _error("Unexpected EOF.", t.line());
    return false;
  } else if (!isLabelDeclaration(t.str())) {
    _error("Invalid label declaration.", t.line());
    return false;
  }
  // Name is the label declaration minus the trailing colon.
  _name = t.str().substr(0, t.str().size() - 1);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x279a6
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
movq %r15, %rdi
callq 0x7b20
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x2772c
leaq 0x58(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x73e0
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %r15
callq 0x75c8
testq %r15, %r15
je 0x162ad
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x73e0
leaq 0x8(%rsp), %rdi
callq 0x280a4
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x75c8
testb %bpl, %bpl
je 0x162d3
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x73e0
leaq 0x78(%rsp), %rdi
movq %r14, %rsi
callq 0x73e0
movq 0x80(%rsp), %rcx
decq %rcx
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x72f0
addq $0x10, %rbx
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7360
movq %r14, %rdi
callq 0x75c8
leaq 0x78(%rsp), %rdi
callq 0x75c8
leaq 0x28(%rsp), %rdi
callq 0x75c8
movb $0x1, %bl
jmp 0x16303
leaq 0x13723(%rip), %rsi     # 0x299d7
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x9502
movl 0x50(%rsp), %esi
leaq 0x8(%rsp), %rdi
callq 0x285f3
jmp 0x162f7
leaq 0x13d24(%rip), %rsi     # 0x29ffe
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x9502
movl 0x50(%rsp), %esi
leaq 0x8(%rsp), %rdi
callq 0x285f3
leaq 0x8(%rsp), %rdi
callq 0x75c8
xorl %ebx, %ebx
leaq 0x48(%rsp), %rdi
callq 0x7b20
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x75c8
jmp 0x16331
jmp 0x16340
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x16348
jmp 0x16351
jmp 0x16351
jmp 0x16340
jmp 0x16351
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x75c8
jmp 0x16354
jmp 0x16351
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x7b20
movq %rbx, %rdi
callq 0x7510