LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzbl 0x1(%rax), %ecx
movw %cx, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0x14(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzwl -0x12(%rbp), %eax
movzwl -0x14(%rbp), %ecx
addl %ecx, %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x15(%rbp), %eax
movzwl %ax, %esi
callq 0xe4a0
movb %al, -0x16(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x15(%rbp), %eax
addl $0x1, %eax
movzwl %ax, %esi
callq 0xe4a0
movb %al, -0x17(%rbp)
movzbl -0x16(%rbp), %eax
movzbl -0x17(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x1a(%rbp), %esi
callq 0xe4a0
movq -0x28(%rbp), %rdi
movb %al, (%rdi)
movl $0xff, %edx
movl %edx, %esi
callq 0x8fb0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
movzwl %ax, %esi
callq 0xe4a0
movq -0x20(%rbp), %rdi
movb %al, (%rdi)
movl $0xff, %edx
movl %edx, %esi
callq 0x8fb0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movq -0x20(%rbp), %rdi
movb %al, -0x11(%rbp)
movw 0x6(%rdi), %ax
addw $0x1, %ax
movw %ax, 0x6(%rdi)
movb -0x11(%rbp), %al
movb %al, (%rdi)
movl $0xff, %edx
movl %edx, %esi
callq 0x8fb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x20(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0x12(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x20(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0x14(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzwl -0x12(%rbp), %eax
movzwl -0x14(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, -0x16(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x16(%rbp), %esi
callq 0xe4a0
movq -0x20(%rbp), %rdi
movb %al, (%rdi)
movl $0xff, %edx
movl %edx, %esi
callq 0x8fb0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzbl 0x2(%rax), %ecx
movw %cx, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0x14(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0xe4a0
movzbl %al, %eax
movw %ax, -0x16(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movw %dx, %ax
movzwl %ax, %esi
callq 0xe4a0
movzbl %al, %eax
movw %ax, -0x18(%rbp)
movzwl -0x16(%rbp), %eax
movzwl -0x18(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x1a(%rbp), %eax
movzwl -0x12(%rbp), %ecx
addl %ecx, %eax
movzwl %ax, %esi
callq 0xe4a0
movq -0x28(%rbp), %rdi
movb %al, (%rdi)
movl $0xff, %edx
movl %edx, %esi
callq 0x8fb0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movq -0x20(%rbp), %rcx
movb %al, -0x11(%rbp)
movb 0x1(%rcx), %al
movb %al, -0x12(%rbp)
movw 0x6(%rcx), %ax
addw $0x1, %ax
movw %ax, 0x6(%rcx)
movzbl -0x11(%rbp), %eax
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movw %dx, %ax
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0xe4a0
movq -0x20(%rbp), %rdi
movb %al, (%rdi)
movl $0xff, %edx
movl %edx, %esi
callq 0x8fb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x12(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzbl -0x11(%rbp), %ecx
movzbl -0x12(%rbp), %edx
shll $0x8, %edx
orl %edx, %ecx
movw %cx, -0x14(%rbp)
movzbl 0x2(%rax), %ecx
movzwl -0x14(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0xe4a0
movq -0x20(%rbp), %rdi
movb %al, (%rdi)
movl $0xff, %edx
movl %edx, %esi
callq 0x8fb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzbl 0x1(%rax), %ecx
movw %cx, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0x14(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzwl -0x12(%rbp), %eax
movzwl -0x14(%rbp), %ecx
addl %ecx, %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x15(%rbp), %eax
movzwl %ax, %esi
callq 0xe4a0
movb %al, -0x16(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x15(%rbp), %eax
addl $0x1, %eax
movzwl %ax, %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, -0x17(%rbp)
movzbl -0x16(%rbp), %ecx
movzbl -0x17(%rbp), %edx
shll $0x8, %edx
orl %edx, %ecx
movw %cx, -0x1a(%rbp)
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x1a(%rbp), %esi
callq 0xe4a0
movq -0x28(%rbp), %rdi
movb %al, %cl
movl -0x20(%rbp), %eax
movzbl %cl, %ecx
subl %ecx, %eax
movb %al, -0x1b(%rbp)
movl $0x1, %esi
callq 0x9b00
movzbl -0x1b(%rbp), %eax
cmpl $0x0, %eax
jne 0x7b9b
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x7ba6
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x1b(%rbp), %eax
cmpl $0x80, %eax
jl 0x7bc1
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x7bcc
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x1a(%rbp), %esi
callq 0xe4a0
movb %al, %cl
movl -0x2c(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x7bfa
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
movzwl %ax, %esi
callq 0xe4a0
movq -0x20(%rbp), %rdi
movb %al, %cl
movl -0x18(%rbp), %eax
movzbl %cl, %ecx
subl %ecx, %eax
movb %al, -0x12(%rbp)
movl $0x1, %esi
callq 0x9b00
movzbl -0x12(%rbp), %eax
cmpl $0x0, %eax
jne 0x7c90
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x7c9b
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x12(%rbp), %eax
cmpl $0x80, %eax
jl 0x7cb6
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x7cc1
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
movzwl %ax, %esi
callq 0xe4a0
movb %al, %cl
movl -0x24(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x7cf2
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movq -0x20(%rbp), %rdi
movb %al, -0x11(%rbp)
movw 0x6(%rdi), %ax
addw $0x1, %ax
movw %ax, 0x6(%rdi)
movzbl (%rdi), %eax
movzbl -0x11(%rbp), %ecx
subl %ecx, %eax
movb %al, -0x12(%rbp)
movl $0x1, %esi
callq 0x9b00
movzbl -0x12(%rbp), %eax
cmpl $0x0, %eax
jne 0x7d73
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x7d7e
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x12(%rbp), %eax
cmpl $0x80, %eax
jl 0x7d99
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x7da4
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movzbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jge 0x7dbe
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0x12(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0x14(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzwl -0x12(%rbp), %ecx
movzwl -0x14(%rbp), %edx
shll $0x8, %edx
orl %edx, %ecx
movw %cx, -0x16(%rbp)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x16(%rbp), %esi
callq 0xe4a0
movq -0x28(%rbp), %rdi
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %ecx
subl %ecx, %eax
movb %al, -0x17(%rbp)
movl $0x1, %esi
callq 0x9b00
movzbl -0x17(%rbp), %eax
cmpl $0x0, %eax
jne 0x7e98
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x7ea3
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x17(%rbp), %eax
cmpl $0x80, %eax
jl 0x7ebe
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x7ec9
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x16(%rbp), %esi
callq 0xe4a0
movb %al, %cl
movl -0x2c(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x7ef7
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzbl 0x2(%rax), %ecx
movw %cx, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0x14(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0xe4a0
movzbl %al, %eax
movw %ax, -0x16(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movw %dx, %ax
movzwl %ax, %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0x18(%rbp)
movzwl -0x16(%rbp), %ecx
movzwl -0x18(%rbp), %edx
shll $0x8, %edx
orl %edx, %ecx
movw %cx, -0x1a(%rbp)
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x1a(%rbp), %eax
movzwl -0x12(%rbp), %ecx
addl %ecx, %eax
movzwl %ax, %esi
callq 0xe4a0
movq -0x28(%rbp), %rdi
movb %al, %cl
movl -0x20(%rbp), %eax
movzbl %cl, %ecx
subl %ecx, %eax
movb %al, -0x1b(%rbp)
movl $0x1, %esi
callq 0x9b00
movzbl -0x1b(%rbp), %eax
cmpl $0x0, %eax
jne 0x7ff2
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x7ffd
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x1b(%rbp), %eax
cmpl $0x80, %eax
jl 0x8018
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x8023
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x1a(%rbp), %eax
movzwl -0x12(%rbp), %ecx
addl %ecx, %eax
movzwl %ax, %esi
callq 0xe4a0
movb %al, %cl
movl -0x2c(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x805a
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movq -0x28(%rbp), %rcx
movb %al, -0x11(%rbp)
movb 0x1(%rcx), %al
movb %al, -0x12(%rbp)
movw 0x6(%rcx), %ax
addw $0x1, %ax
movw %ax, 0x6(%rcx)
movzbl -0x11(%rbp), %eax
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movw %dx, %cx
movw %cx, -0x14(%rbp)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0xe4a0
movq -0x28(%rbp), %rdi
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %ecx
subl %ecx, %eax
movb %al, -0x15(%rbp)
movl $0x1, %esi
callq 0x9b00
movzbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0x810e
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x8119
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x15(%rbp), %eax
cmpl $0x80, %eax
jl 0x8134
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x813f
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0xe4a0
movb %al, %cl
movl -0x2c(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x816d
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, -0x11(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, -0x12(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzbl -0x11(%rbp), %ecx
movzbl -0x12(%rbp), %edx
shll $0x8, %edx
orl %edx, %ecx
movw %cx, -0x14(%rbp)
movzbl 0x2(%rax), %edx
movzwl -0x14(%rbp), %ecx
addl %edx, %ecx
movw %cx, -0x14(%rbp)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0xe4a0
movq -0x28(%rbp), %rdi
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %ecx
subl %ecx, %eax
movb %al, -0x15(%rbp)
movl $0x1, %esi
callq 0x9b00
movzbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0x824e
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x8259
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x15(%rbp), %eax
cmpl $0x80, %eax
jl 0x8274
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x827f
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0xe4a0
movb %al, %cl
movl -0x2c(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x82ad
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::cmp_absolute_x(NES::MemoryUnit&)
void CPU::cmp_absolute_x(MemoryUnit &r) {
    // Compare 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;
    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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, -0x11(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, -0x12(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzbl -0x11(%rbp), %ecx
movzbl -0x12(%rbp), %edx
shll $0x8, %edx
orl %edx, %ecx
movw %cx, -0x14(%rbp)
movzbl 0x1(%rax), %edx
movzwl -0x14(%rbp), %ecx
addl %edx, %ecx
movw %cx, -0x14(%rbp)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0xe4a0
movq -0x28(%rbp), %rdi
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %ecx
subl %ecx, %eax
movb %al, -0x15(%rbp)
movl $0x1, %esi
callq 0x9b00
movzbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0x838e
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x8399
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x15(%rbp), %eax
cmpl $0x80, %eax
jl 0x83b4
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x83bf
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0xe4a0
movb %al, %cl
movl -0x2c(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0x83ed
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
movzwl %ax, %esi
callq 0xe4a0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x12(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzbl -0x12(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x8477
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b00
jmp 0x8482
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
movzbl -0x12(%rbp), %eax
shll %eax
movb %al, -0x12(%rbp)
movzbl -0x12(%rbp), %eax
cmpl $0x0, %eax
jne 0x84a4
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x84af
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x12(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x84cd
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x84d8
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
movzwl %ax, %esi
movzbl -0x12(%rbp), %edx
callq 0xe420
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movw 0x6(%rdi), %ax
addw $0x1, %ax
movw %ax, 0x6(%rdi)
callq 0x9bf0
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x854a
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b00
jmp 0x8555
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
movzbl -0x11(%rbp), %eax
shll %eax
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0x8577
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x8582
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x11(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x85a0
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x85ab
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x20(%rbp), %rdi
movzbl -0x11(%rbp), %esi
callq 0x9c00
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x12(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzbl -0x12(%rbp), %eax
shll $0x8, %eax
movzbl -0x11(%rbp), %ecx
orl %ecx, %eax
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0xe4a0
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x8667
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b00
jmp 0x8672
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
movzbl -0x15(%rbp), %eax
shll %eax
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0x8694
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x869f
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x15(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x86bd
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x86c8
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x10(%rbp), %rdi
movw -0x14(%rbp), %ax
movzwl %ax, %esi
movzbl -0x15(%rbp), %edx
callq 0xe420
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movb 0x1(%rax), %cl
movb %cl, -0x12(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzbl -0x11(%rbp), %eax
movzbl -0x12(%rbp), %ecx
addl %ecx, %eax
movb %al, -0x13(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x13(%rbp), %eax
movzwl %ax, %esi
callq 0xe4a0
movb %al, -0x14(%rbp)
movzbl -0x14(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x877a
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b00
jmp 0x8785
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
movzbl -0x14(%rbp), %eax
shll %eax
movb %al, -0x14(%rbp)
movzbl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x87a7
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x87b2
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x14(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x87d0
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x87db
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x10(%rbp), %rdi
movzbl -0x13(%rbp), %eax
movzwl %ax, %esi
movzbl -0x14(%rbp), %edx
callq 0xe420
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0x11(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movq -0x20(%rbp), %rcx
movb %al, -0x12(%rbp)
movw 0x6(%rcx), %ax
addw $0x1, %ax
movw %ax, 0x6(%rcx)
movzbl -0x12(%rbp), %eax
shll $0x8, %eax
movzbl -0x11(%rbp), %edx
orl %edx, %eax
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movb %al, -0x13(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x13(%rbp), %eax
movzwl %ax, %esi
callq 0xe4a0
movb %al, -0x14(%rbp)
movzbl -0x14(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x88ad
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b00
jmp 0x88b8
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
movzbl -0x14(%rbp), %eax
shll %eax
movb %al, -0x14(%rbp)
movzbl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x88da
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x88e5
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x14(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x8903
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x890e
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x10(%rbp), %rdi
movzbl -0x13(%rbp), %eax
movzwl %ax, %esi
movzbl -0x14(%rbp), %edx
callq 0xe420
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
movzwl %ax, %esi
callq 0xe4a0
movq -0x20(%rbp), %rdi
movb %al, -0x12(%rbp)
movzbl -0x12(%rbp), %eax
andl $0x80, %eax
movb %al, -0x13(%rbp)
movw 0x6(%rdi), %ax
addw $0x1, %ax
movw %ax, 0x6(%rdi)
movzbl -0x12(%rbp), %eax
shll %eax
movb %al, -0x12(%rbp)
movzbl -0x12(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x9a70
movb %al, %cl
movl -0x18(%rbp), %eax
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, -0x12(%rbp)
movzbl -0x13(%rbp), %eax
cmpl $0x0, %eax
jne 0x89cb
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
jmp 0x89d9
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b00
movzbl -0x12(%rbp), %eax
cmpl $0x0, %eax
jne 0x89f2
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x89fd
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x12(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x8a1b
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x8a26
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
movzwl %ax, %esi
movzbl -0x12(%rbp), %edx
callq 0xe420
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movw 0x6(%rdi), %ax
addw $0x1, %ax
movw %ax, 0x6(%rdi)
callq 0x9bf0
movq -0x20(%rbp), %rdi
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
andl $0x80, %eax
movb %al, -0x12(%rbp)
movzbl -0x11(%rbp), %eax
shll %eax
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x9a70
movb %al, %cl
movl -0x18(%rbp), %eax
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, -0x11(%rbp)
movzbl -0x12(%rbp), %eax
cmpl $0x0, %eax
jne 0x8ab4
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
jmp 0x8ac2
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b00
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0x8adb
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x8ae6
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x11(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x8b04
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x8b0f
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x20(%rbp), %rdi
movzbl -0x11(%rbp), %esi
callq 0x9c00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, -0x11(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, -0x12(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzbl -0x12(%rbp), %eax
shll $0x8, %eax
movzbl -0x11(%rbp), %ecx
orl %ecx, %eax
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0xe4a0
movq -0x28(%rbp), %rdi
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %eax
andl $0x80, %eax
movb %al, -0x16(%rbp)
movzbl -0x15(%rbp), %eax
shll %eax
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x9a70
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, -0x15(%rbp)
movzbl -0x16(%rbp), %eax
cmpl $0x0, %eax
jne 0x8c01
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
jmp 0x8c0f
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9b00
movzbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0x8c28
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x8c33
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x15(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x8c51
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x8c5c
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x10(%rbp), %rdi
movw -0x14(%rbp), %ax
movzwl %ax, %esi
movzbl -0x15(%rbp), %edx
callq 0xe420
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, -0x11(%rbp)
movb 0x1(%rax), %cl
movb %cl, -0x12(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movzbl -0x11(%rbp), %eax
movzbl -0x12(%rbp), %ecx
addl %ecx, %eax
movb %al, -0x13(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x13(%rbp), %eax
movzwl %ax, %esi
callq 0xe4a0
movq -0x28(%rbp), %rdi
movb %al, -0x14(%rbp)
movzbl -0x14(%rbp), %eax
andl $0x80, %eax
movb %al, -0x15(%rbp)
movzbl -0x14(%rbp), %eax
shll %eax
movb %al, -0x14(%rbp)
movzbl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x9a70
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, -0x14(%rbp)
movzbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0x8d34
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
jmp 0x8d42
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9b00
movzbl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x8d5b
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x8d66
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x14(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x8d84
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x8d8f
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x10(%rbp), %rdi
movzbl -0x13(%rbp), %eax
movzwl %ax, %esi
movzbl -0x14(%rbp), %edx
callq 0xe420
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, -0x11(%rbp)
movw 0x6(%rax), %cx
addw $0x1, %cx
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
movzwl 0x6(%rax), %esi
callq 0xe4a0
movq -0x28(%rbp), %rcx
movb %al, -0x12(%rbp)
movw 0x6(%rcx), %ax
addw $0x1, %ax
movw %ax, 0x6(%rcx)
movzbl -0x12(%rbp), %eax
shll $0x8, %eax
movzbl -0x11(%rbp), %edx
orl %edx, %eax
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movb %al, -0x13(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x13(%rbp), %eax
movzwl %ax, %esi
callq 0xe4a0
movq -0x28(%rbp), %rdi
movb %al, -0x14(%rbp)
movzbl -0x14(%rbp), %eax
andl $0x80, %eax
movb %al, -0x15(%rbp)
movzbl -0x14(%rbp), %eax
shll %eax
movb %al, -0x14(%rbp)
movzbl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x9a70
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, -0x14(%rbp)
movzbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0x8e87
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b00
jmp 0x8e95
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9b00
movzbl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x8eae
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9b50
jmp 0x8eb9
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movzbl -0x14(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x8ed7
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x9ba0
jmp 0x8ee2
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x9ba0
movq -0x10(%rbp), %rdi
movzbl -0x13(%rbp), %eax
movzwl %ax, %esi
movzbl -0x14(%rbp), %edx
callq 0xe420
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: nimitbhardwaj[P]KapaNes/./src/cpu.cpp
// Function: NES::CPU::opcodeNotAvailable(unsigned char)
bool CPU::opcodeNotAvailable(uint8_t opcode) {
    if (opcodeBag.find(opcode) == opcodeBag.end()) {
        return true;
    } else {
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x40, %rdi
leaq -0x11(%rbp), %rsi
callq 0x9a10
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x40, %rdi
callq 0x9a40
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x99e0
testb $0x1, %al
jne 0x8f8f
jmp 0x8f95
movb $0x1, -0x1(%rbp)
jmp 0x8f99
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)