LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/driver.cc
// Function: readAreaLight(std::istream&)
sp_arealightd readAreaLight(istream &is) {
	rgbcolord color;
	vector3d center, normal, upDir;
	double hspace, vspace, width, height;
	cin >> color >> center >> normal >> upDir >> hspace >> vspace >> width
		>> height;
	sp_arealightd x(new arealightd(
			color, center, normal, upDir, hspace, vspace, width, height));
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, -0x30(%rbp)
xorl %eax, %eax
leaq -0xd0(%rbp), %rcx
movq %rax, 0x10(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
movq %rcx, %rsi
leaq -0xb0(%rbp), %rbx
movq %rax, 0x10(%rbx)
movaps %xmm0, (%rbx)
leaq -0x90(%rbp), %r14
movq %rax, 0x10(%r14)
movaps %xmm0, (%r14)
leaq -0x70(%rbp), %r15
movq %rax, 0x10(%r15)
movaps %xmm0, (%r15)
movq 0xa66a(%rip), %rdi      # 0xdfd8
callq 0x45f7
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4501
movq %rax, %rdi
movq %r14, %rsi
callq 0x4501
movq %rax, %rdi
movq %r15, %rsi
callq 0x4501
leaq -0x50(%rbp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3100
leaq -0x48(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x3100
leaq -0x40(%rbp), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x3100
leaq -0x38(%rbp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x3100
movl $0xb8, %edi
callq 0x31c0
movq %rax, %r14
movsd (%rbx), %xmm0
movsd (%r15), %xmm1
movsd (%r12), %xmm2
movsd (%r13), %xmm3
movq %rax, %rdi
leaq -0xd0(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
leaq -0x90(%rbp), %rcx
leaq -0x70(%rbp), %r8
callq 0x4e74
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5010
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0xb8, %esi
movq %r14, %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/driver.cc
// Function: readCamera(std::istream&)
sp_camerad readCamera(istream &is) {
	vector3d vec1;
	vector3d vec2;
	vector3d vec3;
	cin >> vec1 >> vec2 >> vec3;
	sp_camerad x(new camerad(vec1, vec2, vec3));
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq -0x80(%rbp), %r14
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq -0x60(%rbp), %r15
movq %rax, 0x10(%r15)
movaps %xmm0, (%r15)
leaq -0x40(%rbp), %r12
movq %rax, 0x10(%r12)
movaps %xmm0, (%r12)
movq 0xa543(%rip), %rdi      # 0xdfd8
movq %r14, %rsi
callq 0x4501
movq %rax, %rdi
movq %r15, %rsi
callq 0x4501
movq %rax, %rdi
movq %r12, %rsi
callq 0x4501
movl $0x70, %edi
callq 0x31c0
movq %rax, %r13
movsd 0x5550(%rip), %xmm0     # 0x9018
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x5068
movq %rbx, %rdi
movq %r13, %rsi
callq 0x522c
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x70, %esi
movq %r13, %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/driver.cc
// Function: usage(char*)
void usage(char *progname) {
	cout << "---> Usage: " << progname
			<< ": <width in pixels> <height in pixels> -s" << endl;
	cout << "---> -s is for shadows and must be the last argument." << endl;
	cout << "---> It's intended for scene descriptions to be sent in with"
			<< " redirection like: " << endl
			<< "       " << progname << " 640 480 < inputfile.dat" << endl;
	cout << "---> See example.dat for the scene description format."
			<< endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xa4a6(%rip), %rbx      # 0xdfc8
leaq 0x55f4(%rip), %rsi      # 0x911d
movl $0xc, %edx
movq %rbx, %rdi
callq 0x31f0
testq %r14, %r14
je 0x3b57
movq %r14, %rdi
callq 0x30b0
movq 0xa47e(%rip), %rdi      # 0xdfc8
movq %r14, %rsi
movq %rax, %rdx
callq 0x31f0
jmp 0x3b6e
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x3280
leaq 0x55b5(%rip), %rsi      # 0x912a
movl $0x29, %edx
movq %rbx, %rdi
callq 0x31f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
leaq 0x55a4(%rip), %rsi      # 0x9154
movl $0x35, %edx
movq %rbx, %rdi
callq 0x31f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
leaq 0x559f(%rip), %rsi      # 0x918a
movl $0x3c, %edx
movq %rbx, %rdi
callq 0x31f0
leaq 0x55c8(%rip), %rsi      # 0x91c7
movl $0x13, %edx
movq %rbx, %rdi
callq 0x31f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
movq %rax, %r15
leaq 0x559e(%rip), %rsi      # 0x91db
movl $0x7, %edx
movq %rax, %rdi
callq 0x31f0
testq %r14, %r14
je 0x3c67
movq %r14, %rdi
callq 0x30b0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x31f0
jmp 0x3c81
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x3280
leaq 0x555b(%rip), %rsi      # 0x91e3
movl $0x18, %edx
movq %r15, %rdi
callq 0x31f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
leaq 0x5539(%rip), %rsi      # 0x91fc
movl $0x36, %edx
movq %rbx, %rdi
callq 0x31f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3110
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/mvector.hh
// Function: std::istream& operator>><double, 3>(std::istream&, mvector<double, 3>&)
std::istream & operator>>(std::istream& is, mvector<T, size> &v) {

	if(!is) { // If not ready...
		return is; // ...already failed, just return.
	}

	// Configure istream to throw an exception if the failbit gets set below.
	is.exceptions(std::ios_base::failbit);

	// Otherwise get the first char.
	char c;
	is >> c;
	if (c == '<') { // If it's the start of a vector, then...

		assert(size > 0);
		int i = 0;
		do {
			is >> v[i] >> c;
			if (c != ',') { // If wasn't a comma after coordinate, bad format.
				is.clear(std::ios_base::failbit);
			}
			i++;
		} while (i < size - 1);

		// When we reach here we have one coordinate left to read.
		assert(i == size - 1);
		is >> v[size - 1] >> c;
		if (c != '>') { // If no closing bracket, then bad format.
			is.clear(std::ios_base::failbit);
		}

	}
	else { // If first char wasn't <, put it back into the stream and return.
		is.putback(c);
		return is;
	}

	return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rdi
movl 0x20(%rbx,%rdi), %esi
testb $0x5, %sil
jne 0x45e7
addq %rbx, %rdi
movl $0x4, 0x1c(%rdi)
callq 0x3280
leaq -0x21(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3210
movb (%r15), %al
cmpb $0x3c, %al
jne 0x45dc
xorl %esi, %esi
movb $0x1, %r12b
movq %r14, %rdi
callq 0x4bca
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3100
movq %rax, %rdi
movq %r15, %rsi
callq 0x3210
cmpb $0x2c, -0x21(%rbp)
je 0x4591
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0x4, %esi
callq 0x3280
movl $0x1, %esi
testb $0x1, %r12b
movl $0x0, %r12d
jne 0x4559
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3100
leaq -0x21(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3210
cmpb $0x3e, (%r14)
je 0x45e7
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0x4, %esi
callq 0x3280
jmp 0x45e7
movsbl %al, %esi
movq %rbx, %rdi
callq 0x32d0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3>::operator-(mvector<double, 3> const&) const
const mvector<T, size> operator-(const mvector<T, size> &rhs) const {
		mvector tmp = *this;
		for (int i = 0; i < size; i++)
			tmp[i] -= rhs[i];
		return tmp;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x5b6e
movsd %xmm0, (%r14,%r12,8)
incq %r12
cmpq $0x3, %r12
jne 0x4c39
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5b6e
movsd %xmm0, -0x28(%rbp)
movq %r14, %rdi
movl %r15d, %esi
callq 0x4bca
movsd (%rax), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
incl %r15d
cmpl $0x3, %r15d
jne 0x4c56
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3>::norm() const
mvector<T, size> norm() const {
    	mvector vec(*this);
    	T magnitude = mag();
    	for (int i = 0; i < size; i++)
    		vec[i] /= magnitude;
    	return vec;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5b6e
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq $0x3, %r15
jne 0x4cab
xorpd %xmm1, %xmm1
xorl %r15d, %r15d
movsd %xmm1, -0x20(%rbp)
movq %r14, %rdi
movl %r15d, %esi
callq 0x5b6e
movsd -0x20(%rbp), %xmm1
mulsd (%r14,%r15,8), %xmm0
addsd %xmm0, %xmm1
incq %r15
cmpq $0x3, %r15
jne 0x4ccc
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x4d07
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x4d10
movapd %xmm1, %xmm0
callq 0x3170
xorl %r14d, %r14d
movsd %xmm0, -0x20(%rbp)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4bca
movsd -0x20(%rbp), %xmm0
movsd (%rax), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax)
incl %r14d
cmpl $0x3, %r14d
jne 0x4d18
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/arealight.hh
// Function: arealight<double, double, double, 3>::arealight(rgbcolor<double> const&, mvector<double, 3> const&, mvector<double, 3> const&, mvector<double, 3> const&, double, double, double, double)
arealight(const rgbcolor<color_T> &color, const mvector<vec_T, dim> &center,
			const mvector<vec_T, dim> &surfaceNormal,
			const mvector<vec_T, dim> &upDirection,
			vec_T horizontalSpacing, vec_T verticalSpacing,
			vec_T width, vec_T height) :
				light<vec_T, color_T, time_T, dim>(color, center),
				norm(surfaceNormal.norm()),
				horizontalSpacing(horizontalSpacing),
				verticalSpacing(verticalSpacing),
				width(width), height(height) {

		// After the initializer list ends we still need to deal with
		// vhat, uhat, and the lights collection.
		assert(dim > 0);
		assert(horizontalSpacing > 0);
		assert(verticalSpacing > 0);
		assert(horizontalSpacing < width);
		assert(verticalSpacing < height);

		constructorHelper(upDirection);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm3, -0x48(%rbp)
movsd %xmm2, -0x38(%rbp)
movsd %xmm1, -0x40(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movupd (%rsi), %xmm0
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rdi)
movupd %xmm0, 0x8(%rdi)
leaq 0x8c9b(%rip), %rax      # 0xdb58
movq %rax, (%rdi)
xorl %r13d, %r13d
movq %r12, %rdi
movl %r13d, %esi
callq 0x5b6e
movsd %xmm0, 0x20(%rbx,%r13,8)
incq %r13
cmpq $0x3, %r13
jne 0x4ec3
leaq 0x8dc3(%rip), %rax      # 0xdca8
movq %rax, (%rbx)
leaq 0x38(%rbx), %rdi
movq %r15, %rsi
callq 0x4c98
movsd -0x30(%rbp), %xmm5
movsd %xmm5, 0x50(%rbx)
movsd -0x40(%rbp), %xmm3
movsd %xmm3, 0x58(%rbx)
movsd -0x38(%rbp), %xmm4
movsd %xmm4, 0x60(%rbx)
movsd -0x48(%rbp), %xmm2
movsd %xmm2, 0x68(%rbx)
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm5
xorps %xmm1, %xmm1
movups %xmm1, 0x70(%rbx)
movups %xmm1, 0x80(%rbx)
movups %xmm1, 0x90(%rbx)
movups %xmm1, 0xa0(%rbx)
movq $0x0, 0xb0(%rbx)
jbe 0x4f79
ucomisd %xmm0, %xmm3
jbe 0x4f98
ucomisd %xmm5, %xmm4
jbe 0x4fb7
ucomisd %xmm3, %xmm2
jbe 0x4fd6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6b2a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x49cb(%rip), %rdi      # 0x994b
leaq 0x49da(%rip), %rsi      # 0x9961
leaq 0x49e4(%rip), %rcx      # 0x9972
movl $0xb5, %edx
callq 0x30f0
leaq 0x4ace(%rip), %rdi      # 0x9a6d
leaq 0x49bb(%rip), %rsi      # 0x9961
leaq 0x49c5(%rip), %rcx      # 0x9972
movl $0xb6, %edx
callq 0x30f0
leaq 0x4ac3(%rip), %rdi      # 0x9a81
leaq 0x499c(%rip), %rsi      # 0x9961
leaq 0x49a6(%rip), %rcx      # 0x9972
movl $0xb7, %edx
callq 0x30f0
leaq 0x4abe(%rip), %rdi      # 0x9a9b
leaq 0x497d(%rip), %rsi      # 0x9961
leaq 0x4987(%rip), %rcx      # 0x9972
movl $0xb8, %edx
callq 0x30f0
movq %rax, %r14
addq $0xa0, %rbx
movq %rbx, %rdi
callq 0x58f8
movq %r14, %rdi
callq 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/camera.hh
// Function: camera<double, double, 3>::camera(mvector<double, 3> const&, mvector<double, 3> const&, mvector<double, 3> const&, double)
camera(const mvector<vec_T, dim> &position,
			const mvector<vec_T, dim> &lookAt,
			const mvector<vec_T, dim> &upDir,
			vec_T fieldOfView = M_PI / 3) : pos(position), fov(fieldOfView) {
		dir = (lookAt - pos).norm();
		right = (dir % upDir).norm();
		up = (right % dir).norm();
		dist = 0.5 / tan((double)fov / 2);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, -0x30(%rbp)
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
xorl %r13d, %r13d
movq %r15, %rdi
movl %r13d, %esi
callq 0x5b6e
movsd %xmm0, (%rbx,%r13,8)
incq %r13
cmpq $0x3, %r13
jne 0x508d
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq $0x0, 0x28(%rbx)
movsd -0x30(%rbp), %xmm1
movsd %xmm1, 0x30(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x4c1e
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4c98
movq 0x10(%r12), %rax
movq %rax, 0x28(%rbx)
movups (%r12), %xmm0
movups %xmm0, 0x18(%rbx)
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movsd 0x20(%rbx), %xmm2
movsd 0x28(%rbx), %xmm3
movapd %xmm0, %xmm4
mulsd %xmm3, %xmm4
movapd %xmm2, %xmm5
mulsd %xmm1, %xmm5
subsd %xmm4, %xmm5
movsd %xmm5, (%r15)
movsd 0x18(%rbx), %xmm4
movsd (%r14), %xmm5
mulsd %xmm5, %xmm3
mulsd %xmm4, %xmm1
subsd %xmm1, %xmm3
movsd %xmm3, 0x8(%r15)
mulsd %xmm2, %xmm5
mulsd %xmm0, %xmm4
subsd %xmm5, %xmm4
movsd %xmm4, 0x10(%r15)
leaq -0x60(%rbp), %r15
leaq -0x48(%rbp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x4c98
movq 0x10(%r15), %rax
movq %rax, 0x60(%rbx)
movups (%r15), %xmm0
movups %xmm0, 0x50(%rbx)
movsd 0x58(%rbx), %xmm0
movsd 0x20(%rbx), %xmm1
movsd 0x28(%rbx), %xmm2
movsd 0x60(%rbx), %xmm3
movapd %xmm1, %xmm4
mulsd %xmm3, %xmm4
movapd %xmm0, %xmm5
mulsd %xmm2, %xmm5
subsd %xmm4, %xmm5
movsd %xmm5, (%r14)
movsd 0x18(%rbx), %xmm4
movsd 0x50(%rbx), %xmm5
mulsd %xmm4, %xmm3
mulsd %xmm5, %xmm2
subsd %xmm2, %xmm3
movsd %xmm3, 0x8(%r14)
mulsd %xmm0, %xmm4
mulsd %xmm1, %xmm5
subsd %xmm4, %xmm5
movsd %xmm5, 0x10(%r14)
leaq -0x60(%rbp), %r14
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x4c98
movq 0x10(%r14), %rax
movq %rax, 0x48(%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x38(%rbx)
movsd 0x30(%rbx), %xmm0
mulsd 0x3e19(%rip), %xmm0     # 0x9020
callq 0x30e0
movsd 0x3e0c(%rip), %xmm1     # 0x9020
divsd %xmm0, %xmm1
movsd %xmm1, 0x68(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/scene.hh
// Function: scene<double, double, double, 3>::addAreaLight(boost::shared_ptr<arealight<double, double, double, 3>>)
void addAreaLight(sp_arealight theLight) {
		assert(theLight != 0);
		typename std::vector<boost::shared_ptr<
			light<vec_T, color_T, time_T, dim> > >::const_iterator iter;
		for(iter = theLight->getLights().begin();
				iter < theLight->getLights().end(); iter++) {
			addPointLight(*iter);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %rax
testq %rax, %rax
je 0x54c1
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa0(%rax), %r13
leaq -0x30(%rbp), %r15
leaq -0x38(%rbp), %r12
cmpq 0xa8(%rax), %r13
jae 0x54b2
movq (%r13), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%r13), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x5474
lock
incl 0x8(%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x53c0
movq %r15, %rdi
callq 0x576e
addq $0x10, %r13
movq (%rbx), %rax
testq %rax, %rax
jne 0x5452
leaq 0x46e9(%rip), %rdi      # 0x9b83
leaq 0x46ea(%rip), %rsi      # 0x9b8b
leaq 0x49ec(%rip), %rcx      # 0x9e94
movl $0x2d8, %edx            # imm = 0x2D8
callq 0x30f0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4844(%rip), %rdi      # 0x9d0c
leaq 0x47b9(%rip), %rsi      # 0x9c88
leaq 0x493f(%rip), %rcx      # 0x9e15
movl $0x9f, %edx
callq 0x30f0
movq %rax, %rbx
movq %r15, %rdi
callq 0x576e
movq %rbx, %rdi
callq 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3>::print(std::ostream&) const
void print(std::ostream &os) const {
    	int i = 0;
    	os << "<";
    	do {
    		os << v[i];
    		if (i + 1 != size)
    			os << ", ";
    	} while (++i < size);
    	os << ">";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x39ce(%rip), %rsi      # 0x95a8
movl $0x1, %edx
movq %rbx, %rdi
callq 0x31f0
movsd (%r14), %xmm0
movq %rbx, %rdi
callq 0x3260
xorl %r12d, %r12d
leaq 0x390c(%rip), %r15      # 0x950a
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31f0
movsd 0x8(%r14,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x3260
incq %r12
cmpq $0x2, %r12
jne 0x5bfe
leaq 0x397d(%rip), %rsi      # 0x95aa
movl $0x1, %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3> const operator*<double, 3>(mvector<double, 3> const&, double)
const mvector<T, size> operator*(const mvector<T, size> &lhs, T scalar) {
	mvector<T, size> tmp = lhs;
	for (int i = 0; i < lhs.dim(); i++)
		tmp[i] *= scalar;
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, -0x20(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5b6e
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq $0x3, %r15
jne 0x65bb
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4bca
movsd (%rax), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
incl %r14d
cmpl $0x3, %r14d
jne 0x65d8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/infplane.hh
// Function: infplane<double, double, double, 3>::intersection(ray<double, double, 3> const&) const
time_T intersection(const ray<vec_T, time_T, dim> &r) const {
		vec_T denom = r.getDir() * surfNorm;
		if (denom == 0)
			return RAY_MISS;
		time_T t= (time_T) (-(r.getOrig() * surfNorm + dist) / denom);
		if (t < 0)
			return RAY_MISS;
		return t;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
movsd %xmm0, -0x28(%rbp)
movq %r15, %rdi
movl %r12d, %esi
callq 0x5b6e
mulsd 0x18(%r14,%r12,8), %xmm0
movsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
incq %r12
cmpq $0x3, %r12
jne 0x675e
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x67a7
jp 0x67a7
movsd 0x289b(%rip), %xmm0     # 0x9040
jmp 0x6805
xorl %r12d, %r12d
movapd %xmm2, -0x40(%rbp)
movq %r15, %rdi
movl %r12d, %esi
callq 0x5b6e
movapd -0x40(%rbp), %xmm2
mulsd (%r14,%r12,8), %xmm0
addsd %xmm0, %xmm2
incq %r12
cmpq $0x3, %r12
jne 0x67aa
addsd 0x28(%rbx), %xmm2
xorpd 0x28b1(%rip), %xmm2     # 0x9090
divsd -0x28(%rbp), %xmm2
xorpd %xmm0, %xmm0
movapd %xmm2, %xmm1
cmpltsd %xmm0, %xmm1
movsd 0x2847(%rip), %xmm0     # 0x9040
andpd %xmm1, %xmm0
andnpd %xmm2, %xmm1
orpd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/camera.hh
// Function: camera<double, double, 3>::getRayForPixel(int, int, int, int) const
ray<vec_T, time_T, dim> getRayForPixel(int x, int y,
			int width, int height) const {
		assert(x >= 0);
		assert(y >= 0);
		assert(width > 0);
		assert(height > 0);
		vec_T centerx = ((vec_T) width) / height / 2;
	    mvector<vec_T, dim> pixelDir = dist * dir +
	    		(0.5 - (vec_T) y / (vec_T) (height - 1)) * up +
				((vec_T) x / (vec_T) (height - 1) - centerx) * right;

	    ray<vec_T, time_T, dim> pixelRay(pos, pixelDir);
	    return pixelRay;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
testl %edx, %edx
js 0x7f39
movl %ecx, %r13d
testl %ecx, %ecx
js 0x7f58
testl %r8d, %r8d
jle 0x7f77
movl %r9d, %r12d
testl %r9d, %r9d
jle 0x7f96
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cvtsi2sd %r8d, %xmm1
cvtsi2sd %r12d, %xmm0
divsd %xmm0, %xmm1
mulsd 0x11b3(%rip), %xmm1     # 0x9020
movsd %xmm1, -0x38(%rbp)
movsd 0x68(%rsi), %xmm0
addq $0x18, %rsi
leaq -0x50(%rbp), %rdi
callq 0x87bc
cvtsi2sd %r13d, %xmm2
decl %r12d
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
movsd %xmm0, -0x30(%rbp)
divsd %xmm0, %xmm2
movsd 0x117b(%rip), %xmm0     # 0x9020
subsd %xmm2, %xmm0
leaq 0x38(%r14), %rsi
leaq -0x80(%rbp), %r12
movq %r12, %rdi
callq 0x87bc
leaq -0x98(%rbp), %r13
movq %r13, %rdi
leaq -0x50(%rbp), %rsi
movq %r12, %rdx
callq 0x652a
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
divsd -0x30(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
leaq 0x50(%r14), %rsi
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x87bc
leaq -0xb0(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x652a
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rdi
addq $0x18, %rdi
movq %r12, %rsi
callq 0x4c98
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15ee(%rip), %rdi      # 0x952e
leaq 0x1ffa(%rip), %rsi      # 0x9f41
leaq 0x2001(%rip), %rcx      # 0x9f4f
movl $0x6a, %edx
callq 0x30f0
leaq 0x2077(%rip), %rdi      # 0x9fd6
leaq 0x1fdb(%rip), %rsi      # 0x9f41
leaq 0x1fe2(%rip), %rcx      # 0x9f4f
movl $0x6b, %edx
callq 0x30f0
leaq 0x205f(%rip), %rdi      # 0x9fdd
leaq 0x1fbc(%rip), %rsi      # 0x9f41
leaq 0x1fc3(%rip), %rcx      # 0x9f4f
movl $0x6c, %edx
callq 0x30f0
leaq 0x160f(%rip), %rdi      # 0x95ac
leaq 0x1f9d(%rip), %rsi      # 0x9f41
leaq 0x1fa4(%rip), %rcx      # 0x9f4f
movl $0x6d, %edx
callq 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3> const operator*<double, 3>(double, mvector<double, 3> const&)
const mvector<T, size> operator*(T scalar, const mvector<T, size> &rhs) {
	mvector<T, size> tmp = rhs;
	for (int i = 0; i < rhs.dim(); i++)
		tmp[i] *= scalar;
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movsd %xmm0, -0x20(%rbp)
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5b6e
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq $0x3, %r15
jne 0x87d4
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4bca
movsd (%rax), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
incl %r14d
cmpl $0x3, %r14d
jne 0x87f1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/scene.hh
// Function: scene<double, double, double, 3>::findClosestShape(ray<double, double, 3> const&, double&) const
sp_shape findClosestShape(
			const ray<vec_T, time_T, dim> &r, time_T &tIntersect) const {
		time_T t = RAY_MISS;
		tIntersect = RAY_MISS;
		sp_shape intersectedObjPtr, tmpPtr;
		typename std::vector<sp_shape>::const_iterator iter;
		for (iter = shapes.begin(); iter < shapes.end(); iter++) {
			tmpPtr = *iter;
			t = tmpPtr->intersection(r);
			if (t != RAY_MISS && t > 0) {
				if (tIntersect == RAY_MISS) { // tIntersect starts at RAY_MISS
					tIntersect = t;
					intersectedObjPtr = tmpPtr;
				}
				else if (t < tIntersect) {
					intersectedObjPtr = tmpPtr;
					tIntersect = t;
				}
			}
		}
		return intersectedObjPtr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, -0x80(%rbp)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, (%rcx)
xorpd %xmm0, %xmm0
movq %rdi, -0x48(%rbp)
movupd %xmm0, (%rdi)
movapd %xmm0, -0x40(%rbp)
movq 0x30(%rsi), %r13
movq %rsi, -0x78(%rbp)
cmpq 0x38(%rsi), %r13
jae 0x898b
movq %rcx, %rbx
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
xorl %r15d, %r15d
xorl %r14d, %r14d
movq %rcx, -0x60(%rbp)
movq (%r13), %rax
movq 0x8(%r13), %rcx
testq %rcx, %rcx
je 0x888f
lock
incl 0x8(%rcx)
movapd -0x40(%rbp), %xmm0
movupd %xmm0, -0x58(%rbp)
movq %rax, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x576e
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x89a7
movq (%rdi), %rax
movq -0x80(%rbp), %rsi
callq *0x20(%rax)
ucomisd 0x777(%rip), %xmm0      # 0x9040
jne 0x88d1
jnp 0x8969
ucomisd 0x787(%rip), %xmm0      # 0x9060
jbe 0x8969
movsd (%rbx), %xmm1
ucomisd 0x755(%rip), %xmm1      # 0x9040
jne 0x8922
jp 0x8922
movsd %xmm0, (%rbx)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %rbx
testq %rbx, %rbx
je 0x8904
lock
incl 0x8(%rbx)
movq %r14, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq %r12, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x576e
jmp 0x896f
ucomisd %xmm0, %xmm1
jbe 0x8969
movsd %xmm0, -0x70(%rbp)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %rbx
testq %rbx, %rbx
je 0x893e
lock
incl 0x8(%rbx)
movq %r14, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq %r12, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x576e
movq -0x60(%rbp), %rax
movsd -0x70(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x896f
movq %r15, %rbx
movq %r14, %r12
addq $0x10, %r13
movq %rbx, %r15
movq %r12, %r14
movq -0x78(%rbp), %rax
cmpq 0x38(%rax), %r13
movq -0x60(%rbp), %rbx
jb 0x887e
leaq -0x38(%rbp), %rdi
callq 0x576e
movq -0x48(%rbp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11d5(%rip), %rdi      # 0x9b83
leaq 0x11d6(%rip), %rsi      # 0x9b8b
leaq 0x16ae(%rip), %rcx      # 0xa06a
movl $0x2d8, %edx            # imm = 0x2D8
callq 0x30f0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x576e
movq -0x68(%rbp), %rdi
callq 0x576e
movq %rbx, %rdi
callq 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3>::operator-() const
const mvector<T, size> operator-() const {
		mvector tmp = *this;
		for (int i = 0; i < size; i++)
			tmp[i] *= -1;
		return tmp;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5b6e
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq $0x3, %r15
jne 0x8a5f
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4bca
movsd (%rax), %xmm0
xorps 0x5fe(%rip), %xmm0      # 0x9090
movlps %xmm0, (%rax)
incl %r14d
cmpl $0x3, %r14d
jne 0x8a7c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::ora_indirect_x(NES::MemoryUnit&)
void CPU::ora_indirect_x(MemoryUnit &r) {
    // Bitwise OR with Accumulator: Indirect Reg-X addressing
    // PC += 2

    instPtr++;
    uint16_t alpha = regX, beta = r.getByteAt(instPtr);
    instPtr++;
    uint8_t addr = ((alpha+beta)&0xFF);
    uint8_t kapa = r.getByteAt(addr), napa = r.getByteAt(addr+1);
    uint16_t finalAddr = (kapa | (napa << 8));
    regAcc = regAcc|r.getByteAt(finalAddr);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movb 0x1(%rdi), %r15b
movl $0xffff, %r13d          # imm = 0xFFFF
andl %r13d, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
addb %r15b, %al
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5bd4
movl %eax, %r12d
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5bd4
movzbl %r12b, %ecx
movzbl %al, %esi
shll $0x8, %esi
orl %ecx, %esi
movb (%rbx), %r15b
andl %r13d, %esi
movq %r14, %rdi
callq 0x5bd4
orb %r15b, %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x278c
andb $-0x2, %cl
testb $0x1, %al
je 0x278f
orb $0x2, %cl
jmp 0x2792
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::ora_zeropg(NES::MemoryUnit&)
void CPU::ora_zeropg(MemoryUnit &r) {
    // Bitwise OR with Accumulator: Zero Page Addressing
    // PC += 2

    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    regAcc = regAcc|r.getByteAt(alpha);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
movb (%rbx), %r15b
movzbl %al, %esi
movq %r14, %rdi
callq 0x5bd4
orb %r15b, %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x27f1
andb $-0x2, %cl
testb $0x1, %al
je 0x27f4
orb $0x2, %cl
jmp 0x27f7
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::ora_immediate(NES::MemoryUnit&)
void CPU::ora_immediate(MemoryUnit &r) {
    // Bitwise OR with Accumulator: Immediate addressing
    // PC += 2
    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    regAcc = regAcc|alpha;
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movzwl 0x6(%rdi), %ecx
incl %ecx
movw %cx, 0x6(%rdi)
movzwl %cx, %esi
movq %rax, %rdi
callq 0x5bd4
incw 0x6(%rbx)
orb (%rbx), %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x2840
andb $-0x2, %cl
testb $0x1, %al
je 0x2843
orb $0x2, %cl
jmp 0x2846
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::ora_absolute(NES::MemoryUnit&)
void CPU::ora_absolute(MemoryUnit &r) {
    // Bitwise OR with Accumulator: Absolute addressing
    // PC += 3

    instPtr++;
    uint16_t alpha = r.getByteAt(instPtr);
    instPtr++;
    uint16_t beta = r.getByteAt(instPtr);
    instPtr++;
    uint16_t addr = (alpha|(beta<<8));
    regAcc = regAcc|r.getByteAt(addr);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movl $0xffff, %r12d          # imm = 0xFFFF
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
movzbl %r15b, %ecx
movzbl %al, %esi
shll $0x8, %esi
orl %ecx, %esi
movb (%rbx), %r15b
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
orb %r15b, %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x28c8
andb $-0x2, %cl
testb $0x1, %al
je 0x28cb
orb $0x2, %cl
jmp 0x28ce
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::ora_indirect_y(NES::MemoryUnit&)
void CPU::ora_indirect_y(MemoryUnit &r) {
    // Bitwise OR with Accumulator: Zero Page Y indexed
    // PC += 2

    instPtr++;
    uint16_t alpha = regY, beta = r.getByteAt(instPtr);
    instPtr++;
    uint16_t kapa = r.getByteAt(beta), napa = r.getByteAt((beta+1)%256);
    uint16_t addr = kapa|(napa<<8);
    regAcc = regAcc|r.getByteAt(addr+alpha);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movzbl 0x2(%rdi), %r13d
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5bd4
movl %eax, %r12d
incb %r15b
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x5bd4
movzbl %r12b, %ecx
addl %r13d, %ecx
movzbl %al, %esi
shll $0x8, %esi
addl %ecx, %esi
movb (%rbx), %r15b
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
movq %r14, %rdi
callq 0x5bd4
orb %r15b, %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x2968
andb $-0x2, %cl
testb $0x1, %al
je 0x296b
orb $0x2, %cl
jmp 0x296e
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::ora_zeropg_x(NES::MemoryUnit&)
void CPU::ora_zeropg_x(MemoryUnit &r) {
    // Bitwise OR with Accumulator: Zero Page X Indexed
    // PC += 2

    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr), beta = regX;
    instPtr++;
    uint16_t addr = (alpha + regX)%256;
    regAcc = regAcc|r.getByteAt(addr);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
addb 0x1(%rbx), %al
movb (%rbx), %r15b
movzbl %al, %esi
movq %r14, %rdi
callq 0x5bd4
orb %r15b, %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x29d0
andb $-0x2, %cl
testb $0x1, %al
je 0x29d3
orb $0x2, %cl
jmp 0x29d6
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::ora_absolute_y(NES::MemoryUnit&)
void CPU::ora_absolute_y(MemoryUnit &r) {
    // Bitwise OR with Accumulator: Absolute addressing indexed Y
    // PC += 3
    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    uint8_t beta = r.getByteAt(instPtr);
    instPtr++;
    uint16_t addr = (alpha|(beta<<8));
    addr += regY;
    regAcc = regAcc|r.getByteAt(addr);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movl $0xffff, %r12d          # imm = 0xFFFF
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
movzbl %r15b, %ecx
movzbl %al, %eax
shll $0x8, %eax
orl %ecx, %eax
movzbl 0x2(%rbx), %esi
addl %eax, %esi
movb (%rbx), %r15b
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
orb %r15b, %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x2a62
andb $-0x2, %cl
testb $0x1, %al
je 0x2a65
orb $0x2, %cl
jmp 0x2a68
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::ora_absolute_x(NES::MemoryUnit&)
void CPU::ora_absolute_x(MemoryUnit &r) {
    // Bitwise OR with Accumulator: Absolute addressing indexed X
    // PC += 3
    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    uint8_t beta = r.getByteAt(instPtr);
    instPtr++;
    uint16_t addr = (alpha|(beta<<8));
    addr += regX;
    regAcc = regAcc|r.getByteAt(addr);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movl $0xffff, %r12d          # imm = 0xFFFF
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
movzbl %r15b, %ecx
movzbl %al, %eax
shll $0x8, %eax
orl %ecx, %eax
movzbl 0x1(%rbx), %esi
addl %eax, %esi
movb (%rbx), %r15b
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
orb %r15b, %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x2af2
andb $-0x2, %cl
testb $0x1, %al
je 0x2af5
orb $0x2, %cl
jmp 0x2af8
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::and_indirect_x(NES::MemoryUnit&)
void CPU::and_indirect_x(MemoryUnit &r) {
    // Bitwise AND with Accumulator: Indirect Reg-X addressing
    // PC += 2

    instPtr++;
    uint16_t alpha = regX, beta = r.getByteAt(instPtr);
    instPtr++;
    uint8_t addr = ((alpha+beta)&0xFF);
    uint8_t kapa = r.getByteAt(addr), napa = r.getByteAt(addr+1);
    uint16_t finalAddr = (kapa | (napa << 8));
    regAcc = regAcc&r.getByteAt(finalAddr);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movb 0x1(%rdi), %r15b
movl $0xffff, %r13d          # imm = 0xFFFF
andl %r13d, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
addb %r15b, %al
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5bd4
movl %eax, %r12d
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5bd4
movzbl %r12b, %ecx
movzbl %al, %esi
shll $0x8, %esi
orl %ecx, %esi
movb (%rbx), %r15b
andl %r13d, %esi
movq %r14, %rdi
callq 0x5bd4
andb %r15b, %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x2b8e
andb $-0x2, %cl
testb $0x1, %al
je 0x2b91
orb $0x2, %cl
jmp 0x2b94
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::and_zeropg(NES::MemoryUnit&)
void CPU::and_zeropg(MemoryUnit &r) {
    // Bitwise AND with Accumulator: Zero Page Addressing
    // PC += 2

    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    regAcc = regAcc&r.getByteAt(alpha);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
movb (%rbx), %r15b
movzbl %al, %esi
movq %r14, %rdi
callq 0x5bd4
andb %r15b, %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x2bf3
andb $-0x2, %cl
testb $0x1, %al
je 0x2bf6
orb $0x2, %cl
jmp 0x2bf9
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::and_immediate(NES::MemoryUnit&)
void CPU::and_immediate(MemoryUnit &r) {
    // Bitwise AND with Accumulator: Immediate addressing
    // PC += 2
    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    regAcc = regAcc&alpha;
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movzwl 0x6(%rdi), %ecx
incl %ecx
movw %cx, 0x6(%rdi)
movzwl %cx, %esi
movq %rax, %rdi
callq 0x5bd4
incw 0x6(%rbx)
andb (%rbx), %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x2c42
andb $-0x2, %cl
testb $0x1, %al
je 0x2c45
orb $0x2, %cl
jmp 0x2c48
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::and_absolute(NES::MemoryUnit&)
void CPU::and_absolute(MemoryUnit &r) {
    // Bitwise AND with Accumulator: Absolute addressing
    // PC += 3

    instPtr++;
    uint16_t alpha = r.getByteAt(instPtr);
    instPtr++;
    uint16_t beta = r.getByteAt(instPtr);
    instPtr++;
    uint16_t addr = (alpha|(beta<<8));
    regAcc = regAcc&r.getByteAt(addr);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movl $0xffff, %r12d          # imm = 0xFFFF
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
movzbl %r15b, %ecx
movzbl %al, %esi
shll $0x8, %esi
orl %ecx, %esi
movb (%rbx), %r15b
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
andb %r15b, %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x2cca
andb $-0x2, %cl
testb $0x1, %al
je 0x2ccd
orb $0x2, %cl
jmp 0x2cd0
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::and_indirect_y(NES::MemoryUnit&)
void CPU::and_indirect_y(MemoryUnit &r) {
    // Bitwise AND with Accumulator: Zero Page Y indexed
    // PC += 2

    instPtr++;
    uint16_t alpha = regY, beta = r.getByteAt(instPtr);
    instPtr++;
    uint16_t kapa = r.getByteAt(beta), napa = r.getByteAt((beta+1)%256);
    uint16_t addr = kapa|(napa<<8);
    regAcc = regAcc&r.getByteAt(addr+alpha);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movzbl 0x2(%rdi), %r13d
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5bd4
movl %eax, %r12d
incb %r15b
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x5bd4
movzbl %r12b, %ecx
addl %r13d, %ecx
movzbl %al, %esi
shll $0x8, %esi
addl %ecx, %esi
movb (%rbx), %r15b
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
movq %r14, %rdi
callq 0x5bd4
andb %r15b, %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x2d6a
andb $-0x2, %cl
testb $0x1, %al
je 0x2d6d
orb $0x2, %cl
jmp 0x2d70
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::and_zeropg_x(NES::MemoryUnit&)
void CPU::and_zeropg_x(MemoryUnit &r) {
    // Bitwise AND with Accumulator: Zero Page X Indexed
    // PC += 2

    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr), beta = regX;
    instPtr++;
    uint16_t addr = (alpha + regX)%256;
    regAcc = regAcc&r.getByteAt(addr);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
addb 0x1(%rbx), %al
movb (%rbx), %r15b
movzbl %al, %esi
movq %r14, %rdi
callq 0x5bd4
andb %r15b, %al
movb %al, (%rbx)
movb 0x3(%rbx), %cl
je 0x2dd2
andb $-0x2, %cl
testb $0x1, %al
je 0x2dd5
orb $0x2, %cl
jmp 0x2dd8
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::eor_zeropg(NES::MemoryUnit&)
void CPU::eor_zeropg(MemoryUnit &r) {
    // Bitwise Exclusive-OR with Accumulator: Zero Page Addressing
    // PC += 2

    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    regAcc = regAcc^r.getByteAt(alpha);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
movb (%rbx), %r15b
movzbl %al, %esi
movq %r14, %rdi
callq 0x5bd4
movl %eax, %edx
xorb %r15b, %dl
movb %dl, (%rbx)
movb 0x3(%rbx), %cl
cmpb %al, %r15b
jne 0x2ffb
orb $0x1, %cl
jmp 0x3003
andb $-0x2, %cl
testb $0x1, %dl
jne 0x3008
andb $-0x3, %cl
jmp 0x300b
orb $0x2, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::eor_immediate(NES::MemoryUnit&)
void CPU::eor_immediate(MemoryUnit &r) {
    // Bitwise Exclusive-OR with Accumulator: Immediate addressing
    // PC += 2
    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    regAcc = regAcc^alpha;
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movzwl 0x6(%rdi), %ecx
incl %ecx
movw %cx, 0x6(%rdi)
movzwl %cx, %esi
movq %rax, %rdi
callq 0x5bd4
incw 0x6(%rbx)
movb (%rbx), %sil
movb 0x3(%rbx), %cl
movl %esi, %edx
xorb %al, %dl
movb %dl, (%rbx)
cmpb %al, %sil
jne 0x3055
orb $0x1, %cl
jmp 0x305d
andb $-0x2, %cl
testb $0x1, %dl
jne 0x3062
andb $-0x3, %cl
jmp 0x3065
orb $0x2, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::eor_absolute(NES::MemoryUnit&)
void CPU::eor_absolute(MemoryUnit &r) {
    // Bitwise Exclusive-OR with Accumulator: Absolute addressing
    // PC += 3

    instPtr++;
    uint16_t alpha = r.getByteAt(instPtr);
    instPtr++;
    uint16_t beta = r.getByteAt(instPtr);
    instPtr++;
    uint16_t addr = (alpha|(beta<<8));
    regAcc = regAcc^r.getByteAt(addr);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movl $0xffff, %r12d          # imm = 0xFFFF
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
movzbl %r15b, %ecx
movzbl %al, %esi
shll $0x8, %esi
orl %ecx, %esi
movb (%rbx), %r15b
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
movl %eax, %edx
xorb %r15b, %dl
movb %dl, (%rbx)
movb 0x3(%rbx), %cl
cmpb %al, %r15b
jne 0x30e6
orb $0x1, %cl
jmp 0x30ee
andb $-0x2, %cl
testb $0x1, %dl
jne 0x30f3
andb $-0x3, %cl
jmp 0x30f6
orb $0x2, %cl
movb %cl, 0x3(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::eor_indirect_y(NES::MemoryUnit&)
void CPU::eor_indirect_y(MemoryUnit &r) {
    // Bitwise Exclusive-OR with Accumulator: Zero Page Y indexed
    // PC += 2

    instPtr++;
    uint16_t alpha = regY, beta = r.getByteAt(instPtr);
    instPtr++;
    uint16_t kapa = r.getByteAt(beta), napa = r.getByteAt((beta+1)%256);
    uint16_t addr = kapa|(napa<<8);
    regAcc = regAcc^r.getByteAt(addr+alpha);
    changeFlags();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movzbl 0x2(%rdi), %r13d
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5bd4
movl %eax, %r12d
incb %r15b
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x5bd4
movzbl %r12b, %ecx
addl %r13d, %ecx
movzbl %al, %esi
shll $0x8, %esi
addl %ecx, %esi
movb (%rbx), %r15b
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
movq %r14, %rdi
callq 0x5bd4
movl %eax, %edx
xorb %r15b, %dl
movb %dl, (%rbx)
movb 0x3(%rbx), %cl
cmpb %al, %r15b
jne 0x318e
orb $0x1, %cl
jmp 0x3196
andb $-0x2, %cl
testb $0x1, %dl
jne 0x319b
andb $-0x3, %cl
jmp 0x319e
orb $0x2, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq