LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c1a
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq $0x3, %r15
jne 0x8911
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4c22
movsd (%rax), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
incl %r14d
cmpl $0x3, %r14d
jne 0x892e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, (%rcx)
xorpd %xmm0, %xmm0
movq %rdi, -0x30(%rbp)
movupd %xmm0, (%rdi)
movapd %xmm0, -0x40(%rbp)
movq 0x30(%rsi), %r13
cmpq 0x38(%rsi), %r13
jae 0x8a33
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8c22
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x8a4f
movq (%rdi), %rax
movq %r15, %rsi
callq *0x20(%rax)
ucomisd 0x66f(%rip), %xmm0      # 0x9040
jne 0x89d5
jnp 0x8a24
ucomisd 0x683(%rip), %xmm0      # 0x9060
jbe 0x8a24
movsd (%r14), %xmm1
ucomisd 0x654(%rip), %xmm1      # 0x9040
jne 0x8a03
jp 0x8a03
movsd %xmm0, (%r14)
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x8c22
jmp 0x8a24
ucomisd %xmm0, %xmm1
jbe 0x8a24
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
movsd %xmm0, -0x48(%rbp)
callq 0x8c22
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%r14)
addq $0x10, %r13
cmpq 0x38(%r12), %r13
jb 0x89a8
leaq -0x38(%rbp), %rdi
callq 0x581c
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x112d(%rip), %rdi      # 0x9b83
leaq 0x112e(%rip), %rsi      # 0x9b8b
leaq 0x1606(%rip), %rcx      # 0xa06a
movl $0x2d8, %edx            # imm = 0x2D8
callq 0x30f0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x581c
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x581c
movq %rbx, %rdi
callq 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c1a
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq $0x3, %r15
jne 0x8b0b
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4c22
movsd (%rax), %xmm0
xorps 0x552(%rip), %xmm0      # 0x9090
movlps %xmm0, (%rax)
incl %r14d
cmpl $0x3, %r14d
jne 0x8b28
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lagoproject[P]arti/analysis/cherenkov.cc
// Function: Usage(char*, int)
void Usage(char *prog, int verbose=0) {
  cout << endl << "analysis.cc, from ARTI     version " << VERSION << endl<< endl;
  cout << "  Read ascii files containing Corsika Cherenkov outputs (CER) and produce a histogram" << endl; 
  cout << "  of photon density as a function of distance to core." << endl; 
  cout << "  Usage: " << prog << " [flags] raw_file" << endl;
  cout << "    If 'raw_file' does not exits, switch to STDIN and use raw_file as" << endl;
  cout << "    basename for output file." << endl;
  cout << "    flags:"<<endl;
  cout << "      -c <CERARY input line> : CERARY line (expects complete line!) from input file" << endl;
  cout << "      -v: enable verbose outputs"<<endl; 
  cout << "      -h: prints help and exits"<<endl << endl;
//  cout << "    * STILL NOT IMPLEMENTED"<<endl;
  if (verbose) {
    // verbose help
  }
  exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x3b97(%rip), %rbx      # 0x4fc8
movq %rbx, %rdi
callq 0x1070
leaq 0x1c50(%rip), %rsi      # 0x3090
movq %rax, %rdi
callq 0x10d0
leaq 0x1c65(%rip), %rsi      # 0x30b4
movq %rax, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
callq 0x1070
leaq 0x1c4b(%rip), %rsi      # 0x30b9
movq %rbx, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1070
leaq 0x1c8a(%rip), %rsi      # 0x310f
movq %rbx, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1070
leaq 0x1caa(%rip), %rsi      # 0x3146
movq %rbx, %rdi
callq 0x10d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x10d0
leaq 0x1c9a(%rip), %rsi      # 0x3150
movq %rax, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1070
leaq 0x1c95(%rip), %rsi      # 0x3162
movq %rbx, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1070
leaq 0x1cc4(%rip), %rsi      # 0x31a8
movq %rbx, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1070
leaq 0x1ccb(%rip), %rsi      # 0x31c6
movq %rbx, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1070
leaq 0x1cbf(%rip), %rsi      # 0x31d1
movq %rbx, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1070
leaq 0x1cfc(%rip), %rsi      # 0x3225
movq %rbx, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1070
leaq 0x1d06(%rip), %rsi      # 0x3246
movq %rbx, %rdi
callq 0x10d0
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
callq 0x1070
movl $0x1, %edi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5af4
incw 0x6(%rbx)
addb %r15b, %al
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movl %eax, %r12d
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movzbl %r12b, %ecx
movzbl %al, %esi
shll $0x8, %esi
orl %ecx, %esi
movb (%rbx), %r15b
andl %r13d, %esi
movq %r14, %rdi
callq 0x5af4
orb %r15b, %al
movb %al, (%rbx)
sete %cl
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %cl, %dl
addb %al, %al
andb $0x2, %al
orb %dl, %al
movb %al, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5af4
incw 0x6(%rbx)
movb (%rbx), %r15b
movzbl %al, %esi
movq %r14, %rdi
callq 0x5af4
orb %r15b, %al
movb %al, (%rbx)
sete %cl
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %cl, %dl
addb %al, %al
andb $0x2, %al
orb %dl, %al
movb %al, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5af4
incw 0x6(%rbx)
orb (%rbx), %al
movb %al, (%rbx)
sete %cl
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %cl, %dl
addb %al, %al
andb $0x2, %al
orb %dl, %al
movb %al, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5af4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
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 0x5af4
orb %r15b, %al
movb %al, (%rbx)
sete %cl
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %cl, %dl
addb %al, %al
andb $0x2, %al
orb %dl, %al
movb %al, 0x3(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5af4
incw 0x6(%rbx)
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movl %eax, %r12d
incb %r15b
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x5af4
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 0x5af4
orb %r15b, %al
movb %al, (%rbx)
sete %cl
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %cl, %dl
addb %al, %al
andb $0x2, %al
orb %dl, %al
movb %al, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5af4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
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 0x5af4
orb %r15b, %al
movb %al, (%rbx)
sete %cl
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %cl, %dl
addb %al, %al
andb $0x2, %al
orb %dl, %al
movb %al, 0x3(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5af4
incw 0x6(%rbx)
movb (%rbx), %r15b
movzbl %al, %esi
movq %r14, %rdi
callq 0x5af4
movl %eax, %ecx
xorb %r15b, %cl
movb %cl, (%rbx)
cmpb %al, %r15b
sete %al
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %al, %dl
addb %cl, %cl
andb $0x2, %cl
orb %dl, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5af4
incw 0x6(%rbx)
movb (%rbx), %cl
movb 0x3(%rbx), %dl
movl %ecx, %esi
xorb %al, %sil
movb %sil, (%rbx)
cmpb %al, %cl
sete %al
andb $-0x4, %dl
orb %al, %dl
addb %sil, %sil
andb $0x2, %sil
orb %dl, %sil
movb %sil, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5af4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
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 0x5af4
movl %eax, %ecx
xorb %r15b, %cl
movb %cl, (%rbx)
cmpb %al, %r15b
sete %al
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %al, %dl
addb %cl, %cl
andb $0x2, %cl
orb %dl, %cl
movb %cl, 0x3(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5af4
incw 0x6(%rbx)
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movl %eax, %r12d
incb %r15b
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x5af4
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 0x5af4
movl %eax, %ecx
xorb %r15b, %cl
movb %cl, (%rbx)
cmpb %al, %r15b
sete %al
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %al, %dl
addb %cl, %cl
andb $0x2, %cl
orb %dl, %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_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::eor_zeropg_x(NES::MemoryUnit&)
void CPU::eor_zeropg_x(MemoryUnit &r) {
    // Bitwise Exclusive-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 0x5af4
incw 0x6(%rbx)
addb 0x1(%rbx), %al
movb (%rbx), %r15b
movzbl %al, %esi
movq %r14, %rdi
callq 0x5af4
movl %eax, %ecx
xorb %r15b, %cl
movb %cl, (%rbx)
cmpb %al, %r15b
sete %al
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %al, %dl
addb %cl, %cl
andb $0x2, %cl
orb %dl, %cl
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::eor_absolute_y(NES::MemoryUnit&)
void CPU::eor_absolute_y(MemoryUnit &r) {
    // Bitwise Exclusive 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 0x5af4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
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 0x5af4
movl %eax, %ecx
xorb %r15b, %cl
movb %cl, (%rbx)
cmpb %al, %r15b
sete %al
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %al, %dl
addb %cl, %cl
andb $0x2, %cl
orb %dl, %cl
movb %cl, 0x3(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::adc_indirect_x(NES::MemoryUnit&)
void CPU::adc_indirect_x(MemoryUnit &r) {
    // Add to the 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));
    uint8_t m=regAcc, n=r.getByteAt(finalAddr), res;

    uint16_t zeta = uint16_t(regAcc)+uint16_t(n)+\
                    uint16_t(getCarryFlag());
    regAcc = zeta%256;
    res = regAcc;
    uint8_t overflow=!((m^n)&0x80)&&((m^res)&0x80), carry=0;
    carry = zeta/256;
    changeFlags(carry, overflow);
}

// 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 0x5af4
incw 0x6(%rbx)
addb %r15b, %al
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movl %eax, %r12d
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movzbl %r12b, %ecx
movzbl %al, %esi
shll $0x8, %esi
orl %ecx, %esi
movzbl (%rbx), %r15d
andl %r13d, %esi
movq %r14, %rdi
callq 0x5af4
movzbl (%rbx), %esi
movzbl %al, %eax
movzbl 0x3(%rbx), %ecx
btl $0x2, %ecx
adcl %eax, %esi
movb %sil, (%rbx)
movl %r15d, %ecx
xorl %esi, %ecx
testb %cl, %cl
sets %cl
xorb %r15b, %al
setns %al
andb %cl, %al
shrl $0x8, %esi
movzbl %al, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x48fa
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::adc_zeropg(NES::MemoryUnit&)
void CPU::adc_zeropg(MemoryUnit &r) {
    // Add to the Accumulator: Zero Page Addressing
    // PC += 2

    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    uint8_t m=regAcc, n=r.getByteAt(alpha), res;

    uint16_t zeta = uint16_t(regAcc)+uint16_t(n)+\
                    uint16_t(getCarryFlag());
    regAcc = zeta%256;
    res = regAcc;
    uint8_t overflow=!((m^n)&0x80)&&((m^res)&0x80), carry=0;
    carry = zeta/256;
    changeFlags(carry, overflow);
}

// 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 0x5af4
incw 0x6(%rbx)
movzbl (%rbx), %r15d
movzbl %al, %esi
movq %r14, %rdi
callq 0x5af4
movzbl (%rbx), %esi
movzbl %al, %eax
movzbl 0x3(%rbx), %ecx
btl $0x2, %ecx
adcl %eax, %esi
movb %sil, (%rbx)
movl %r15d, %ecx
xorl %esi, %ecx
testb %cl, %cl
sets %cl
xorb %r15b, %al
setns %al
andb %cl, %al
shrl $0x8, %esi
movzbl %al, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x48fa
nop
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::adc_immediate(NES::MemoryUnit&)
void CPU::adc_immediate(MemoryUnit &r) {
    // Add to Accumulator: Immediate addressing
    // PC += 2
    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    uint16_t zeta = uint16_t(regAcc)+uint16_t(alpha)+\
                    uint16_t(getCarryFlag());
    uint8_t m=regAcc, n=alpha, res;
    regAcc = zeta%256;
    res = regAcc;
    uint8_t overflow=!((m^n)&0x80)&&((m^res)&0x80), carry=0;
    carry = zeta/256;
    changeFlags(carry, overflow);
}

// 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 0x5af4
incw 0x6(%rbx)
movzbl (%rbx), %ecx
movzbl %al, %eax
movzbl 0x3(%rbx), %edx
btl $0x2, %edx
movl %ecx, %esi
adcl %eax, %esi
movb %sil, (%rbx)
movl %esi, %edx
xorb %cl, %dl
sets %dl
xorb %cl, %al
setns %al
andb %dl, %al
shrl $0x8, %esi
movzbl %al, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x48fa
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::adc_absolute(NES::MemoryUnit&)
void CPU::adc_absolute(MemoryUnit &r) {
    // Add to the 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));
    uint8_t m=regAcc, n=r.getByteAt(addr), res;

    uint16_t zeta = uint16_t(regAcc)+uint16_t(n)+\
                    uint16_t(getCarryFlag());
    regAcc = zeta%256;
    res = regAcc;
    uint8_t overflow=!((m^n)&0x80)&&((m^res)&0x80), carry=0;
    carry = zeta/256;
    changeFlags(carry, overflow);
}

// 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 0x5af4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
incw 0x6(%rbx)
movzbl %r15b, %ecx
movzbl %al, %esi
shll $0x8, %esi
orl %ecx, %esi
movzbl (%rbx), %r15d
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
movzbl (%rbx), %esi
movzbl %al, %eax
movzbl 0x3(%rbx), %ecx
btl $0x2, %ecx
adcl %eax, %esi
movb %sil, (%rbx)
movl %r15d, %ecx
xorl %esi, %ecx
testb %cl, %cl
sets %cl
xorb %r15b, %al
setns %al
andb %cl, %al
shrl $0x8, %esi
movzbl %al, %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x48fa
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::adc_indirect_y(NES::MemoryUnit&)
void CPU::adc_indirect_y(MemoryUnit &r) {
    // Add to 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);
    uint8_t m=regAcc, n=r.getByteAt(addr+alpha), res;

    uint16_t zeta = uint16_t(regAcc)+uint16_t(n)+\
                    uint16_t(getCarryFlag());
    regAcc = zeta%256;
    res = regAcc;
    uint8_t overflow=!((m^n)&0x80)&&((m^res)&0x80), carry=0;
    carry = zeta/256;
    changeFlags(carry, overflow);
}

// 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 0x5af4
incw 0x6(%rbx)
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movl %eax, %r12d
incb %r15b
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x5af4
movzbl %r12b, %ecx
addl %r13d, %ecx
movzbl %al, %esi
shll $0x8, %esi
addl %ecx, %esi
movzbl (%rbx), %r15d
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
movq %r14, %rdi
callq 0x5af4
movzbl (%rbx), %esi
movzbl %al, %eax
movzbl 0x3(%rbx), %ecx
btl $0x2, %ecx
adcl %eax, %esi
movb %sil, (%rbx)
movl %r15d, %ecx
xorl %esi, %ecx
testb %cl, %cl
sets %cl
xorb %r15b, %al
setns %al
andb %cl, %al
shrl $0x8, %esi
movzbl %al, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x48fa
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::adc_absolute_y(NES::MemoryUnit&)
void CPU::adc_absolute_y(MemoryUnit &r) {
    // Add to the 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;
    uint8_t m=regAcc, n=r.getByteAt(addr), res;

    uint16_t zeta = uint16_t(regAcc)+uint16_t(n)+\
                    uint16_t(getCarryFlag());
    regAcc = zeta%256;
    res = regAcc;
    uint8_t overflow=!((m^n)&0x80)&&((m^res)&0x80), carry=0;
    carry = zeta/256;
    changeFlags(carry, overflow);

}

// 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 0x5af4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
incw 0x6(%rbx)
movzbl %r15b, %ecx
movzbl %al, %eax
shll $0x8, %eax
orl %ecx, %eax
movzbl 0x2(%rbx), %esi
addl %eax, %esi
movzbl (%rbx), %r15d
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
movzbl (%rbx), %esi
movzbl %al, %eax
movzbl 0x3(%rbx), %ecx
btl $0x2, %ecx
adcl %eax, %esi
movb %sil, (%rbx)
movl %r15d, %ecx
xorl %esi, %ecx
testb %cl, %cl
sets %cl
xorb %r15b, %al
setns %al
andb %cl, %al
shrl $0x8, %esi
movzbl %al, %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x48fa
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::sta_indirect_x(NES::MemoryUnit&)
void CPU::sta_indirect_x(MemoryUnit &r) {
    // Store contents of accumulator to address: 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));
    r.setByteAt(finalAddr, regAcc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movb 0x1(%rdi), %r15b
movl $0xffff, %r13d          # imm = 0xFFFF
andl %r13d, %esi
movq %rbx, %rdi
callq 0x5af4
incw 0x6(%r14)
addb %r15b, %al
movzbl %al, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5af4
movl %eax, %r12d
incl %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5af4
movzbl %r12b, %ecx
movzbl %al, %esi
shll $0x8, %esi
orl %ecx, %esi
movzbl (%r14), %edx
andl %r13d, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5ad4
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::sta_zeropg(NES::MemoryUnit&)
void CPU::sta_zeropg(MemoryUnit &r) {
    // Store contents of accumulator to address: Zero Page Addressing
    // PC += 2

    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    r.setByteAt(alpha, regAcc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x6(%rdi), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x5af4
incw 0x6(%r14)
movzbl (%r14), %edx
movzbl %al, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5ad4
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::sta_absolute(NES::MemoryUnit&)
void CPU::sta_absolute(MemoryUnit &r) {
    // Store contents of accumulator to address: 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));
    r.setByteAt(addr, regAcc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movl $0xffff, %r12d          # imm = 0xFFFF
andl %r12d, %esi
movq %rbx, %rdi
callq 0x5af4
movl %eax, %r15d
movzwl 0x6(%r14), %esi
incl %esi
movw %si, 0x6(%r14)
andl %r12d, %esi
movq %rbx, %rdi
callq 0x5af4
incw 0x6(%r14)
movzbl %r15b, %ecx
movzbl %al, %esi
shll $0x8, %esi
orl %ecx, %esi
movzbl (%r14), %edx
andl %r12d, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5ad4
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::sta_indirect_y(NES::MemoryUnit&)
void CPU::sta_indirect_y(MemoryUnit &r) {
    // Store contents of accumulator to address: 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);
    r.setByteAt(addr+alpha, regAcc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movzbl 0x2(%rdi), %r13d
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
movq %rbx, %rdi
callq 0x5af4
incw 0x6(%r14)
movzbl %al, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5af4
movl %eax, %r12d
incb %r15b
movzbl %r15b, %esi
movq %rbx, %rdi
callq 0x5af4
movzbl %r12b, %ecx
addl %r13d, %ecx
movzbl %al, %esi
shll $0x8, %esi
addl %ecx, %esi
movzbl (%r14), %edx
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5ad4
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::sta_zeropg_x(NES::MemoryUnit&)
void CPU::sta_zeropg_x(MemoryUnit &r) {
    // Store contents of accumulator to address: Zero Page X Indexed
    // PC += 2

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x6(%rdi), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x5af4
incw 0x6(%r14)
addb 0x1(%r14), %al
movzbl (%r14), %edx
movzbl %al, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5ad4
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::sta_absolute_y(NES::MemoryUnit&)
void CPU::sta_absolute_y(MemoryUnit &r) {
    // Store contents of accumulator to address: 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;
    r.setByteAt(addr, regAcc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x6(%rdi), %esi
incl %esi
movw %si, 0x6(%rdi)
movl $0xffff, %r12d          # imm = 0xFFFF
andl %r12d, %esi
movq %rbx, %rdi
callq 0x5af4
movl %eax, %r15d
movzwl 0x6(%r14), %esi
incl %esi
movw %si, 0x6(%r14)
andl %r12d, %esi
movq %rbx, %rdi
callq 0x5af4
incw 0x6(%r14)
movzbl %r15b, %ecx
movzbl %al, %eax
shll $0x8, %eax
orl %ecx, %eax
movzbl 0x2(%r14), %esi
addl %eax, %esi
movzbl (%r14), %edx
andl %r12d, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5ad4
nop
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::lda_indirect_x(NES::MemoryUnit&)
void CPU::lda_indirect_x(MemoryUnit &r) {
    // Load 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 = 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 0x5af4
incw 0x6(%rbx)
addb %r15b, %al
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movl %eax, %r12d
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movzbl %r12b, %ecx
movzbl %al, %esi
shll $0x8, %esi
orl %ecx, %esi
andl %r13d, %esi
movq %r14, %rdi
callq 0x5af4
movb %al, (%rbx)
testb %al, %al
sete %cl
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %cl, %dl
addb %al, %al
andb $0x2, %al
orb %dl, %al
movb %al, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::lda_zeropg(NES::MemoryUnit&)
void CPU::lda_zeropg(MemoryUnit &r) {
    // Load Accumulator: Zero Page Addressing
    // PC += 2

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %r14, %rdi
callq 0x5af4
incw 0x6(%rbx)
movzbl %al, %esi
movq %r14, %rdi
callq 0x5af4
movb %al, (%rbx)
testb %al, %al
sete %cl
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %cl, %dl
addb %al, %al
andb $0x2, %al
orb %dl, %al
movb %al, 0x3(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::lda_immediate(NES::MemoryUnit&)
void CPU::lda_immediate(MemoryUnit &r) {
    // Load Accumulator: Immediate addressing
    // PC += 2
    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    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 0x5af4
incw 0x6(%rbx)
movb %al, (%rbx)
testb %al, %al
sete %cl
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %cl, %dl
addb %al, %al
andb $0x2, %al
orb %dl, %al
movb %al, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::lda_absolute(NES::MemoryUnit&)
void CPU::lda_absolute(MemoryUnit &r) {
    // Load 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 = 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 0x5af4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
incw 0x6(%rbx)
movzbl %r15b, %ecx
movzbl %al, %esi
shll $0x8, %esi
orl %ecx, %esi
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
movb %al, (%rbx)
testb %al, %al
sete %cl
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %cl, %dl
addb %al, %al
andb $0x2, %al
orb %dl, %al
movb %al, 0x3(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::lda_indirect_y(NES::MemoryUnit&)
void CPU::lda_indirect_y(MemoryUnit &r) {
    // Load 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 = 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 0x5af4
incw 0x6(%rbx)
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movl %eax, %r12d
incb %r15b
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x5af4
movzbl %r12b, %ecx
addl %r13d, %ecx
movzbl %al, %esi
shll $0x8, %esi
addl %ecx, %esi
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
movq %r14, %rdi
callq 0x5af4
movb %al, (%rbx)
testb %al, %al
sete %cl
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %cl, %dl
addb %al, %al
andb $0x2, %al
orb %dl, %al
movb %al, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::lda_zeropg_x(NES::MemoryUnit&)
void CPU::lda_zeropg_x(MemoryUnit &r) {
    // Load Accumulator: Zero Page X Indexed
    // PC += 2

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x6(%rdi), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %r14, %rdi
callq 0x5af4
incw 0x6(%rbx)
addb 0x1(%rbx), %al
movzbl %al, %esi
movq %r14, %rdi
callq 0x5af4
movb %al, (%rbx)
testb %al, %al
sete %cl
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %cl, %dl
addb %al, %al
andb $0x2, %al
orb %dl, %al
movb %al, 0x3(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::lda_absolute_y(NES::MemoryUnit&)
void CPU::lda_absolute_y(MemoryUnit &r) {
    // Load 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 = 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 0x5af4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
incw 0x6(%rbx)
movzbl %r15b, %ecx
movzbl %al, %eax
shll $0x8, %eax
orl %ecx, %eax
movzbl 0x2(%rbx), %esi
addl %eax, %esi
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
movb %al, (%rbx)
testb %al, %al
sete %cl
movb 0x3(%rbx), %dl
andb $-0x4, %dl
orb %cl, %dl
addb %al, %al
andb $0x2, %al
orb %dl, %al
movb %al, 0x3(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::cmp_indirect_x(NES::MemoryUnit&)
void CPU::cmp_indirect_x(MemoryUnit &r) {
    // Compare Accumulator and Memory: Indirect X
    // 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));
    uint8_t val = regAcc-r.getByteAt(finalAddr);
    setCarryFlag(1);
    if (val == 0) {
        setZeroFlag(1);
    } else {
        setZeroFlag(0);
    }
    if (val >= 0x80) {
        setNegetiveFlag(1);
    } else {
        setNegetiveFlag(0);
    }
    if (regAcc < r.getByteAt(finalAddr)) {
        setCarryFlag(0);
    }
}

// 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 0x5af4
incw 0x6(%rbx)
addb %r15b, %al
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movl %eax, %r12d
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movzbl %r12b, %ecx
movzbl %al, %r15d
shll $0x8, %r15d
orl %ecx, %r15d
movb (%rbx), %r12b
andl %r13d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movb (%rbx), %r13b
movb 0x3(%rbx), %cl
movl %ecx, %edx
andb $-0x8, %dl
orb $0x4, %dl
orb $0x5, %cl
subb %al, %r12b
movzbl %cl, %eax
movzbl %dl, %ecx
cmovel %eax, %ecx
andb $-0x3, %cl
shrb $0x6, %r12b
andb $0x2, %r12b
orb %cl, %r12b
movb %r12b, 0x3(%rbx)
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
cmpb %al, %r13b
jae 0x3ec1
andb $-0x5, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::cmp_zeropg(NES::MemoryUnit&)
void CPU::cmp_zeropg(MemoryUnit &r) {
    // Compare Accumulator: Zero Page Addressing
    // PC += 2

    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    uint8_t val = regAcc-r.getByteAt(alpha);
    
    setCarryFlag(1);
    if (val == 0) {
        setZeroFlag(1);
    } else {
        setZeroFlag(0);
    }
    if (val >= 0x80) {
        setNegetiveFlag(1);
    } else {
        setNegetiveFlag(0);
    }
    if (regAcc < r.getByteAt(alpha)) {
        setCarryFlag(0);
    }
}

// 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), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %r14, %rdi
callq 0x5af4
incw 0x6(%rbx)
movb (%rbx), %r12b
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movb (%rbx), %r13b
movb 0x3(%rbx), %cl
movl %ecx, %edx
andb $-0x8, %dl
orb $0x4, %dl
orb $0x5, %cl
subb %al, %r12b
movzbl %cl, %eax
movzbl %dl, %ecx
cmovel %eax, %ecx
andb $-0x3, %cl
shrb $0x6, %r12b
andb $0x2, %r12b
orb %cl, %r12b
movb %r12b, 0x3(%rbx)
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
cmpb %al, %r13b
jae 0x3f52
andb $-0x5, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::cmp_immediate(NES::MemoryUnit&)
void CPU::cmp_immediate(MemoryUnit &r) {
    // Compare: Immediate addressing
    // PC += 2
    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    uint8_t val = regAcc-alpha;
    
    setCarryFlag(1);
    if (val == 0) {
        setZeroFlag(1);
    } else {
        setZeroFlag(0);
    }
    if (val >= 0x80) {
        setNegetiveFlag(1);
    } else {
        setNegetiveFlag(0);
    }
    if (regAcc < alpha) {
        setCarryFlag(0);
    }
}

// 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 0x5af4
incw 0x6(%rbx)
movb (%rbx), %cl
movb 0x3(%rbx), %dl
movl %edx, %esi
andb $-0x8, %sil
orb $0x4, %sil
orb $0x5, %dl
movl %ecx, %edi
subb %al, %dil
movzbl %dl, %edx
movzbl %sil, %esi
cmovel %edx, %esi
andb $-0x3, %sil
shrb $0x6, %dil
andb $0x2, %dil
orb %sil, %dil
movb %dil, 0x3(%rbx)
cmpb %al, %cl
jae 0x3fc3
andb $-0x5, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::cmp_absolute(NES::MemoryUnit&)
void CPU::cmp_absolute(MemoryUnit &r) {
    // Compare 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));
    uint8_t val = regAcc-r.getByteAt(addr);
    
    setCarryFlag(1);
    if (val == 0) {
        setZeroFlag(1);
    } else {
        setZeroFlag(0);
    }
    if (val >= 0x80) {
        setNegetiveFlag(1);
    } else {
        setNegetiveFlag(0);
    }
    if (regAcc < r.getByteAt(addr)) {
        setCarryFlag(0);
    }
}

// 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)
movl $0xffff, %r12d          # imm = 0xFFFF
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
movl %eax, %r15d
movzwl 0x6(%rbx), %esi
incl %esi
movw %si, 0x6(%rbx)
andl %r12d, %esi
movq %r14, %rdi
callq 0x5af4
incw 0x6(%rbx)
movzbl %r15b, %ecx
movzbl %al, %r15d
shll $0x8, %r15d
orl %ecx, %r15d
movb (%rbx), %r13b
andl %r12d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
movb (%rbx), %r12b
movb 0x3(%rbx), %cl
movl %ecx, %edx
andb $-0x8, %dl
orb $0x4, %dl
orb $0x5, %cl
subb %al, %r13b
movzbl %cl, %eax
movzbl %dl, %ecx
cmovel %eax, %ecx
andb $-0x3, %cl
shrb $0x6, %r13b
andb $0x2, %r13b
orb %cl, %r13b
movb %r13b, 0x3(%rbx)
movq %r14, %rdi
movl %r15d, %esi
callq 0x5af4
cmpb %al, %r12b
jae 0x4078
andb $-0x5, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop