LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5bd4
incw 0x6(%rbx)
addb 0x1(%rbx), %al
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 0x31fe
orb $0x1, %cl
jmp 0x3206
andb $-0x2, %cl
testb $0x1, %dl
jne 0x320b
andb $-0x3, %cl
jmp 0x320e
orb $0x2, %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_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 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
movl %eax, %edx
xorb %r15b, %dl
movb %dl, (%rbx)
movb 0x3(%rbx), %cl
cmpb %al, %r15b
jne 0x3298
orb $0x1, %cl
jmp 0x32a0
andb $-0x2, %cl
testb $0x1, %dl
jne 0x32a5
andb $-0x3, %cl
jmp 0x32a8
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_absolute_x(NES::MemoryUnit&)
void CPU::eor_absolute_x(MemoryUnit &r) {
    // Bitwise Exclusive-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
movl %eax, %edx
xorb %r15b, %dl
movb %dl, (%rbx)
movb 0x3(%rbx), %cl
cmpb %al, %r15b
jne 0x3330
orb $0x1, %cl
jmp 0x3338
andb $-0x2, %cl
testb $0x1, %dl
jne 0x333d
andb $-0x3, %cl
jmp 0x3340
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::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 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
movzbl (%rbx), %r15d
andl %r13d, %esi
movq %r14, %rdi
callq 0x5bd4
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 0x49aa
// File: /workspace/github_cpp_makefile_star2_O3/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 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
movzbl (%rbx), %r15d
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
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 0x49aa
// File: /workspace/github_cpp_makefile_star2_O3/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 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
movzbl (%rbx), %r15d
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
movq %r14, %rdi
callq 0x5bd4
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 0x49aa
// File: /workspace/github_cpp_makefile_star2_O3/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 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
movzbl (%rbx), %r15d
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
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 0x49aa
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5bd4
incw 0x6(%r14)
addb %r15b, %al
movzbl %al, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5bd4
movl %eax, %r12d
incl %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5bd4
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 0x5bb4
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5bd4
incw 0x6(%r14)
movzbl (%r14), %edx
movzbl %al, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5bb4
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5bd4
movl %eax, %r15d
movzwl 0x6(%r14), %esi
incl %esi
movw %si, 0x6(%r14)
andl %r12d, %esi
movq %rbx, %rdi
callq 0x5bd4
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 0x5bb4
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5bd4
incw 0x6(%r14)
movzbl %al, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5bd4
movl %eax, %r12d
incb %r15b
movzbl %r15b, %esi
movq %rbx, %rdi
callq 0x5bd4
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 0x5bb4
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5bd4
movl %eax, %r15d
movzwl 0x6(%r14), %esi
incl %esi
movw %si, 0x6(%r14)
andl %r12d, %esi
movq %rbx, %rdi
callq 0x5bd4
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 0x5bb4
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 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
andl %r13d, %esi
movq %r14, %rdi
callq 0x5bd4
movb %al, (%rbx)
movb 0x3(%rbx), %cl
testb %al, %al
je 0x3b82
andb $-0x2, %cl
testb $0x1, %al
je 0x3b85
orb $0x2, %cl
jmp 0x3b88
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::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 0x5bd4
incw 0x6(%rbx)
movzbl %al, %esi
movq %r14, %rdi
callq 0x5bd4
movb %al, (%rbx)
movb 0x3(%rbx), %cl
testb %al, %al
je 0x3be0
andb $-0x2, %cl
testb $0x1, %al
je 0x3be3
orb $0x2, %cl
jmp 0x3be6
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5bd4
incw 0x6(%rbx)
movb %al, (%rbx)
movb 0x3(%rbx), %cl
testb %al, %al
je 0x3c28
andb $-0x2, %cl
testb $0x1, %al
je 0x3c2b
orb $0x2, %cl
jmp 0x3c2e
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::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 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
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
movb %al, (%rbx)
movb 0x3(%rbx), %cl
testb %al, %al
je 0x3cac
andb $-0x2, %cl
testb $0x1, %al
je 0x3caf
orb $0x2, %cl
jmp 0x3cb2
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::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 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
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
movq %r14, %rdi
callq 0x5bd4
movb %al, (%rbx)
movb 0x3(%rbx), %cl
testb %al, %al
je 0x3d48
andb $-0x2, %cl
testb $0x1, %al
je 0x3d4b
orb $0x2, %cl
jmp 0x3d4e
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::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 0x5bd4
incw 0x6(%rbx)
addb 0x1(%rbx), %al
movzbl %al, %esi
movq %r14, %rdi
callq 0x5bd4
movb %al, (%rbx)
movb 0x3(%rbx), %cl
testb %al, %al
je 0x3da9
andb $-0x2, %cl
testb $0x1, %al
je 0x3dac
orb $0x2, %cl
jmp 0x3daf
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 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
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
movb %al, (%rbx)
movb 0x3(%rbx), %cl
testb %al, %al
je 0x3e32
andb $-0x2, %cl
testb $0x1, %al
je 0x3e35
orb $0x2, %cl
jmp 0x3e38
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::lda_absolute_x(NES::MemoryUnit&)
void CPU::lda_absolute_x(MemoryUnit &r) {
    // Load 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 = 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
andl %r12d, %esi
movq %r14, %rdi
callq 0x5bd4
movb %al, (%rbx)
movb 0x3(%rbx), %cl
testb %al, %al
je 0x3ebe
andb $-0x2, %cl
testb $0x1, %al
je 0x3ec1
orb $0x2, %cl
jmp 0x3ec4
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::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 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, %r15d
shll $0x8, %r15d
orl %ecx, %r15d
movb (%rbx), %r12b
andl %r13d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5bd4
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 0x5bd4
cmpb %al, %r13b
jae 0x3f8d
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_O3/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 0x5bd4
incw 0x6(%rbx)
movb (%rbx), %r12b
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5bd4
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 0x5bd4
cmpb %al, %r13b
jae 0x401e
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_O3/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 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, %r15d
shll $0x8, %r15d
orl %ecx, %r15d
movb (%rbx), %r13b
andl %r12d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5bd4
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 0x5bd4
cmpb %al, %r12b
jae 0x414c
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_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::cmp_indirect_y(NES::MemoryUnit&)
void CPU::cmp_indirect_y(MemoryUnit &r) {
    // Compare 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 val = regAcc-r.getByteAt(addr+alpha);

    setCarryFlag(1);
    if (val == 0) {
        setZeroFlag(1);
    } else {
        setZeroFlag(0);
    }
    if (val >= 0x80) {
        setNegetiveFlag(1);
    } else {
        setNegetiveFlag(0);
    }
    if (regAcc < r.getByteAt(addr+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), %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, %r15d
shll $0x8, %r15d
addl %ecx, %r15d
movb (%rbx), %r12b
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5bd4
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 0x5bd4
cmpb %al, %r13b
jae 0x421e
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_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::cmp_zeropg_x(NES::MemoryUnit&)
void CPU::cmp_zeropg_x(MemoryUnit &r) {
    // Compare Accumulator: Zero Page X Indexed
    // PC += 2

    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr), beta = regX;
    instPtr++;
    uint16_t addr = (alpha + regX)%256;
    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), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %r14, %rdi
callq 0x5bd4
incw 0x6(%rbx)
addb 0x1(%rbx), %al
movb (%rbx), %r12b
movzbl %al, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5bd4
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 0x5bd4
cmpb %al, %r13b
jae 0x42b3
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_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::cmp_absolute_y(NES::MemoryUnit&)
void CPU::cmp_absolute_y(MemoryUnit &r) {
    // Compare 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 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 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), %r15d
addl %eax, %r15d
movb (%rbx), %r13b
andl %r12d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5bd4
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 0x5bd4
cmpb %al, %r12b
jae 0x4375
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_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::asl_zeropg(NES::MemoryUnit&)
void CPU::asl_zeropg(MemoryUnit &r) {
    // Shifts one bit by left and set the shifted bit to carry flag
    // PC += 2
    instPtr++;
    uint8_t addr = r.getByteAt(instPtr);
    uint8_t val = r.getByteAt(addr);
    instPtr++;
    if (val & 0x80) setCarryFlag(1);
    else setCarryFlag(0);
    val = val << 1;
    if (val == 0) setZeroFlag(1);
    else setZeroFlag(0);
    if (val & 0x80) setNegetiveFlag(1);
    else setNegetiveFlag(0);
    r.setByteAt(addr, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x6(%rdi), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x5bd4
movzbl %al, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5bd4
incw 0x6(%r14)
movb 0x3(%r14), %dl
andb $-0x5, %dl
movl %eax, %ecx
shrb $0x5, %cl
andb $0x4, %cl
orb %dl, %cl
addb %al, %al
je 0x44a0
andb $-0x2, %cl
testb %al, %al
jns 0x44a3
orb $0x2, %cl
jmp 0x44a6
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%r14)
movzwl %r15w, %esi
movzbl %al, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5bb4
nop
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::asl_accumulator(NES::MemoryUnit&)
void CPU::asl_accumulator(MemoryUnit &r) {
    // Shifts one bit by left and set the shifted bit to carry flag
    // PC += 1
    instPtr++;
    uint8_t val = getAccumulator();
    if (val & 0x80) setCarryFlag(1);
    else setCarryFlag(0);
    val = val << 1;
    if (val == 0) setZeroFlag(1);
    else setZeroFlag(0);
    if (val & 0x80) setNegetiveFlag(1);
    else setNegetiveFlag(0);
    setAccumulator(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
incw 0x6(%rdi)
movb (%rdi), %al
movb 0x3(%rdi), %cl
andb $-0x8, %cl
movl %eax, %edx
shrb $0x5, %dl
addb %al, %al
sete %sil
andb $0x4, %dl
orb %cl, %dl
orb %sil, %dl
movb %al, (%rdi)
movb %dl, 0x3(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::asl_absolute(NES::MemoryUnit&)
void CPU::asl_absolute(MemoryUnit &r) {
    // Shifts one bit by left and set the shifted bit to carry flag
    // PC += 3
    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    uint8_t beta = r.getByteAt(instPtr);
    instPtr++;
    uint16_t addr = (beta << 8) | alpha;
    uint8_t val = r.getByteAt(addr);
    if (val & 0x80) setCarryFlag(1);
    else setCarryFlag(0);
    val = val << 1;
    if (val == 0) setZeroFlag(1);
    else setZeroFlag(0);
    if (val & 0x80) setNegetiveFlag(1);
    else setNegetiveFlag(0);
    r.setByteAt(addr, val);
}

// 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 0x5bd4
movl %eax, %r15d
movzwl 0x6(%r14), %esi
incl %esi
movw %si, 0x6(%r14)
andl %r12d, %esi
movq %rbx, %rdi
callq 0x5bd4
incw 0x6(%r14)
movzbl %al, %eax
shll $0x8, %eax
movzbl %r15b, %r15d
orl %eax, %r15d
movl %r15d, %esi
andl %r12d, %esi
movq %rbx, %rdi
callq 0x5bd4
movb 0x3(%r14), %dl
andb $-0x5, %dl
movl %eax, %ecx
shrb $0x5, %cl
andb $0x4, %cl
orb %dl, %cl
addb %al, %al
je 0x4575
andb $-0x2, %cl
testb %al, %al
jns 0x4578
orb $0x2, %cl
jmp 0x457b
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%r14)
movzwl %r15w, %esi
movzbl %al, %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5bb4
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::asl_zeropg_x(NES::MemoryUnit&)
void CPU::asl_zeropg_x(MemoryUnit &r) {
    // Shifts one bit by left and set the shifted bit to carry flag
    // PC += 2
    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr), beta = regX;
    instPtr++;
    uint8_t addr = alpha+beta;
    uint8_t val = r.getByteAt(addr);

    if (val & 0x80) setCarryFlag(1);
    else setCarryFlag(0);
    val = val << 1;
    if (val == 0) setZeroFlag(1);
    else setZeroFlag(0);
    if (val & 0x80) setNegetiveFlag(1);
    else setNegetiveFlag(0);
    r.setByteAt(addr, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x6(%rdi), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x5bd4
incw 0x6(%r14)
addb 0x1(%r14), %al
movzbl %al, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5bd4
movb 0x3(%r14), %dl
andb $-0x5, %dl
movl %eax, %ecx
shrb $0x5, %cl
andb $0x4, %cl
orb %dl, %cl
addb %al, %al
je 0x45f4
andb $-0x2, %cl
testb %al, %al
jns 0x45f7
orb $0x2, %cl
jmp 0x45fa
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%r14)
movzwl %r15w, %esi
movzbl %al, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5bb4
nop
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::asl_absolute_x(NES::MemoryUnit&)
void CPU::asl_absolute_x(MemoryUnit &r) {
    // Shifts one bit by left and set the shifted bit to carry flag
    // PC += 3

    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    uint8_t beta = r.getByteAt(instPtr);
    instPtr++;
    uint8_t addr = ((beta<<8)|alpha)+regX;
    uint8_t val = r.getByteAt(addr);

    if (val & 0x80) setCarryFlag(1);
    else setCarryFlag(0);
    val = val << 1;
    if (val == 0) setZeroFlag(1);
    else setZeroFlag(0);
    if (val & 0x80) setNegetiveFlag(1);
    else setNegetiveFlag(0);
    r.setByteAt(addr, val);
}

// 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 0x5bd4
movl %eax, %r15d
movzwl 0x6(%r14), %esi
incl %esi
movw %si, 0x6(%r14)
andl %r12d, %esi
movq %rbx, %rdi
callq 0x5bd4
incw 0x6(%r14)
addb 0x1(%r14), %r15b
movzbl %r15b, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5bd4
movb 0x3(%r14), %dl
andb $-0x5, %dl
movl %eax, %ecx
shrb $0x5, %cl
andb $0x4, %cl
orb %dl, %cl
addb %al, %al
je 0x4697
andb $-0x2, %cl
testb %al, %al
jns 0x469a
orb $0x2, %cl
jmp 0x469d
orb $0x1, %cl
andb $-0x3, %cl
movb %cl, 0x3(%r14)
movzwl %r15w, %esi
movzbl %al, %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5bb4
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::rol_zeropg(NES::MemoryUnit&)
void CPU::rol_zeropg(MemoryUnit &r) {
    // Shifts one bit by left take shifted as carry and
    // set the shifted bit to carry flag 
    // PC += 2
    instPtr++;
    uint8_t addr = r.getByteAt(instPtr);
    uint8_t val = r.getByteAt(addr);
    uint8_t c = val&0x80;
    instPtr++;
    val = val << 1;
    val = val | (getCarryFlag());
    if (c == 0) setCarryFlag(0);
    else setCarryFlag(1);
    if (val == 0) setZeroFlag(1);
    else setZeroFlag(0);
    if (val & 0x80) setNegetiveFlag(1);
    else setNegetiveFlag(0);
    r.setByteAt(addr, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x6(%rdi), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x5bd4
movzbl %al, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5bd4
incw 0x6(%r14)
leal (%rax,%rax), %edx
movb 0x3(%r14), %sil
movl %esi, %ecx
shrb $0x2, %cl
andb $0x1, %cl
andb $-0x5, %sil
shrb $0x5, %al
andb $0x4, %al
orb %sil, %al
orb %dl, %cl
je 0x471a
andb $-0x2, %al
testb %dl, %dl
jns 0x471c
orb $0x2, %al
jmp 0x471e
orb $0x1, %al
andb $-0x3, %al
movb %al, 0x3(%r14)
movzwl %r15w, %esi
movzbl %cl, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5bb4
nop
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::rol_accumulator(NES::MemoryUnit&)
void CPU::rol_accumulator(MemoryUnit &r) {
    // Shifts one bit by left take shifted as carry and
    // set the shifted bit to carry flag 
    // PC += 1
    instPtr++;
    uint8_t val = getAccumulator();
    uint8_t c = val&0x80;
    val = val << 1;
    val = val | (getCarryFlag());
    if (c == 0) setCarryFlag(0);
    else setCarryFlag(1);
    if (val == 0) setZeroFlag(1);
    else setZeroFlag(0);
    if (val & 0x80) setNegetiveFlag(1);
    else setNegetiveFlag(0);
    setAccumulator(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
incw 0x6(%rdi)
movb (%rdi), %al
movb 0x3(%rdi), %sil
leal (%rax,%rax), %edx
movl %esi, %ecx
shrb $0x2, %cl
andb $0x1, %cl
andb $-0x8, %sil
shrb $0x5, %al
andb $0x4, %al
orb %sil, %al
orb %cl, %dl
je 0x476d
movb %dl, (%rdi)
addb %cl, %cl
orb %cl, %al
jmp 0x4772
orb $0x1, %al
movb $0x0, (%rdi)
movb %al, 0x3(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::rol_absolute(NES::MemoryUnit&)
void CPU::rol_absolute(MemoryUnit &r) {
    // Shifts one bit by left take shifted as carry and
    // set the shifted bit to carry flag 
    // PC += 3

    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    uint8_t beta = r.getByteAt(instPtr);
    instPtr++;
    uint16_t addr = (beta << 8) | alpha;
    uint8_t val = r.getByteAt(addr);
    uint8_t c = val&0x80;
    val = val << 1;
    val = val | (getCarryFlag());
    if (c == 0) setCarryFlag(0);
    else setCarryFlag(1);
    if (val == 0) setZeroFlag(1);
    else setZeroFlag(0);
    if (val & 0x80) setNegetiveFlag(1);
    else setNegetiveFlag(0);
    r.setByteAt(addr, val);
}

// 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 0x5bd4
movl %eax, %r15d
movzwl 0x6(%r14), %esi
incl %esi
movw %si, 0x6(%r14)
andl %r12d, %esi
movq %rbx, %rdi
callq 0x5bd4
incw 0x6(%r14)
movzbl %al, %eax
shll $0x8, %eax
movzbl %r15b, %r15d
orl %eax, %r15d
movl %r15d, %esi
andl %r12d, %esi
movq %rbx, %rdi
callq 0x5bd4
leal (%rax,%rax), %edx
movb 0x3(%r14), %sil
movl %esi, %ecx
shrb $0x2, %cl
andb $0x1, %cl
andb $-0x5, %sil
shrb $0x5, %al
andb $0x4, %al
orb %sil, %al
orb %dl, %cl
je 0x4807
andb $-0x2, %al
testb %dl, %dl
jns 0x4809
orb $0x2, %al
jmp 0x480b
orb $0x1, %al
andb $-0x3, %al
movb %al, 0x3(%r14)
movzwl %r15w, %esi
movzbl %cl, %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5bb4
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::rol_zeropg_x(NES::MemoryUnit&)
void CPU::rol_zeropg_x(MemoryUnit &r) {
    // Shifts one bit by left take shifted as carry and
    // set the shifted bit to carry flag 
    // PC += 2
    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr), beta = regX;
    instPtr++;
    uint8_t addr = alpha+beta;
    uint8_t val = r.getByteAt(addr);

    uint8_t c = val&0x80;
    val = val << 1;
    val = val | (getCarryFlag());
    if (c == 0) setCarryFlag(0);
    else setCarryFlag(1);
    if (val == 0) setZeroFlag(1);
    else setZeroFlag(0);
    if (val & 0x80) setNegetiveFlag(1);
    else setNegetiveFlag(0);
    r.setByteAt(addr, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x6(%rdi), %eax
incl %eax
movw %ax, 0x6(%rdi)
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x5bd4
incw 0x6(%r14)
addb 0x1(%r14), %al
movzbl %al, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5bd4
leal (%rax,%rax), %edx
movb 0x3(%r14), %sil
movl %esi, %ecx
shrb $0x2, %cl
andb $0x1, %cl
andb $-0x5, %sil
shrb $0x5, %al
andb $0x4, %al
orb %sil, %al
orb %dl, %cl
je 0x488c
andb $-0x2, %al
testb %dl, %dl
jns 0x488e
orb $0x2, %al
jmp 0x4890
orb $0x1, %al
andb $-0x3, %al
movb %al, 0x3(%r14)
movzwl %r15w, %esi
movzbl %cl, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5bb4
nop
// File: /workspace/github_cpp_makefile_star2_O3/nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::rol_absolute_x(NES::MemoryUnit&)
void CPU::rol_absolute_x(MemoryUnit &r) {
    // Shifts one bit by left take shifted as carry and
    // set the shifted bit to carry flag 
    // PC += 3
    instPtr++;
    uint8_t alpha = r.getByteAt(instPtr);
    instPtr++;
    uint8_t beta = r.getByteAt(instPtr);
    instPtr++;
    uint8_t addr = ((beta<<8)|alpha)+regX;
    uint8_t val = r.getByteAt(addr);

    uint8_t c = val&0x80;
    val = val << 1;
    val = val | (getCarryFlag());
    if (c == 0) setCarryFlag(0);
    else setCarryFlag(1);
    if (val == 0) setZeroFlag(1);
    else setZeroFlag(0);
    if (val & 0x80) setNegetiveFlag(1);
    else setNegetiveFlag(0);
    r.setByteAt(addr, val);
}

// 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 0x5bd4
movl %eax, %r15d
movzwl 0x6(%r14), %esi
incl %esi
movw %si, 0x6(%r14)
andl %r12d, %esi
movq %rbx, %rdi
callq 0x5bd4
incw 0x6(%r14)
addb 0x1(%r14), %r15b
movzbl %r15b, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5bd4
leal (%rax,%rax), %edx
movb 0x3(%r14), %sil
movl %esi, %ecx
shrb $0x2, %cl
andb $0x1, %cl
andb $-0x5, %sil
shrb $0x5, %al
andb $0x4, %al
orb %sil, %al
orb %dl, %cl
je 0x4935
andb $-0x2, %al
testb %dl, %dl
jns 0x4937
orb $0x2, %al
jmp 0x4939
orb $0x1, %al
andb $-0x3, %al
movb %al, 0x3(%r14)
movzwl %r15w, %esi
movzbl %cl, %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5bb4