LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rsi), %eax
testl %eax, %eax
je 0x2aa7
movq %rsi, %r14
xorl %r15d, %r15d
movq %rsi, %r12
cmpl %eax, %r15d
je 0x2ab6
movq (%r12), %r12
movsbl (%r12), %esi
movq %rbx, %rdi
callq 0x2180
addq $0x8, %r12
incl %r15d
movl 0x8(%r14), %eax
jmp 0x2a84
leaq 0x173a(%rip), %rsi      # 0x41e8
movq %rbx, %rdi
callq 0x2150
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x8(%rdi), %r13d
testl %r13d, %r13d
je 0x2b44
testl %esi, %esi
jle 0x2b65
cmpl %esi, %r13d
jle 0x2b65
movq %rdi, %rbx
incl %esi
callq 0x2668
movq %rax, %r14
xorl %r15d, %r15d
leaq 0x17f6(%rip), %r12      # 0x42f3
cmpl %r13d, %r15d
je 0x2b2a
movsbl (%r14), %esi
movq 0x34b3(%rip), %rdi      # 0x5fc0
callq 0x2180
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
movq 0x10(%r14), %r14
incl %r15d
movl 0x8(%rbx), %r13d
jmp 0x2afd
movq 0x348f(%rip), %rdi      # 0x5fc0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
movq 0x3475(%rip), %rdi      # 0x5fc0
leaq 0x16c1(%rip), %rsi      # 0x4213
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2150
pushq $0x10
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x16c7(%rip), %rsi      # 0x423e
movq %rax, %rdi
callq 0x2260
movq 0x3452(%rip), %rsi      # 0x5fd8
movq 0x343b(%rip), %rdx      # 0x5fc8
movq %rbx, %rdi
callq 0x2200
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpb %sil, %dil
movzbl %sil, %ecx
movl %esi, %r8d
cmovbl %edi, %r8d
negl %r8d
movl $0x1, %r9d
xorl %edx, %edx
movzbl %dil, %esi
leal (%r8,%r9), %eax
cmpl $0x1, %eax
je 0x3136
movl %esi, %eax
divb %r9b
movzbl %ah, %eax
testb %al, %al
jne 0x3131
movl %ecx, %eax
divb %r9b
movzbl %ah, %eax
testb %al, %al
cmovel %r9d, %edx
incl %r9d
jmp 0x310e
movl %edx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpb %sil, %dil
jbe 0x314c
movzbl %dil, %eax
divb %sil
jmp 0x3153
movzbl %sil, %eax
divb %dil
movzbl %ah, %eax
movzbl %al, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
leaq -0x228(%rbp), %rbx
movq %rbx, %rdi
callq 0x21f0
leaq 0x110e(%rip), %rsi      # 0x4293
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x2040
xorl %r15d, %r15d
movl $0xfe, %r12d
leaq 0x1153(%rip), %r14      # 0x42f3
cmpl $0x1f4, %r15d           # imm = 0x1F4
je 0x31e3
movl $0xfa, %r13d
subl $0x1, %r13d
jb 0x31d6
callq 0x2080
cltd
idivl %r12d
leal 0x1(%rdx), %esi
movq %rbx, %rdi
callq 0x2210
movq %rax, %rdi
movq %r14, %rsi
callq 0x2150
jmp 0x31af
movq %rbx, %rdi
callq 0x20d0
incl %r15d
jmp 0x31a0
leaq -0x228(%rbp), %rdi
callq 0x21a0
leaq -0x228(%rbp), %rdi
callq 0x21b0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3211
jmp 0x3211
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rsp, %rbx
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x1338
pushq $-0x1
popq %rbp
cmpl $0x4, %ebp
je 0x118a
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12a2
cmpl %eax, %ebp
je 0x1158
leaq 0xe90(%rip), %rdi       # 0x2004
leaq 0xe98(%rip), %rsi       # 0x2013
leaq 0xea0(%rip), %rcx       # 0x2022
pushq $0x4c
popq %rdx
callq 0x1030
movq %rsp, %rbx
pushq $0x3
popq %rbp
pushq $0x4
popq %r14
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x12c8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12a2
movl %eax, %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x12a2
cmpl %eax, %ebp
jne 0x1231
movq %rsp, %rdi
pushq $0x3
popq %rsi
callq 0x12a2
cmpl $0x4, %eax
je 0x11e0
movq %rsp, %rdi
pushq $0x4
popq %rsi
callq 0x12a2
cmpl $0x3, %eax
jne 0x1285
movq %rsp, %rbx
pushq $0x1
popq %rbp
pushq $0x4
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x12c8
pushq $0x3
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1314
testb %al, %al
je 0x124d
movq %rsp, %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x12a2
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x12a2
cmpl %eax, %ebp
jne 0x1269
xorl %eax, %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xdf5(%rip), %rdi       # 0x202d
leaq 0xdd4(%rip), %rsi       # 0x2013
leaq 0xddc(%rip), %rcx       # 0x2022
pushq $0x4f
jmp 0x1184
leaq 0xe11(%rip), %rdi       # 0x2065
leaq 0xdb8(%rip), %rsi       # 0x2013
leaq 0xdc0(%rip), %rcx       # 0x2022
pushq $0x53
jmp 0x1184
leaq 0xe06(%rip), %rdi       # 0x2076
leaq 0xd9c(%rip), %rsi       # 0x2013
leaq 0xda4(%rip), %rcx       # 0x2022
pushq $0x54
jmp 0x1184
leaq 0xdb8(%rip), %rdi       # 0x2044
leaq 0xd80(%rip), %rsi       # 0x2013
leaq 0xd88(%rip), %rcx       # 0x2022
pushq $0x50
jmp 0x1184
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
callq 0x12a2
movl %eax, %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x12a2
cmpl %eax, %ebp
je 0x130f
movslq %ebp, %rcx
movslq %eax, %rdx
movl 0xfa0(%rbx,%rdx,4), %esi
cmpl %esi, 0xfa0(%rbx,%rcx,4)
jge 0x1303
movl %eax, (%rbx,%rcx,4)
jmp 0x130f
movl %ebp, (%rbx,%rdx,4)
jg 0x130f
incl 0xfa0(%rbx,%rcx,4)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testl %ecx, %ecx
je 0x11cf4
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %edx
movq 0xa2d3(%rip), %r15      # 0x1bfe0
movq (%r15), %rdi
leaq 0x5688(%rip), %rsi      # 0x1739f
xorl %eax, %eax
callq 0x1120
movq (%r15), %rsi
movq %r14, %rdi
callq 0x11d3b
movq %rbx, %rdi
callq 0x12138
movl $0xff, %edi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x28(%rdi)
movl %esi, 0x890(%rdi)
andq $0x0, 0x894(%rdi)
andl $0x0, 0x89c(%rdi)
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
movups %xmm0, 0x10(%rdi)
movq %r8, 0x58(%rdi)
callq 0x122e2
movq %rbx, %rdi
callq 0x12b50
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x12be2
movq %r14, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq 0x52fd(%rip), %rdi      # 0x17453
leaq 0x5302(%rip), %rsi      # 0x1745f
callq 0x1100
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x1224f
leaq -0x50(%rbp), %rax
movb $0x0, 0x10(%rax)
leaq -0x150(%rbp), %r13
xorl %r15d, %r15d
xorl %eax, %eax
cmpl $0x1000, %eax           # imm = 0x1000
je 0x12246
movl %eax, -0x2c(%rbp)
shll $0x4, %eax
movzwl %ax, %edx
movq %r13, %rdi
leaq 0x52c1(%rip), %rsi      # 0x17462
xorl %eax, %eax
callq 0x1040
xorl %r14d, %r14d
cmpq $0x8, %r14
je 0x121b9
cmpq $0x10, %r14
jne 0x121d3
jmp 0x1221f
movq %r13, %rdi
callq 0x1080
movw $0x2d20, -0x150(%rbp,%rax) # imm = 0x2D20
movb $0x0, -0x14e(%rbp,%rax)
leaq (%r15,%r14), %rax
movzwl %ax, %eax
movzbl (%rbx,%rax), %r12d
movq %r13, %rdi
callq 0x1080
leaq (%rax,%rbp), %rdi
addq $-0x150, %rdi           # imm = 0xFEB0
leaq 0x5273(%rip), %rsi      # 0x1746c
movl %r12d, %edx
xorl %eax, %eax
callq 0x1040
movl %r12d, %edi
callq 0x1160
pushq $0x2e
popq %rcx
testl %eax, %eax
je 0x12215
movl %r12d, %ecx
movb %cl, -0x50(%rbp,%r14)
incq %r14
jmp 0x121ab
movq -0x38(%rbp), %rdi
leaq 0x5248(%rip), %rsi      # 0x17472
movq %r13, %rdx
leaq -0x50(%rbp), %rcx
xorl %eax, %eax
callq 0x1120
movl -0x2c(%rbp), %eax
incl %eax
addq $0x10, %r15
jmp 0x12183
movq -0x38(%rbp), %rdi
callq 0x10d0
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
andl $0x0, 0x894(%rdi)
movb $0x0, 0x89e(%rdi)
callq 0x14598
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
movl %r14d, %edx
callq 0x153f8
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x155fc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x15020
movq %rbx, %rdi
movl $0xfffc, %esi           # imm = 0xFFFC
callq 0x145da
movl %eax, %r14d
movq %rbx, %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0x145da
movzbl %al, %eax
shll $0x8, %eax
movzbl %r14b, %ecx
orl %eax, %ecx
movw %cx, 0x898(%rbx)
movq %rbx, %rdi
callq 0x14598
movq %rbx, %rdi
callq 0x14598
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x14598
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x1426c
movl $0x504d4a, 0x62(%rbx)   # imm = 0x504D4A
movq %rbx, %rdi
callq 0x145be
movl %eax, %r14d
movq %rbx, %rdi
callq 0x145be
movzbl %al, %eax
shll $0x8, %eax
movzbl %r14b, %r14d
orl %eax, %r14d
cmpq $0x0, 0x10(%rbx)
je 0x142a9
leaq 0x66(%rbx), %rdi
movzwl %r14w, %edx
leaq 0x2fff(%rip), %rsi      # 0x172a1
xorl %eax, %eax
callq 0x1040
movw %r14w, 0x898(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x142d1
movl $0x504d4a, 0x62(%rbx)   # imm = 0x504D4A
movq %rbx, %rdi
callq 0x145be
movl %eax, %r14d
movq %rbx, %rdi
callq 0x145be
movzbl %al, %eax
shll $0x8, %eax
movzbl %r14b, %ecx
orl %eax, %ecx
cmpq $0x0, 0x10(%rbx)
movzwl %cx, %r14d
je 0x14310
leaq 0x66(%rbx), %rdi
leaq 0x3084(%rip), %rsi      # 0x1738a
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
leal 0x1(%r14), %r15d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x145da
movl %eax, %r14d
movzwl %r15w, %esi
movq %rbx, %rdi
callq 0x145da
movzbl %al, %eax
shll $0x8, %eax
movzbl %r14b, %ecx
orl %eax, %ecx
movw %cx, 0x898(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x14364
movl $0x52534a, 0x62(%rbx)   # imm = 0x52534A
movq %rbx, %rdi
callq 0x145be
movl %eax, %r14d
movq %rbx, %rdi
callq 0x145be
movzbl %al, %eax
shll $0x8, %eax
movzbl %r14b, %r14d
orl %eax, %r14d
cmpq $0x0, 0x10(%rbx)
je 0x143a1
leaq 0x66(%rbx), %rdi
movzwl %r14w, %edx
leaq 0x2f07(%rip), %rsi      # 0x172a1
xorl %eax, %eax
callq 0x1040
movzbl 0x898(%rbx), %esi
movq %rbx, %rdi
callq 0x15020
movzbl 0x899(%rbx), %esi
movq %rbx, %rdi
callq 0x15020
movw %r14w, 0x898(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x14598
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x143ef
movl $0x535452, 0x62(%rbx)   # imm = 0x535452
movq %rbx, %rdi
callq 0x15086
movl %eax, %r14d
movq %rbx, %rdi
callq 0x15086
movl %eax, %r15d
movzbl %r14b, %r14d
shll $0x8, %r14d
movq %rbx, %rdi
callq 0x14598
movzbl %r15b, %r15d
orl %r14d, %r15d
movq %rbx, %rdi
callq 0x14598
movw %r15w, 0x898(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14598
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x1448c
movl $0x495452, 0x62(%rbx)   # imm = 0x495452
movq %rbx, %rdi
callq 0x15086
movb %al, 0x89d(%rbx)
movq %rbx, %rdi
callq 0x15086
movl %eax, %r14d
movq %rbx, %rdi
callq 0x15086
movzbl %al, %eax
shll $0x8, %eax
movzbl %r14b, %ecx
orl %eax, %ecx
movw %cx, 0x898(%rbx)
movq %rbx, %rdi
callq 0x14598
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x14598
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x14560
leaq 0x62(%r14), %rdi
callq 0x10c0
movb %bl, (%r15)
movb 0x89d(%r14), %al
andb $0x7f, %al
andb $-0x80, %bl
orb %al, %bl
movb %bl, 0x89d(%r14)
cmpb $0x0, (%r15)
sete %al
andb $-0x3, %bl
addb %al, %al
orb %bl, %al
movb %al, 0x89d(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x145be
movl %eax, %r14d
cmpq $0x0, 0x10(%rbx)
je 0x146d0
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x2bc9(%rip), %rsi      # 0x17292
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %al
addb %r14b, %al
movzbl %al, %r14d
movq %rbx, %rdi
callq 0x14598
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x145be
movl %eax, %r14d
movq %rbx, %rdi
callq 0x145be
movzbl %al, %eax
shll $0x8, %eax
movzbl %r14b, %r14d
orl %eax, %r14d
cmpq $0x0, 0x10(%rbx)
je 0x1475f
addq $0x66, %rbx
movzwl %r14w, %edx
leaq 0x2b4c(%rip), %rsi      # 0x172a1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, -0x2c(%rbp)
movq %rdi, %rbx
callq 0x145be
movzbl %al, %r12d
movq %rbx, %rdi
callq 0x145be
movzbl %al, %r13d
shll $0x8, %r13d
leal (%r12,%r13), %r14d
cmpq $0x0, 0x10(%rbx)
je 0x147e8
leaq 0x66(%rbx), %rdi
movzbl 0x89b(%rbx), %ecx
leaq 0x2ac9(%rip), %rsi      # 0x172a7
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movzbl 0x89b(%rbx), %r15d
addl %r15d, %r12d
cmpl $0x100, %r12d           # imm = 0x100
jb 0x1480d
movzbl %r12b, %esi
orl %r13d, %esi
movq %rbx, %rdi
callq 0x145da
jmp 0x1481b
cmpb $0x0, -0x2c(%rbp)
je 0x1481b
movq %rbx, %rdi
callq 0x14598
addl %r15d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, -0x2c(%rbp)
movq %rdi, %rbx
callq 0x145be
movzbl %al, %r12d
movq %rbx, %rdi
callq 0x145be
movzbl %al, %r13d
shll $0x8, %r13d
leal (%r12,%r13), %r14d
cmpq $0x0, 0x10(%rbx)
je 0x148b0
leaq 0x66(%rbx), %rdi
movzbl 0x89c(%rbx), %ecx
leaq 0x2a10(%rip), %rsi      # 0x172b6
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movzbl 0x89c(%rbx), %r15d
addl %r15d, %r12d
cmpl $0x100, %r12d           # imm = 0x100
jb 0x148d5
movzbl %r12b, %esi
orl %r13d, %esi
movq %rbx, %rdi
callq 0x145da
jmp 0x148e3
cmpb $0x0, -0x2c(%rbp)
je 0x148e3
movq %rbx, %rdi
callq 0x14598
addl %r15d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x145be
movl %eax, %r14d
cmpq $0x0, 0x10(%rbx)
je 0x1495b
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x2971(%rip), %rsi      # 0x172c5
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %r15b
addb %r14b, %r15b
movzbl %r15b, %esi
incb %r15b
movq %rbx, %rdi
callq 0x145da
movl %eax, %r14d
movzbl %r15b, %esi
movq %rbx, %rdi
callq 0x145da
movzbl %al, %eax
shll $0x8, %eax
movzbl %r14b, %r14d
orl %eax, %r14d
movq %rbx, %rdi
callq 0x14598
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0x145be
cmpq $0x0, 0x10(%rbx)
movzbl %al, %r15d
je 0x14a12
leaq 0x66(%rbx), %rdi
movzbl 0x89c(%rbx), %ecx
leaq 0x28ce(%rip), %rsi      # 0x172d6
movl %r15d, %edx
xorl %eax, %eax
callq 0x1040
leal 0x1(%r15), %r13d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x145da
movzbl %al, %r12d
movzbl %r13b, %esi
movq %rbx, %rdi
callq 0x145da
movzbl %al, %r15d
shll $0x8, %r15d
movzbl 0x89c(%rbx), %r13d
leal (%r12,%r13), %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x14a5c
movzbl %al, %esi
orl %r15d, %esi
movq %rbx, %rdi
callq 0x145da
jmp 0x14a69
testb %r14b, %r14b
je 0x14a69
movq %rbx, %rdi
callq 0x14598
orl %r12d, %r15d
addl %r13d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x145be
movl %eax, %r14d
cmpq $0x0, 0x10(%rbx)
je 0x14afc
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89c(%rbx), %ecx
leaq 0x27f6(%rip), %rsi      # 0x172eb
xorl %eax, %eax
callq 0x1040
movb 0x89c(%rbx), %al
addb %r14b, %al
movzbl %al, %r14d
movq %rbx, %rdi
callq 0x14598
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::adc(unsigned char)
inline void adc(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "ADC");
        if (isSupportBCD() && getStatusD()) {
            int aH = ((R.a & 0b11110000) >> 4) % 10;
            int aL = (R.a & 0b00001111) % 10;
            int vH = ((value & 0b11110000) >> 4) % 10;
            int vL = (value & 0b00001111) % 10;
            aL += vL + (getStatusC() ? 1 : 0);
            int halfCarry = aL / 10 ? 1 : 0;
            aL %= 10;
            aH += vH + halfCarry;
            updateStatusC(aH / 10 ? true : false);
            aH %= 10;
            R.a = (aH << 4) + aL;
            updateStatusZ(R.a == 0);
        } else {
            add(value);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x10(%rdi)
je 0x14bfc
movl $0x434441, 0x62(%rdi)   # imm = 0x434441
cmpl $0x0, 0x890(%rdi)
jne 0x14c11
movzbl 0x89d(%rdi), %ecx
testb $0x8, %cl
jne 0x14c1b
movzbl %sil, %esi
popq %rbp
jmp 0x14cf8
movb 0x89a(%rdi), %al
movzbl %al, %eax
movl %eax, %r8d
shrl $0x4, %r8d
leal -0xa(%r8), %edx
cmpb $-0x60, %al
cmovbl %r8d, %edx
andl $0xf, %eax
movl %eax, %r8d
subl $0xa, %r8d
cmovbl %eax, %r8d
movzbl %sil, %esi
movl %esi, %r9d
shrl $0x4, %r9d
leal -0xa(%r9), %eax
cmpb $-0x60, %sil
cmovbl %r9d, %eax
andl $0xf, %esi
movl %esi, %r9d
subl $0xa, %r9d
cmovbl %esi, %r9d
movl %ecx, %esi
andl $0x1, %esi
addl %r9d, %esi
addl %r8d, %esi
addl %edx, %eax
movl %esi, %r8d
subl $0xa, %r8d
cmovbl %esi, %r8d
sbbl $-0x1, %eax
cmpl $0xa, %eax
setae %dl
andb $-0x4, %cl
orb %dl, %cl
movl $0xa, %esi
xorl %edx, %edx
divl %esi
shll $0x4, %edx
orl %r8d, %edx
movb %dl, 0x89a(%rdi)
sete %al
addb %al, %al
orb %cl, %al
movb %al, 0x89d(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %r14d
movb 0x89d(%rdi), %al
andb $-0x2, %al
orb %r14b, %al
movb %al, 0x89d(%rdi)
testl %edx, %edx
je 0x14cf3
movq %rdi, %rbx
callq 0x14598
cmpq $0x0, 0x10(%rbx)
je 0x14cf3
testb %r14b, %r14b
movl $0x434553, %eax         # imm = 0x434553
movl $0x434c43, %ecx         # imm = 0x434C43
cmovnel %eax, %ecx
movl %ecx, 0x62(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movzbl 0x89a(%rdi), %eax
movzbl 0x89d(%rdi), %r8d
movl %r8d, %ecx
andl $0x1, %ecx
addl %eax, %ecx
addl %esi, %ecx
andb $0x3c, %r8b
movl %ecx, %edx
andb $-0x80, %dl
orb %r8b, %dl
testb %cl, %cl
sete %r8b
addb %r8b, %r8b
xorl %eax, %esi
notl %esi
xorl %ecx, %eax
andl %esi, %eax
shrb %al
andb $0x40, %al
cmpl $0x100, %ecx            # imm = 0x100
setae %sil
orb %dl, %sil
orb %r8b, %sil
orb %al, %sil
movb %sil, 0x89d(%rdi)
movb %cl, 0x89a(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %r14d
movb 0x89d(%rdi), %al
andb $-0x41, %al
movl %r14d, %ecx
shlb $0x6, %cl
orb %al, %cl
movb %cl, 0x89d(%rdi)
testl %edx, %edx
je 0x14d9e
movq %rdi, %rbx
callq 0x14598
cmpq $0x0, 0x10(%rbx)
je 0x14d9e
testb %r14b, %r14b
movl $0x564553, %eax         # imm = 0x564553
movl $0x564c43, %ecx         # imm = 0x564C43
cmovnel %eax, %ecx
movl %ecx, 0x62(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x0, 0x10(%rdi)
je 0x14db6
movl $0x434253, 0x62(%rdi)   # imm = 0x434253
cmpl $0x0, 0x890(%rdi)
jne 0x14dcb
movzbl 0x89d(%rdi), %ecx
testb $0x8, %cl
jne 0x14dd8
notb %sil
movzbl %sil, %esi
popq %rbp
jmp 0x14cf8
movl %ecx, %eax
movb 0x89a(%rdi), %dl
movzbl %dl, %r9d
movl %r9d, %edx
shrl $0x4, %edx
leal -0xa(%rdx), %r8d
cmpb $-0x60, %r9b
cmovbl %edx, %r8d
andl $0xf, %r9d
movl %r9d, %edx
subl $0xa, %edx
cmovbl %r9d, %edx
movzbl %sil, %esi
movl %esi, %r9d
shrl $0x4, %r9d
leal -0xa(%r9), %r10d
cmpb $-0x60, %sil
cmovbl %r9d, %r10d
andl $0xf, %esi
movl %esi, %r9d
subl $0xa, %r9d
cmovbl %esi, %r9d
notl %eax
andl $0x1, %eax
addl %r9d, %eax
subl %eax, %edx
subl %r10d, %r8d
imull $0xa, %r8d, %eax
leal (%rdx,%rax), %esi
andb $-0x4, %cl
testl %esi, %esi
leal 0x64(%rdx,%rax), %eax
cmovnsl %esi, %eax
setns %sil
movl $0xa, %r8d
xorl %edx, %edx
divl %r8d
orb %cl, %sil
shll $0x4, %eax
orl %edx, %eax
movb %al, 0x89a(%rdi)
testb %al, %al
sete %al
addb %al, %al
orb %sil, %al
movb %al, 0x89d(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x0, 0x10(%rdi)
je 0x14e8a
movl $0x444e41, 0x62(%rdi)   # imm = 0x444E41
andb 0x89a(%rdi), %sil
movb %sil, 0x89a(%rdi)
movb 0x89d(%rdi), %al
andb $0x7d, %al
movl %esi, %ecx
andb $-0x80, %cl
orb %al, %cl
testb %sil, %sil
sete %al
addb %al, %al
orb %cl, %al
movb %al, 0x89d(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x0, 0x10(%rdi)
je 0x14ecc
movl $0x41524f, 0x62(%rdi)   # imm = 0x41524F
orb 0x89a(%rdi), %sil
movb %sil, 0x89a(%rdi)
movb 0x89d(%rdi), %al
andb $0x7d, %al
movl %esi, %ecx
andb $-0x80, %cl
orb %al, %cl
testb %sil, %sil
sete %al
addb %al, %al
orb %cl, %al
movb %al, 0x89d(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::eor(unsigned char)
inline void eor(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "EOR");
        R.a ^= value;
        updateStatusN(R.a & 0x80);
        updateStatusZ(R.a == 0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x10(%rdi)
je 0x14f0e
movl $0x524f45, 0x62(%rdi)   # imm = 0x524F45
movb 0x89a(%rdi), %al
movb 0x89d(%rdi), %cl
movl %eax, %edx
xorb %sil, %dl
movb %dl, 0x89a(%rdi)
andb $0x7d, %cl
andb $-0x80, %dl
cmpb %sil, %al
sete %al
addb %al, %al
orb %dl, %al
orb %cl, %al
movb %al, 0x89d(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::cp(char const*, int, unsigned char)
inline void cp(const char* mne, int m, unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, mne);
        updateStatusN((m - value) & 0x80 ? true : false);
        updateStatusZ(m == value);
        updateStatusC(m >= value);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r14d
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x14f7d
leaq 0x62(%rbx), %rdi
callq 0x10c0
movzbl %r15b, %eax
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
movl %r14d, %edx
subb %al, %dl
andb $-0x80, %dl
cmpl %r14d, %eax
sete %al
setle %sil
addb %al, %al
orb %dl, %al
orb %sil, %al
orb %cl, %al
movb %al, 0x89d(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::pl(char const*, unsigned char*)
inline void pl(const char* mne, unsigned char* r)
    {
        if (CB.debugMessage) strcpy(DD.mne, mne);
        consumeClock();
        *r = pull();
        consumeClock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x15067
leaq 0x62(%r14), %rdi
callq 0x10c0
movq %r14, %rdi
callq 0x14598
movq %r14, %rdi
callq 0x15086
movb %al, (%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x14598
nop
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::transfer(char const*, unsigned char, unsigned char*, bool)
inline void transfer(const char* mne, unsigned char src, unsigned char* dst, bool updateStatus)
    {
        if (CB.debugMessage) strcpy(DD.mne, mne);
        *dst = src;
        if (updateStatus) {
            updateStatusN(src & 0x80);
            updateStatusZ(src == 0);
        }
        consumeClock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r15d
movq %rcx, %r12
movl %edx, %r14d
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x150cf
leaq 0x62(%rbx), %rdi
callq 0x10c0
movb %r14b, (%r12)
testb %r15b, %r15b
je 0x150f8
movb 0x89d(%rbx), %al
andb $0x7d, %al
movl %r14d, %ecx
andb $-0x80, %cl
testb %r14b, %r14b
sete %dl
addb %dl, %dl
orb %cl, %dl
orb %al, %dl
movb %dl, 0x89d(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x14598
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::asl(unsigned char)
inline unsigned char asl(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "ASL");
        int work = value;
        work <<= 1;
        unsigned char result = work & 0xFF;
        updateStatusN(result & 0x80);
        updateStatusZ(result == 0);
        updateStatusC(work & 0xFF00 ? true : false);
        consumeClock();
        return result;
    }

// Assembly:
cmpq $0x0, 0x10(%rdi)
je 0x15116
movl $0x4c5341, 0x62(%rdi)   # imm = 0x4C5341
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leal (%rsi,%rsi), %ebx
movb 0x89d(%rdi), %al
andb $0x7c, %al
testb $0x7f, %sil
sete %cl
addb %cl, %cl
rolb %sil
andb $-0x7f, %sil
orb %cl, %sil
orb %al, %sil
movb %sil, 0x89d(%rdi)
callq 0x14598
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::writeMemoryWithDummy(unsigned short, unsigned char, unsigned char)
inline void writeMemoryWithDummy(unsigned short addr, unsigned char before, unsigned char after)
    {
        if (CB.writeMemory) {
            CB.writeMemory(CB.arg, addr, before);
            CB.writeMemory(CB.arg, addr, after);
        }
        consumeClock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x15189
movl %ecx, %r14d
movq 0x58(%rbx), %rdi
movzwl %si, %r15d
movzbl %dl, %edx
movl %r15d, %esi
callq *%rax
movq 0x58(%rbx), %rdi
movzbl %r14b, %edx
movl %r15d, %esi
callq *0x8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14598
nop
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::lsr(unsigned char)
inline unsigned char lsr(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "LSR");
        if (CB.debugMessage && !DD.opp[0]) sprintf(DD.opp, "A<$%02X>", R.a);
        updateStatusC(value & 0x01 ? true : false);
        value &= 0xFE;
        value >>= 1;
        updateStatusN(false);
        updateStatusZ(value == 0);
        consumeClock();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x151d9
movl $0x52534c, 0x62(%rbx)   # imm = 0x52534C
cmpb $0x0, 0x66(%rbx)
jne 0x151d9
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x216c(%rip), %rsi      # 0x1733e
xorl %eax, %eax
callq 0x1040
movl %r14d, %eax
andb $0x1, %al
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
movl %r14d, %r15d
shrb %r15b
cmpb $0x2, %r14b
setb %dl
addb %dl, %dl
orb %al, %dl
orb %cl, %dl
movb %dl, 0x89d(%rbx)
movq %rbx, %rdi
callq 0x14598
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::rol(unsigned char)
inline unsigned char rol(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "ROL");
        if (CB.debugMessage && !DD.opp[0]) sprintf(DD.opp, "A<$%02X>", R.a);
        updateStatusC(value & 0x80 ? true : false);
        value &= 0x7F;
        value <<= 1;
        value |= getStatusC() ? 0x01 : 0x00;
        updateStatusN(value & 0x80 ? true : false);
        updateStatusZ(value == 0);
        consumeClock();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x15253
movl $0x4c4f52, 0x62(%rbx)   # imm = 0x4C4F52
cmpb $0x0, 0x66(%rbx)
jne 0x15253
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x20f2(%rip), %rsi      # 0x1733e
xorl %eax, %eax
callq 0x1040
movb 0x89d(%rbx), %al
andb $0x7c, %al
movl %r14d, %ecx
shrb $0x7, %cl
leal (%r14,%r14), %edx
movl %r14d, %r15d
rolb %r15b
andb $-0x80, %dl
testb %r14b, %r14b
sete %sil
addb %sil, %sil
orb %dl, %sil
orb %al, %sil
orb %cl, %sil
movb %sil, 0x89d(%rbx)
movq %rbx, %rdi
callq 0x14598
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::ror(unsigned char)
inline unsigned char ror(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "ROR");
        if (CB.debugMessage && !DD.opp[0]) sprintf(DD.opp, "A<$%02X>", R.a);
        updateStatusC(value & 0x01 ? true : false);
        value &= 0xFE;
        value >>= 1;
        value |= getStatusC() ? 0x80 : 0x00;
        updateStatusN(value & 0x80 ? true : false);
        updateStatusZ(value == 0);
        consumeClock();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x152db
movl $0x524f52, 0x62(%rbx)   # imm = 0x524F52
cmpb $0x0, 0x66(%rbx)
jne 0x152db
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x206a(%rip), %rsi      # 0x1733e
xorl %eax, %eax
callq 0x1040
movl %r14d, %eax
andb $0x1, %al
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
movl %r14d, %edx
movl %r14d, %r15d
rorb %r15b
shlb $0x7, %dl
testb %r14b, %r14b
sete %sil
addb %sil, %sil
orb %al, %sil
orb %cl, %sil
orb %dl, %sil
movb %sil, 0x89d(%rbx)
movq %rbx, %rdi
callq 0x14598
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::dec(char const*, unsigned char)
inline unsigned char dec(const char* mne, unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, mne);
        value--;
        updateStatusN(value & 0x80);
        updateStatusZ(value == 0);
        consumeClock();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x15342
leaq 0x62(%r14), %rdi
callq 0x10c0
decb %bl
movb 0x89d(%r14), %al
andb $0x7d, %al
movl %ebx, %ecx
andb $-0x80, %cl
testb %bl, %bl
sete %dl
addb %dl, %dl
orb %cl, %dl
orb %al, %dl
movb %dl, 0x89d(%r14)
movq %r14, %rdi
callq 0x14598
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::inc(char const*, unsigned char)
inline unsigned char inc(const char* mne, unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, mne);
        value++;
        updateStatusN(value & 0x80);
        updateStatusZ(value == 0);
        consumeClock();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x15390
leaq 0x62(%r14), %rdi
callq 0x10c0
incb %bl
sete %al
movb 0x89d(%r14), %cl
andb $0x7d, %cl
movl %ebx, %edx
andb $-0x80, %dl
addb %al, %al
orb %dl, %al
orb %cl, %al
movb %al, 0x89d(%r14)
movq %r14, %rdi
callq 0x14598
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::bit(unsigned char)
inline void bit(unsigned char value)
    {
        if (CB.debugMessage) strcpy(DD.mne, "BIT");
        unsigned char w = R.a & value;
        updateStatusN(value & 0b10000000);
        updateStatusV(value & 0b01000000);
        updateStatusZ(w == 0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x10(%rdi)
je 0x153d2
movl $0x544942, 0x62(%rdi)   # imm = 0x544942
movb 0x89d(%rdi), %al
andb $0x3d, %al
movl %esi, %ecx
andb $-0x40, %cl
orb %al, %cl
testb %sil, 0x89a(%rdi)
sete %al
addb %al, %al
orb %cl, %al
movb %al, 0x89d(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::updateStatusI(bool, bool)
inline void updateStatusI(bool i, bool consume = false)
    {
        i ? R.p |= 0b00000100 : R.p &= 0b11111011;
        if (consume) {
            consumeClock();
            if (CB.debugMessage) strcpy(DD.mne, i ? "SEI" : "CLI");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movb 0x89d(%rdi), %al
andb $-0x5, %al
leal (,%r14,4), %ecx
orb %al, %cl
movb %cl, 0x89d(%rdi)
testl %edx, %edx
je 0x15440
movq %rdi, %rbx
callq 0x14598
cmpq $0x0, 0x10(%rbx)
je 0x15440
testb %r14b, %r14b
movl $0x494553, %eax         # imm = 0x494553
movl $0x494c43, %ecx         # imm = 0x494C43
cmovnel %eax, %ecx
movl %ecx, 0x62(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::updateStatusD(bool, bool)
inline void updateStatusD(bool d, bool consume = false)
    {
        d ? R.p |= 0b00001000 : R.p &= 0b11110111;
        if (consume) {
            consumeClock();
            if (CB.debugMessage) strcpy(DD.mne, d ? "SED" : "CLD");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movb 0x89d(%rdi), %al
andb $-0x9, %al
leal (,%r14,8), %ecx
orb %al, %cl
movb %cl, 0x89d(%rdi)
testl %edx, %edx
je 0x1548e
movq %rdi, %rbx
callq 0x14598
cmpq $0x0, 0x10(%rbx)
je 0x1548e
testb %r14b, %r14b
movl $0x444553, %eax         # imm = 0x444553
movl $0x444c43, %ecx         # imm = 0x444C43
cmovnel %eax, %ecx
movl %ecx, 0x62(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop