LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: operator<<(std::ostream&, CircularDoublyLinkedList&)
ostream& operator<<(ostream& screen, CircularDoublyLinkedList& right){
      if (right.isEmpty()) {
        screen << "Listede eleman bulunmuyor. Error Code: 107";
      }else{
        int i=0;
        for(Node* itr=right.head;i != right.size;itr=itr->next,i++)
          screen << itr->data;
      }
      return screen;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a60
testb $0x1, %al
jne 0x31af
jmp 0x31c1
movq -0x8(%rbp), %rdi
leaq 0x202e(%rip), %rsi      # 0x51e8
callq 0x2160
jmp 0x3208
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x3206
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movzbl (%rax), %esi
callq 0x2240
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x31d3
jmp 0x3208
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::printListPositionReverse(int)
void CircularDoublyLinkedList::printListPositionReverse(int index){
      if (isEmpty()) {
        cout << "Listede eleman bulunmuyor. Error Code: 108";
      }else{
        if(index<=0 || index>=size){
          throw invalid_argument("Index 0'dan kucuk, 0'a esit, eleman sayisina esit veya buyuk olamaz. Error Code: 109");
        }else{
          int i=0;
    			for(Node* itr = FindPreNode(index+1);i != size;itr=itr->prev,i++)
    				cout<<itr->data<<" ";
    			cout<<endl;
        }
      }
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x2a60
testb $0x1, %al
jne 0x3242
jmp 0x325a
movq 0x4d77(%rip), %rdi      # 0x7fc0
leaq 0x1fc3(%rip), %rsi      # 0x5213
callq 0x2160
jmp 0x3330
cmpl $0x0, -0xc(%rbp)
jle 0x326c
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jl 0x32bc
movl $0x10, %edi
callq 0x20c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x1fb7(%rip), %rsi      # 0x523e
callq 0x2310
jmp 0x328e
movq -0x38(%rbp), %rdi
movq 0x4d3f(%rip), %rsi      # 0x7fd8
movq 0x4d28(%rip), %rdx      # 0x7fc8
callq 0x22a0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
jmp 0x3336
movq -0x30(%rbp), %rdi
movl $0x0, -0x20(%rbp)
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x2930
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x8(%rcx), %eax
je 0x331b
movq -0x28(%rbp), %rax
movq 0x4cd3(%rip), %rdi      # 0x7fc0
movzbl (%rax), %esi
callq 0x2240
movq %rax, %rdi
leaq 0x1ff4(%rip), %rsi      # 0x52f3
callq 0x2160
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x32d6
movq 0x4c9e(%rip), %rdi      # 0x7fc0
movq 0x4c87(%rip), %rsi      # 0x7fb0
callq 0x2190
jmp 0x3330
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x22c0
nop
// File: fatiiates[P]CDLL-with-cpp-make-gcc/./src/Test.cpp
// Function: obeb(unsigned char, unsigned char)
int obeb(unsigned char n1, unsigned char n2){
  int largest = 0;
  for(int i=1; i <= n1 && i <= n2; i++)
    if(n1%i==0 && n2%i==0)
      largest = i;
  return largest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movzbl -0x1(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0xd(%rbp)
jg 0x3f1d
movl -0xc(%rbp), %eax
movzbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
setle %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x3f26
jmp 0x3f53
movzbl -0x1(%rbp), %eax
cltd
idivl -0xc(%rbp)
cmpl $0x0, %edx
jne 0x3f46
movzbl -0x2(%rbp), %eax
cltd
idivl -0xc(%rbp)
cmpl $0x0, %edx
jne 0x3f46
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x3f48
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3efe
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: fatiiates[P]CDLL-with-cpp-make-gcc/./src/Test.cpp
// Function: mod(unsigned char, unsigned char)
int mod(unsigned char n1, unsigned char n2){
  if(n1 > n2)
    return n1 % n2;
  else
    return n2 % n1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x5(%rbp)
movb %al, -0x6(%rbp)
movzbl -0x5(%rbp), %eax
movzbl -0x6(%rbp), %ecx
cmpl %ecx, %eax
jle 0x3f8c
movzbl -0x5(%rbp), %eax
movzbl -0x6(%rbp), %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
jmp 0x3f9a
movzbl -0x6(%rbp), %eax
movzbl -0x5(%rbp), %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: fatiiates[P]CDLL-with-cpp-make-gcc/./src/Test.cpp
// Function: createSayilar()
void createSayilar(){
  ofstream file;
  file.open ("doc/Sayilar.txt");

  for (int i = 0; i < 500; i++) {
    for (int j = 0; j < 250; j++) {
      int v1 = rand() % 254 + 1;
      file << v1<<" ";
    }
    file << endl;
  }
  file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
leaq -0x200(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x2290
movq -0x220(%rbp), %rdi
leaq 0x12c7(%rip), %rsi      # 0x5293
movl $0x10, %edx
callq 0x2040
jmp 0x3fd8
movl $0x0, -0x210(%rbp)
cmpl $0x1f4, -0x210(%rbp)    # imm = 0x1F4
jge 0x40d5
movl $0x0, -0x214(%rbp)
cmpl $0xfa, -0x214(%rbp)
jge 0x40aa
callq 0x2080
movl %eax, %edx
movslq %edx, %rax
imulq $-0x7efdfbf7, %rax, %rax # imm = 0x81020409
shrq $0x20, %rax
addl %edx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x7, %eax
addl %ecx, %eax
movl %eax, %ecx
shll $0x8, %ecx
addl %eax, %eax
subl %ecx, %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x1(%rax,%rcx), %eax
movl %eax, -0x218(%rbp)
movl -0x218(%rbp), %esi
leaq -0x200(%rbp), %rdi
callq 0x22b0
movq %rax, -0x228(%rbp)
jmp 0x405f
movq -0x228(%rbp), %rdi
leaq 0x1286(%rip), %rsi      # 0x52f3
callq 0x2160
jmp 0x4074
jmp 0x4076
movl -0x214(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x214(%rbp)
jmp 0x3ffc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x208(%rbp)
movl %eax, -0x20c(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x2230
jmp 0x40f8
movq 0x3eff(%rip), %rsi      # 0x7fb0
leaq -0x200(%rbp), %rdi
callq 0x2190
jmp 0x40bf
jmp 0x40c1
movl -0x210(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x210(%rbp)
jmp 0x3fe2
leaq -0x200(%rbp), %rdi
callq 0x2210
jmp 0x40e3
leaq -0x200(%rbp), %rdi
callq 0x2230
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x208(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
nop
// File: ruippeixotog[P]algo-lib/union-find.cpp
// Function: main
int main() {
  int n = 5;
  UnionFind uf(n);

  for(int i = 0; i < n; i++)
    assert(uf.get(i) == i);

  uf.join(3, 4);
  assert(uf.get(3) == uf.get(4));
  assert(uf.get(3) == 4 || uf.get(4) == 3);

  uf.join(1, 4);
  assert(uf.sameSet(1, 3));
  assert(uf.get(1) == uf.get(3));

  return 0;
}

// Assembly:
subq $0x1f58, %rsp           # imm = 0x1F58
movl $0x0, 0x1f54(%rsp)
movl $0x5, 0x1f50(%rsp)
movl 0x1f50(%rsp), %esi
leaq 0x10(%rsp), %rdi
callq 0x1330
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1f50(%rsp), %eax
jge 0x11c7
movl 0xc(%rsp), %esi
leaq 0x10(%rsp), %rdi
callq 0x1350
cmpl 0xc(%rsp), %eax
jne 0x1199
jmp 0x11b8
leaq 0xe64(%rip), %rdi       # 0x2004
leaq 0xe6c(%rip), %rsi       # 0x2013
movl $0x4c, %edx
leaq 0xe6f(%rip), %rcx       # 0x2022
callq 0x1030
jmp 0x11ba
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1176
leaq 0x10(%rsp), %rdi
movl $0x3, %esi
movl $0x4, %edx
callq 0x13b0
leaq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x1350
movl %eax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movl $0x4, %esi
callq 0x1350
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jne 0x1209
jmp 0x1228
leaq 0xe1d(%rip), %rdi       # 0x202d
leaq 0xdfc(%rip), %rsi       # 0x2013
movl $0x4f, %edx
leaq 0xdff(%rip), %rcx       # 0x2022
callq 0x1030
leaq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x1350
movl %eax, %ecx
movb $0x1, %al
cmpl $0x4, %ecx
movb %al, 0x7(%rsp)
je 0x125d
leaq 0x10(%rsp), %rdi
movl $0x4, %esi
callq 0x1350
cmpl $0x3, %eax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1267
jmp 0x1269
jmp 0x1288
leaq 0xdd4(%rip), %rdi       # 0x2044
leaq 0xd9c(%rip), %rsi       # 0x2013
movl $0x50, %edx
leaq 0xd9f(%rip), %rcx       # 0x2022
callq 0x1030
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x13b0
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x3, %edx
callq 0x1490
testb $0x1, %al
jne 0x12b6
jmp 0x12b8
jmp 0x12d7
leaq 0xda6(%rip), %rdi       # 0x2065
leaq 0xd4d(%rip), %rsi       # 0x2013
movl $0x53, %edx
leaq 0xd50(%rip), %rcx       # 0x2022
callq 0x1030
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x1350
movl %eax, (%rsp)
leaq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x1350
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jne 0x1303
jmp 0x1322
leaq 0xd6c(%rip), %rdi       # 0x2076
leaq 0xd02(%rip), %rsi       # 0x2013
movl $0x54, %edx
leaq 0xd05(%rip), %rcx       # 0x2022
callq 0x1030
xorl %eax, %eax
addq $0x1f58, %rsp           # imm = 0x1F58
retq
nopl (%rax)
// File: ruippeixotog[P]algo-lib/union-find.cpp
// Function: UnionFind::join(int, int)
void join(int i, int j) {
    int xRoot = get(i);
    int yRoot = get(j);
    if (xRoot == yRoot) return;
    if (rank[xRoot] < rank[yRoot])
      pset[xRoot] = yRoot;
    else if (rank[xRoot] > rank[yRoot])
      pset[yRoot] = xRoot;
    else {
      pset[yRoot] = xRoot;
      rank[xRoot] = rank[xRoot] + 1;
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x1c(%rsp), %esi
callq 0x1350
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %esi
callq 0x1350
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jne 0x13f9
jmp 0x148b
movq 0x8(%rsp), %rcx
movslq 0x14(%rsp), %rax
movl 0xfa0(%rcx,%rax,4), %eax
movslq 0x10(%rsp), %rdx
cmpl 0xfa0(%rcx,%rdx,4), %eax
jge 0x142b
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %edx
movslq 0x14(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x148b
movq 0x8(%rsp), %rcx
movslq 0x14(%rsp), %rax
movl 0xfa0(%rcx,%rax,4), %eax
movslq 0x10(%rsp), %rdx
cmpl 0xfa0(%rcx,%rdx,4), %eax
jle 0x145d
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %edx
movslq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1489
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %edx
movslq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movslq 0x14(%rsp), %rcx
movl 0xfa0(%rax,%rcx,4), %edx
addl $0x1, %edx
movslq 0x14(%rsp), %rcx
movl %edx, 0xfa0(%rax,%rcx,4)
jmp 0x148b
addq $0x28, %rsp
retq
// File: suzukiplan[P]M6502/test/test.cpp
// Function: check(int, M6502*, TestMMU*, bool)
static void check(int line, M6502* cpu, TestMMU* mmu, bool succeed)
{
    if (!succeed) {
        fprintf(stderr, "TEST FAILED! (line: %d)\n", line);
        printRegister(cpu, stderr);
        mmu->outputMemoryDump();
        exit(255);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1a2d1
movq 0xed49(%rip), %rax      # 0x28fe0
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x918f(%rip), %rsi      # 0x23433
movb $0x0, %al
callq 0x1120
movq -0x10(%rbp), %rdi
movq 0xed2a(%rip), %rax      # 0x28fe0
movq (%rax), %rsi
callq 0x1a2e0
movq -0x18(%rbp), %rdi
callq 0x1acc0
movl $0xff, %edi
callq 0x1110
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::M6502(int, unsigned char (*)(void*, unsigned short), void (*)(void*, unsigned short, unsigned char), void*)
M6502(int mode, unsigned char (*readMemory)(void* arg, unsigned short addr), void (*writeMemory)(void* arg, unsigned short addr, unsigned char value), void* arg)
    {
        this->mode = mode;
        memset(&R, 0, sizeof(R));
        CB.readMemory = readMemory;
        CB.writeMemory = writeMemory;
        CB.debugMessage = NULL;
        CB.consumeClock = NULL;
        CB.breakPoints.clear();
        CB.breakOperands.clear();
        CB.arg = arg;
        setupOperands();
        reset();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x1af50
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x890(%rdi)
movl $0x0, 0x89c(%rdi)
movq $0x0, 0x894(%rdi)
movq -0x18(%rbp), %rax
movq %rax, (%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x28, %rdi
callq 0x1af80
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
callq 0x1afa0
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, 0x58(%rdi)
callq 0x1afc0
jmp 0x1a629
movq -0x48(%rbp), %rdi
callq 0x1b850
jmp 0x1a634
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x1b920
movq -0x30(%rbp), %rdi
callq 0x1150
nopl (%rax,%rax)
// File: suzukiplan[P]M6502/test/test.cpp
// Function: TestMMU::outputMemoryDump()
void outputMemoryDump()
    {
        FILE* fp = fopen("result.dump", "wt");
        if (fp) {
            char buf[256];
            char ascii[17];
            ascii[16] = '\0';
            for (int i = 0; i < 4096; i++) {
                unsigned short addr = i * 16;
                sprintf(buf, "$%04X:", addr);
                for (int j = 0; j < 16; j++) {
                    if (j == 8) strcat(buf, " -");
                    unsigned char c = ram[addr++];
                    sprintf(&buf[strlen(buf)], " %02X", c);
                    ascii[j] = isprint(c) ? c : '.';
                }
                fprintf(fp, "%s : %s\n", buf, ascii);
            }
            fclose(fp);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x148(%rbp)
leaq 0x8806(%rip), %rdi      # 0x234e7
leaq 0x880b(%rip), %rsi      # 0x234f3
callq 0x1100
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1ae63
movb $0x0, -0x120(%rbp)
movl $0x0, -0x134(%rbp)
cmpl $0x1000, -0x134(%rbp)   # imm = 0x1000
jge 0x1ae5a
movl -0x134(%rbp), %eax
shll $0x4, %eax
movw %ax, -0x136(%rbp)
leaq -0x110(%rbp), %rdi
movzwl -0x136(%rbp), %edx
leaq 0x87b4(%rip), %rsi      # 0x234f6
movb $0x0, %al
callq 0x1040
movl $0x0, -0x13c(%rbp)
cmpl $0x10, -0x13c(%rbp)
jge 0x1ae26
cmpl $0x8, -0x13c(%rbp)
jne 0x1ad7c
leaq -0x110(%rbp), %rdi
leaq 0x8786(%rip), %rsi      # 0x234fd
callq 0x1170
movq -0x148(%rbp), %rax
movw -0x136(%rbp), %cx
movw %cx, %dx
addw $0x1, %dx
movw %dx, -0x136(%rbp)
movzwl %cx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x13d(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x1080
leaq -0x110(%rbp), %rdi
addq %rax, %rdi
movzbl -0x13d(%rbp), %edx
leaq 0x8738(%rip), %rsi      # 0x23500
movb $0x0, %al
callq 0x1040
movzbl -0x13d(%rbp), %edi
callq 0x1160
cmpl $0x0, %eax
je 0x1adef
movzbl -0x13d(%rbp), %eax
movl %eax, -0x14c(%rbp)
jmp 0x1adfc
movl $0x2e, %eax
movl %eax, -0x14c(%rbp)
jmp 0x1adfc
movl -0x14c(%rbp), %eax
movb %al, %cl
movslq -0x13c(%rbp), %rax
movb %cl, -0x130(%rbp,%rax)
movl -0x13c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x13c(%rbp)
jmp 0x1ad53
movq -0x10(%rbp), %rdi
leaq -0x110(%rbp), %rdx
leaq -0x130(%rbp), %rcx
leaq 0x86c7(%rip), %rsi      # 0x23506
movb $0x0, %al
callq 0x1120
movl -0x134(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x134(%rbp)
jmp 0x1ad0d
movq -0x10(%rbp), %rdi
callq 0x10d0
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::reset()
void reset()
    {
        R.tickCount = 0;
        R.s = 0;
        consumeClock();
        updateStatusI(true, true);
        updateStatusB(false, true);
        push(0);
        unsigned char pcL = readMemory(0xFFFC);
        unsigned char pcH = readMemory(0xFFFD);
        R.pc = pcH;
        R.pc <<= 8;
        R.pc |= pcL;
        consumeClock();
        consumeClock();
        consumeClock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, 0x894(%rdi)
movb $0x0, 0x89e(%rdi)
callq 0x1e960
movq -0x18(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x20620
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x20a80
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x1fec0
movq -0x18(%rbp), %rdi
movl $0xfffc, %esi           # imm = 0xFFFC
callq 0x1e9f0
movq -0x18(%rbp), %rdi
movb %al, -0x9(%rbp)
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0x1e9f0
movq -0x18(%rbp), %rdi
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
movw %ax, 0x898(%rdi)
movzwl 0x898(%rdi), %eax
shll $0x8, %eax
movw %ax, 0x898(%rdi)
movzbl -0x9(%rbp), %ecx
movzwl 0x898(%rdi), %eax
orl %ecx, %eax
movw %ax, 0x898(%rdi)
callq 0x1e960
movq -0x18(%rbp), %rdi
callq 0x1e960
movq -0x18(%rbp), %rdi
callq 0x1e960
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::jmp_abs(M6502*)
static inline void jmp_abs(M6502* cpu)
    {
        if (cpu->CB.debugMessage) strcpy(cpu->DD.mne, "JMP");
        unsigned char low = cpu->fetch();
        unsigned short addr = cpu->fetch();
        addr <<= 8;
        addr |= low;
        if (cpu->CB.debugMessage) sprintf(cpu->DD.opp, "$%04X", addr);
        cpu->R.pc = addr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e20f
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x51f4(%rip), %rsi      # 0x233fe
callq 0x10c0
movq -0x8(%rbp), %rdi
callq 0x1e9b0
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e9b0
movzbl %al, %eax
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
shll $0x8, %eax
movw %ax, -0xc(%rbp)
movzbl -0x9(%rbp), %ecx
movzwl -0xc(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e26d
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x6, %rdi
movzwl -0xc(%rbp), %edx
leaq 0x5067(%rip), %rsi      # 0x232cd
movb $0x0, %al
callq 0x1040
movw -0xc(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x898(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::jmp_ind(M6502*)
static inline void jmp_ind(M6502* cpu)
    {
        if (cpu->CB.debugMessage) strcpy(cpu->DD.mne, "JMP");
        unsigned char low = cpu->fetch();
        unsigned short addr = cpu->fetch();
        addr <<= 8;
        addr |= low;
        if (cpu->CB.debugMessage) sprintf(cpu->DD.opp, "($%04X)", addr);
        low = cpu->readMemory(addr++);
        addr = cpu->readMemory(addr);
        addr <<= 8;
        addr |= low;
        cpu->R.pc = addr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e2bf
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x5144(%rip), %rsi      # 0x233fe
callq 0x10c0
movq -0x8(%rbp), %rdi
callq 0x1e9b0
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e9b0
movzbl %al, %eax
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
shll $0x8, %eax
movw %ax, -0xc(%rbp)
movzbl -0x9(%rbp), %ecx
movzwl -0xc(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e31d
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x6, %rdi
movzwl -0xc(%rbp), %edx
leaq 0x50ec(%rip), %rsi      # 0x23402
movb $0x0, %al
callq 0x1040
movq -0x8(%rbp), %rdi
movw -0xc(%rbp), %ax
movw %ax, %cx
addw $0x1, %cx
movw %cx, -0xc(%rbp)
movzwl %ax, %esi
callq 0x1e9f0
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movzwl -0xc(%rbp), %esi
callq 0x1e9f0
movzbl %al, %eax
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
shll $0x8, %eax
movw %ax, -0xc(%rbp)
movzbl -0x9(%rbp), %ecx
movzwl -0xc(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xc(%rbp)
movw -0xc(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x898(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::jsr_abs(M6502*)
static inline void jsr_abs(M6502* cpu)
    {
        if (cpu->CB.debugMessage) strcpy(cpu->DD.mne, "JSR");
        unsigned char low = cpu->fetch();
        unsigned short addr = cpu->fetch();
        addr <<= 8;
        addr |= low;
        if (cpu->CB.debugMessage) sprintf(cpu->DD.opp, "$%04X", addr);
        cpu->push(cpu->R.pc & 0xFF);
        cpu->push((cpu->R.pc & 0xFF00) >> 8);
        cpu->R.pc = addr;
        cpu->consumeClock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e3af
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x5060(%rip), %rsi      # 0x2340a
callq 0x10c0
movq -0x8(%rbp), %rdi
callq 0x1e9b0
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e9b0
movzbl %al, %eax
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
shll $0x8, %eax
movw %ax, -0xc(%rbp)
movzbl -0x9(%rbp), %ecx
movzwl -0xc(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e40d
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x6, %rdi
movzwl -0xc(%rbp), %edx
leaq 0x4ec7(%rip), %rsi      # 0x232cd
movb $0x0, %al
callq 0x1040
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl 0x898(%rax), %eax
andl $0xff, %eax
movzbl %al, %esi
callq 0x1fec0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl 0x898(%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movzbl %al, %esi
callq 0x1fec0
movw -0xc(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x898(%rax)
movq -0x8(%rbp), %rdi
callq 0x1e960
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::rts(M6502*)
static inline void rts(M6502* cpu)
    {
        if (cpu->CB.debugMessage) strcpy(cpu->DD.mne, "RTS");
        unsigned short addr = cpu->pull();
        unsigned char low = cpu->pull();
        addr <<= 8;
        cpu->consumeClock();
        addr |= low;
        cpu->consumeClock();
        cpu->R.pc = addr;
        cpu->consumeClock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e49f
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x4f74(%rip), %rsi      # 0x2340e
callq 0x10c0
movq -0x8(%rbp), %rdi
callq 0x1ff80
movzbl %al, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ff80
movb %al, -0xb(%rbp)
movzwl -0xa(%rbp), %eax
shll $0x8, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e960
movzbl -0xb(%rbp), %ecx
movzwl -0xa(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e960
movw -0xa(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x898(%rax)
movq -0x8(%rbp), %rdi
callq 0x1e960
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::rti(M6502*)
static inline void rti(M6502* cpu)
    {
        if (cpu->CB.debugMessage) strcpy(cpu->DD.mne, "RTI");
        cpu->R.p = cpu->pull();
        unsigned char pcL = cpu->pull();
        unsigned char pcH = cpu->pull();
        cpu->R.pc = pcH;
        cpu->R.pc <<= 8;
        cpu->R.pc |= pcL;
        cpu->consumeClock();
        cpu->consumeClock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e59f
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x4e84(%rip), %rsi      # 0x2341e
callq 0x10c0
movq -0x8(%rbp), %rdi
callq 0x1ff80
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x89d(%rax)
movq -0x8(%rbp), %rdi
callq 0x1ff80
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ff80
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x898(%rax)
movq -0x8(%rbp), %rax
movzwl 0x898(%rax), %ecx
shll $0x8, %ecx
movw %cx, 0x898(%rax)
movzbl -0x9(%rbp), %edx
movq -0x8(%rbp), %rax
movzwl 0x898(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x898(%rax)
movq -0x8(%rbp), %rdi
callq 0x1e960
movq -0x8(%rbp), %rdi
callq 0x1e960
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::ld(char const*, unsigned char*, unsigned char)
inline void ld(const char* mne, unsigned char* r, unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, mne);
        *r = value;
        updateStatusN(*r & 0x80);
        updateStatusZ(*r == 0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1e74d
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
movq -0x28(%rbp), %rdi
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e7a0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e880
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::updateStatusN(bool, bool)
inline void updateStatusN(bool n, bool consume = false)
    {
        n ? R.p |= 0b10000000 : R.p &= 0b01111111;
        if (consume) {
            consumeClock();
            if (CB.debugMessage) strcpy(DD.mne, n ? "SEN" : "CLN");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1e7f1
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
orl $0x80, %ecx
movb %cl, 0x89d(%rax)
jmp 0x1e813
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
andl $0x7f, %ecx
movb %cl, 0x89d(%rax)
testb $0x1, -0xa(%rbp)
je 0x1e86c
movq -0x18(%rbp), %rdi
callq 0x1e960
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e86a
movq -0x18(%rbp), %rax
addq $0x60, %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1e850
leaq 0x4a5d(%rip), %rax      # 0x232a7
movq %rax, -0x28(%rbp)
jmp 0x1e85d
leaq 0x4a54(%rip), %rax      # 0x232ab
movq %rax, -0x28(%rbp)
jmp 0x1e85d
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x10c0
jmp 0x1e86c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::updateStatusZ(bool, bool)
inline void updateStatusZ(bool z, bool consume = false)
    {
        z ? R.p |= 0b00000010 : R.p &= 0b11111101;
        if (consume) {
            consumeClock();
            if (CB.debugMessage) strcpy(DD.mne, z ? "SEZ" : "CLZ");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1e8ce
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x89d(%rax)
jmp 0x1e8f3
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
andl $0xfd, %ecx
movb %cl, 0x89d(%rax)
testb $0x1, -0xa(%rbp)
je 0x1e94c
movq -0x18(%rbp), %rdi
callq 0x1e960
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e94a
movq -0x18(%rbp), %rax
addq $0x60, %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1e930
leaq 0x4985(%rip), %rax      # 0x232af
movq %rax, -0x28(%rbp)
jmp 0x1e93d
leaq 0x497c(%rip), %rax      # 0x232b3
movq %rax, -0x28(%rbp)
jmp 0x1e93d
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x10c0
jmp 0x1e94c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::zeroPageX()
inline unsigned short zeroPageX()
    {
        unsigned short addr = fetch();
        if (CB.debugMessage) sprintf(DD.opp, "$%02X,X<$%02X>", addr, R.x);
        addr += R.x;
        addr &= 0xFF;
        consumeClock();
        return addr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1e9b0
movb %al, %cl
movq -0x18(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0xa(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1eba5
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x60, %rdi
addq $0x6, %rdi
movzwl -0xa(%rbp), %edx
movzbl 0x89b(%rax), %ecx
leaq 0x4720(%rip), %rsi      # 0x232be
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
movzbl 0x89b(%rdi), %ecx
movzwl -0xa(%rbp), %eax
addl %ecx, %eax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
andl $0xff, %eax
movw %ax, -0xa(%rbp)
callq 0x1e960
movw -0xa(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::absolute()
inline unsigned short absolute()
    {
        unsigned char low = fetch();
        unsigned short addr = fetch();
        addr <<= 8;
        addr |= low;
        if (CB.debugMessage) sprintf(DD.opp, "$%04X", addr);
        return addr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1e9b0
movq -0x18(%rbp), %rdi
movb %al, -0x9(%rbp)
callq 0x1e9b0
movb %al, %cl
movq -0x18(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0xc(%rbp)
movzwl -0xc(%rbp), %ecx
shll $0x8, %ecx
movw %cx, -0xc(%rbp)
movzbl -0x9(%rbp), %edx
movzwl -0xc(%rbp), %ecx
orl %edx, %ecx
movw %cx, -0xc(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1eca0
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
addq $0x6, %rdi
movzwl -0xc(%rbp), %edx
leaq 0x4634(%rip), %rsi      # 0x232cd
movb $0x0, %al
callq 0x1040
movw -0xc(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::absoluteX(bool)
inline unsigned short absoluteX(bool alwaysPenalty)
    {
        unsigned int low = fetch();
        unsigned short addr = fetch();
        addr <<= 8;
        unsigned short dummyReadAddr = addr;
        addr |= low;
        if (CB.debugMessage) sprintf(DD.opp, "$%04X,X<$%02X>", addr, R.x);
        addr += R.x;
        if (0xFF < R.x + low) {
            // consume a penalty cycle by dummy read
            dummyReadAddr |= (R.x + low) & 0xFF;
            readMemory(dummyReadAddr);
        } else if (alwaysPenalty) {
            consumeClock(); // consume a penalty cycle
        }
        return addr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1e9b0
movq -0x20(%rbp), %rdi
movzbl %al, %eax
movl %eax, -0x10(%rbp)
callq 0x1e9b0
movb %al, %cl
movq -0x20(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0x12(%rbp)
movzwl -0x12(%rbp), %ecx
shll $0x8, %ecx
movw %cx, -0x12(%rbp)
movw -0x12(%rbp), %cx
movw %cx, -0x14(%rbp)
movl -0x10(%rbp), %edx
movzwl -0x12(%rbp), %ecx
orl %edx, %ecx
movw %cx, -0x12(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1ed9c
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x60, %rdi
addq $0x6, %rdi
movzwl -0x12(%rbp), %edx
movzbl 0x89b(%rax), %ecx
leaq 0x453e(%rip), %rsi      # 0x232d3
movb $0x0, %al
callq 0x1040
movq -0x20(%rbp), %rax
movzbl 0x89b(%rax), %edx
movzwl -0x12(%rbp), %ecx
addl %edx, %ecx
movw %cx, -0x12(%rbp)
movzbl 0x89b(%rax), %ecx
addl -0x10(%rbp), %ecx
movl $0xff, %eax
cmpl %ecx, %eax
jae 0x1eded
movq -0x20(%rbp), %rdi
movzbl 0x89b(%rdi), %ecx
addl -0x10(%rbp), %ecx
andl $0xff, %ecx
movzwl -0x14(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x14(%rbp)
movzwl -0x14(%rbp), %esi
callq 0x1e9f0
jmp 0x1edfe
testb $0x1, -0x9(%rbp)
je 0x1edfc
movq -0x20(%rbp), %rdi
callq 0x1e960
jmp 0x1edfe
movw -0x12(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::absoluteY(bool)
inline unsigned short absoluteY(bool alwaysPenalty)
    {
        unsigned int low = fetch();
        unsigned short addr = fetch();
        addr <<= 8;
        unsigned short dummyReadAddr = addr;
        addr |= low;
        if (CB.debugMessage) sprintf(DD.opp, "$%04X,Y<$%02X>", addr, R.y);
        addr += R.y;
        if (0xFF < R.y + low) {
            // consume a penalty cycle by dummy read
            dummyReadAddr |= (R.y + low) & 0xFF;
            readMemory(dummyReadAddr);
        } else if (alwaysPenalty) {
            consumeClock(); // consume a penalty cycle
        }
        return addr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1e9b0
movq -0x20(%rbp), %rdi
movzbl %al, %eax
movl %eax, -0x10(%rbp)
callq 0x1e9b0
movb %al, %cl
movq -0x20(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0x12(%rbp)
movzwl -0x12(%rbp), %ecx
shll $0x8, %ecx
movw %cx, -0x12(%rbp)
movw -0x12(%rbp), %cx
movw %cx, -0x14(%rbp)
movl -0x10(%rbp), %edx
movzwl -0x12(%rbp), %ecx
orl %edx, %ecx
movw %cx, -0x12(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1eefc
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x60, %rdi
addq $0x6, %rdi
movzwl -0x12(%rbp), %edx
movzbl 0x89c(%rax), %ecx
leaq 0x43ed(%rip), %rsi      # 0x232e2
movb $0x0, %al
callq 0x1040
movq -0x20(%rbp), %rax
movzbl 0x89c(%rax), %edx
movzwl -0x12(%rbp), %ecx
addl %edx, %ecx
movw %cx, -0x12(%rbp)
movzbl 0x89c(%rax), %ecx
addl -0x10(%rbp), %ecx
movl $0xff, %eax
cmpl %ecx, %eax
jae 0x1ef4d
movq -0x20(%rbp), %rdi
movzbl 0x89c(%rdi), %ecx
addl -0x10(%rbp), %ecx
andl $0xff, %ecx
movzwl -0x14(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x14(%rbp)
movzwl -0x14(%rbp), %esi
callq 0x1e9f0
jmp 0x1ef5e
testb $0x1, -0x9(%rbp)
je 0x1ef5c
movq -0x20(%rbp), %rdi
callq 0x1e960
jmp 0x1ef5e
movw -0x12(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::indirectX()
inline unsigned short indirectX()
    {
        unsigned char zero = fetch();
        if (CB.debugMessage) sprintf(DD.opp, "($%02X,X<$%02X>)", zero, R.x);
        zero += R.x;
        unsigned char low = readMemory(zero++);
        unsigned short addr = readMemory(zero);
        addr <<= 8;
        addr |= low;
        consumeClock();
        return addr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1e9b0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, -0x9(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1f011
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x60, %rdi
addq $0x6, %rdi
movzbl -0x9(%rbp), %edx
movzbl 0x89b(%rax), %ecx
leaq 0x42e7(%rip), %rsi      # 0x232f1
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
movzbl 0x89b(%rdi), %ecx
movzbl -0x9(%rbp), %eax
addl %ecx, %eax
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
movb %al, %cl
addb $0x1, %cl
movb %cl, -0x9(%rbp)
movzbl %al, %eax
movzwl %ax, %esi
callq 0x1e9f0
movq -0x18(%rbp), %rdi
movb %al, -0xa(%rbp)
movzbl -0x9(%rbp), %eax
movzwl %ax, %esi
callq 0x1e9f0
movq -0x18(%rbp), %rdi
movzbl %al, %eax
movw %ax, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
shll $0x8, %eax
movw %ax, -0xc(%rbp)
movzbl -0xa(%rbp), %ecx
movzwl -0xc(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xc(%rbp)
callq 0x1e960
movw -0xc(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::indirectY(bool)
inline unsigned short indirectY(bool alwaysPenalty)
    {
        unsigned char zero = fetch();
        if (CB.debugMessage) sprintf(DD.opp, "($%02X),Y<$%02X>", zero, R.y);
        unsigned int low = readMemory(zero++);
        unsigned short addr = readMemory(zero);
        addr <<= 8;
        unsigned short dummyReadAddr = addr;
        addr |= low;
        addr += R.y;
        if (0xFF < R.y + low) {
            // consume a penalty cycle by dummy read
            dummyReadAddr |= (R.y + low) & 0xFF;
            readMemory(dummyReadAddr);
        } else if (alwaysPenalty) {
            consumeClock(); // consume a penalty cycle
        }
        return addr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1e9b0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, -0xa(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1f149
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x60, %rdi
addq $0x6, %rdi
movzbl -0xa(%rbp), %edx
movzbl 0x89c(%rax), %ecx
leaq 0x41c0(%rip), %rsi      # 0x23302
movb $0x0, %al
callq 0x1040
movq -0x20(%rbp), %rdi
movb -0xa(%rbp), %al
movb %al, %cl
addb $0x1, %cl
movb %cl, -0xa(%rbp)
movzbl %al, %eax
movzwl %ax, %esi
callq 0x1e9f0
movq -0x20(%rbp), %rdi
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movzbl -0xa(%rbp), %eax
movzwl %ax, %esi
callq 0x1e9f0
movb %al, %cl
movq -0x20(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0x12(%rbp)
movzwl -0x12(%rbp), %ecx
shll $0x8, %ecx
movw %cx, -0x12(%rbp)
movw -0x12(%rbp), %cx
movw %cx, -0x14(%rbp)
movl -0x10(%rbp), %edx
movzwl -0x12(%rbp), %ecx
orl %edx, %ecx
movw %cx, -0x12(%rbp)
movzbl 0x89c(%rax), %edx
movzwl -0x12(%rbp), %ecx
addl %edx, %ecx
movw %cx, -0x12(%rbp)
movzbl 0x89c(%rax), %ecx
addl -0x10(%rbp), %ecx
movl $0xff, %eax
cmpl %ecx, %eax
jae 0x1f1f3
movq -0x20(%rbp), %rdi
movzbl 0x89c(%rdi), %ecx
addl -0x10(%rbp), %ecx
andl $0xff, %ecx
movzwl -0x14(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x14(%rbp)
movzwl -0x14(%rbp), %esi
callq 0x1e9f0
jmp 0x1f204
testb $0x1, -0x9(%rbp)
je 0x1f202
movq -0x20(%rbp), %rdi
callq 0x1e960
jmp 0x1f204
movw -0x12(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::zeroPageY()
inline unsigned short zeroPageY()
    {
        unsigned short addr = fetch();
        if (CB.debugMessage) sprintf(DD.opp, "$%02X,Y<$%02X>", addr, R.y);
        addr += R.y;
        addr &= 0xFF;
        consumeClock();
        return addr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1e9b0
movb %al, %cl
movq -0x18(%rbp), %rax
movzbl %cl, %ecx
movw %cx, -0xa(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1f2f5
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x60, %rdi
addq $0x6, %rdi
movzwl -0xa(%rbp), %edx
movzbl 0x89c(%rax), %ecx
leaq 0x4029(%rip), %rsi      # 0x23317
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
movzbl 0x89c(%rdi), %ecx
movzwl -0xa(%rbp), %eax
addl %ecx, %eax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
andl $0xff, %eax
movw %ax, -0xa(%rbp)
callq 0x1e960
movw -0xa(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::updateStatusC(bool, bool)
inline void updateStatusC(bool c, bool consume = false)
    {
        c ? R.p |= 0b00000001 : R.p &= 0b11111110;
        if (consume) {
            consumeClock();
            if (CB.debugMessage) strcpy(DD.mne, c ? "SEC" : "CLC");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1f74e
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
orl $0x1, %ecx
movb %cl, 0x89d(%rax)
jmp 0x1f773
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
andl $0xfe, %ecx
movb %cl, 0x89d(%rax)
testb $0x1, -0xa(%rbp)
je 0x1f7cc
movq -0x18(%rbp), %rdi
callq 0x1e960
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1f7ca
movq -0x18(%rbp), %rax
addq $0x60, %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1f7b0
leaq 0x3b90(%rip), %rax      # 0x2333a
movq %rax, -0x28(%rbp)
jmp 0x1f7bd
leaq 0x3b87(%rip), %rax      # 0x2333e
movq %rax, -0x28(%rbp)
jmp 0x1f7bd
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x10c0
jmp 0x1f7cc
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::add(unsigned char)
inline void add(unsigned char value)
    {
        int result = (int)R.a + (int)value + (getStatusC() ? 1 : 0);
        updateStatusN(result & 0x80 ? true : false);
        updateStatusZ((result & 0xFF) == 0);
        updateStatusV(~(R.a ^ value) & (R.a ^ result) & 0x80 ? true : false);
        updateStatusC(0xFF < result);
        R.a = (unsigned char)result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movzbl 0x89a(%rdi), %eax
movzbl -0x9(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
callq 0x1f6e0
movq -0x18(%rbp), %rdi
movb %al, %cl
movl -0x20(%rbp), %eax
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movb -0x10(%rbp), %al
shrb $0x7, %al
movzbl %al, %esi
xorl %edx, %edx
movl %edx, -0x1c(%rbp)
callq 0x1e7a0
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rdi
movb -0x10(%rbp), %al
testb %al, %al
sete %al
movzbl %al, %esi
callq 0x1e880
movq -0x18(%rbp), %rdi
movzbl 0x89a(%rdi), %ecx
movzbl -0x9(%rbp), %edx
movl %ecx, %eax
xorl %edx, %eax
notl %eax
movl -0x10(%rbp), %edx
xorl %edx, %ecx
andl %ecx, %eax
sarb $0x7, %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1f8b0
movq -0x18(%rbp), %rdi
movl $0xff, %eax
cmpl -0x10(%rbp), %eax
setl %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1f700
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movb %cl, 0x89a(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::updateStatusV(bool, bool)
inline void updateStatusV(bool v, bool consume = false)
    {
        v ? R.p |= 0b01000000 : R.p &= 0b10111111;
        if (consume) {
            consumeClock();
            if (CB.debugMessage) strcpy(DD.mne, v ? "SEV" : "CLV");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1f8fe
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
orl $0x40, %ecx
movb %cl, 0x89d(%rax)
jmp 0x1f923
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x894, %rcx            # imm = 0x894
addq $0x9, %rcx
movzbl 0x89d(%rax), %ecx
andl $0xbf, %ecx
movb %cl, 0x89d(%rax)
testb $0x1, -0xa(%rbp)
je 0x1f97c
movq -0x18(%rbp), %rdi
callq 0x1e960
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1f97a
movq -0x18(%rbp), %rax
addq $0x60, %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1f960
leaq 0x39e8(%rip), %rax      # 0x23342
movq %rax, -0x28(%rbp)
jmp 0x1f96d
leaq 0x39df(%rip), %rax      # 0x23346
movq %rax, -0x28(%rbp)
jmp 0x1f96d
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x10c0
jmp 0x1f97c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::sbc(unsigned char)
inline void sbc(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "SBC");
        if (isSupportBCD() && getStatusD()) {
            int aH = ((R.a & 0b11110000) >> 4) % 10;
            int aL = (R.a & 0b00001111) % 10;
            int a = aH * 10 + aL;
            int vH = ((value & 0b11110000) >> 4) % 10;
            int vL = (value & 0b00001111) % 10;
            int v = vH * 10 + vL;
            a -= v + (getStatusC() ? 0 : 1);
            if (a < 0) {
                a += 100;
                updateStatusC(false);
            } else {
                updateStatusC(true);
            }
            aH = a / 10;
            aL = a % 10;
            R.a = (aH << 4) + aL;
            updateStatusZ(R.a == 0);
        } else {
            add(value ^ 0xFF); // To ones' complement (tobe two's complement, if carry is set)
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1f9c9
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x3986(%rip), %rsi      # 0x2334a
callq 0x10c0
movq -0x30(%rbp), %rdi
callq 0x1df60
testb $0x1, %al
jne 0x1f9db
jmp 0x1faff
movq -0x30(%rbp), %rdi
callq 0x1f6c0
testb $0x1, %al
jne 0x1f9ed
jmp 0x1faff
movq -0x30(%rbp), %rdi
movzbl 0x89a(%rdi), %eax
andl $0xf0, %eax
sarl $0x4, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
movzbl 0x89a(%rdi), %eax
andl $0xf, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
imull $0xa, -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movzbl -0x9(%rbp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
movzbl -0x9(%rbp), %eax
andl $0xf, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x20(%rbp)
imull $0xa, -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x1f6e0
movl -0x34(%rbp), %ecx
movb %al, %sil
movl $0x1, %eax
xorl %edx, %edx
testb $0x1, %sil
cmovnel %edx, %eax
addl %eax, %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x1faa4
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
addl $0x64, %eax
movl %eax, -0x18(%rbp)
xorl %edx, %edx
movl %edx, %esi
callq 0x1f700
jmp 0x1fab4
movq -0x30(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x1f700
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movl -0x10(%rbp), %eax
shll $0x4, %eax
addl -0x14(%rbp), %eax
movb %al, 0x89a(%rdi)
movzbl 0x89a(%rdi), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e880
jmp 0x1fb14
movq -0x30(%rbp), %rdi
movzbl -0x9(%rbp), %eax
xorl $0xff, %eax
movzbl %al, %esi
callq 0x1f7e0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::and_(unsigned char)
inline void and_(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "AND");
        R.a &= value;
        updateStatusN(R.a & 0x80);
        updateStatusZ(R.a == 0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1fb59
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x37fa(%rip), %rsi      # 0x2334e
callq 0x10c0
movq -0x18(%rbp), %rdi
movzbl -0x9(%rbp), %ecx
movzbl 0x89a(%rdi), %eax
andl %ecx, %eax
movb %al, 0x89a(%rdi)
movzbl 0x89a(%rdi), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e7a0
movq -0x18(%rbp), %rdi
movzbl 0x89a(%rdi), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e880
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::ora(unsigned char)
inline void ora(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "ORA");
        R.a |= value;
        updateStatusN(R.a & 0x80);
        updateStatusZ(R.a == 0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1fbf9
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
addq $0x2, %rdi
leaq 0x375e(%rip), %rsi      # 0x23352
callq 0x10c0
movq -0x18(%rbp), %rdi
movzbl -0x9(%rbp), %ecx
movzbl 0x89a(%rdi), %eax
orl %ecx, %eax
movb %al, 0x89a(%rdi)
movzbl 0x89a(%rdi), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e7a0
movq -0x18(%rbp), %rdi
movzbl 0x89a(%rdi), %eax
cmpl $0x0, %eax
sete %al
movzbl %al, %esi
andl $0x1, %esi
xorl %edx, %edx
callq 0x1e880
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)