LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::dec_zpg(M6502*)
static inline void dec_zpg(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readZeroPage(&addr);
        unsigned char after = cpu->dec("DEC", before);
        cpu->writeMemoryWithDummy(addr, before, after);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x898(%rdi), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rdi)
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1d4b6
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1d4b9
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d4c8
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
movzbl %r14b, %r14d
je 0x1d4ee
leaq 0x66(%rbx), %rdi
leaq 0x3da4(%rip), %rsi      # 0x21288
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movzwl %r14w, %r14d
testq %rax, %rax
je 0x1d508
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1d50b
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d51a
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d536
movl $0x434544, 0x62(%rbx)   # imm = 0x434544
leal -0x1(%r15), %r12d
movb 0x89d(%rbx), %cl
andb $0x7d, %cl
movl %r12d, %edx
andb $-0x80, %dl
testb %r12b, %r12b
sete %sil
addb %sil, %sil
orb %dl, %sil
orb %cl, %sil
movb %sil, 0x89d(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1d575
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d5a1
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
movl %r14d, %esi
callq *%rax
movq 0x58(%rbx), %rdi
movzbl %r12b, %edx
movl %r14d, %esi
callq *0x8(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d5b0
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::dec_zpg_x(M6502*)
static inline void dec_zpg_x(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readZeroPageX(&addr);
        unsigned char after = cpu->dec("DEC", before);
        cpu->writeMemoryWithDummy(addr, before, after);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x898(%rdi), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rdi)
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1d5f4
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1d5f7
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d606
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d630
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x3c65(%rip), %rsi      # 0x2128e
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %r15b
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d646
movq 0x58(%rbx), %rdi
callq *%rax
addb %r14b, %r15b
incl 0x88(%rbx)
movzbl %r15b, %ecx
movq (%rbx), %rax
movzwl %cx, %r14d
testq %rax, %rax
je 0x1d66d
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1d670
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d67f
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d69b
movl $0x434544, 0x62(%rbx)   # imm = 0x434544
leal -0x1(%r15), %r12d
movb 0x89d(%rbx), %cl
andb $0x7d, %cl
movl %r12d, %edx
andb $-0x80, %dl
testb %r12b, %r12b
sete %sil
addb %sil, %sil
orb %dl, %sil
orb %cl, %sil
movb %sil, 0x89d(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1d6da
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d706
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
movl %r14d, %esi
callq *%rax
movq 0x58(%rbx), %rdi
movzbl %r12b, %edx
movl %r14d, %esi
callq *0x8(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d715
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::dec_abs(M6502*)
static inline void dec_abs(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readAbsolute(&addr);
        unsigned char after = cpu->dec("DEC", before);
        cpu->writeMemoryWithDummy(addr, before, after);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x898(%rdi), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rdi)
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1d759
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1d75c
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d76b
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movl 0x898(%rbx), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x1d79c
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1d79f
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d7ae
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
cmpq $0x0, 0x10(%rbx)
movzwl %ax, %r14d
je 0x1d7db
leaq 0x66(%rbx), %rdi
leaq 0x3acc(%rip), %rsi      # 0x2129d
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1d7f1
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1d7f4
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d803
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d81f
movl $0x434544, 0x62(%rbx)   # imm = 0x434544
leal -0x1(%r15), %r12d
movb 0x89d(%rbx), %cl
andb $0x7d, %cl
movl %r12d, %edx
andb $-0x80, %dl
testb %r12b, %r12b
sete %sil
addb %sil, %sil
orb %dl, %sil
orb %cl, %sil
movb %sil, 0x89d(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1d85e
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d88a
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
movl %r14d, %esi
callq *%rax
movq 0x58(%rbx), %rdi
movzbl %r12b, %edx
movl %r14d, %esi
callq *0x8(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d899
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::dec_abs_x(M6502*)
static inline void dec_abs_x(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readAbsoluteX(&addr, true);
        unsigned char after = cpu->dec("DEC", before);
        cpu->writeMemoryWithDummy(addr, before, after);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1eb62
movq (%rbx), %rcx
movzwl %ax, %r14d
testq %rcx, %rcx
je 0x1d8da
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1d8dd
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d8ec
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d908
movl $0x434544, 0x62(%rbx)   # imm = 0x434544
leal -0x1(%r15), %r12d
movb 0x89d(%rbx), %cl
andb $0x7d, %cl
movl %r12d, %edx
andb $-0x80, %dl
testb %r12b, %r12b
sete %sil
addb %sil, %sil
orb %dl, %sil
orb %cl, %sil
movb %sil, 0x89d(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1d947
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d973
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
movl %r14d, %esi
callq *%rax
movq 0x58(%rbx), %rdi
movzbl %r12b, %edx
movl %r14d, %esi
callq *0x8(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d982
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::inc_zpg(M6502*)
static inline void inc_zpg(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readZeroPage(&addr);
        unsigned char after = cpu->inc("INC", before);
        cpu->writeMemoryWithDummy(addr, before, after);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x898(%rdi), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rdi)
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1da8e
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1da91
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1daa0
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
movzbl %r14b, %r14d
je 0x1dac6
leaq 0x66(%rbx), %rdi
leaq 0x37cc(%rip), %rsi      # 0x21288
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movzwl %r14w, %r14d
testq %rax, %rax
je 0x1dae0
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1dae3
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1daf2
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1db0e
movl $0x434e49, 0x62(%rbx)   # imm = 0x434E49
movl %r15d, %r12d
incb %r12b
sete %cl
movb 0x89d(%rbx), %dl
andb $0x7d, %dl
movl %r12d, %esi
andb $-0x80, %sil
addb %cl, %cl
orb %sil, %cl
orb %dl, %cl
movb %cl, 0x89d(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1db49
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1db75
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
movl %r14d, %esi
callq *%rax
movq 0x58(%rbx), %rdi
movzbl %r12b, %edx
movl %r14d, %esi
callq *0x8(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1db84
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::inc_zpg_x(M6502*)
static inline void inc_zpg_x(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readZeroPageX(&addr);
        unsigned char after = cpu->inc("INC", before);
        cpu->writeMemoryWithDummy(addr, before, after);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x898(%rdi), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rdi)
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1dbc8
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1dbcb
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1dbda
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1dc04
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x3691(%rip), %rsi      # 0x2128e
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %r15b
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1dc1a
movq 0x58(%rbx), %rdi
callq *%rax
addb %r14b, %r15b
incl 0x88(%rbx)
movzbl %r15b, %ecx
movq (%rbx), %rax
movzwl %cx, %r14d
testq %rax, %rax
je 0x1dc41
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1dc44
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1dc53
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1dc6f
movl $0x434e49, 0x62(%rbx)   # imm = 0x434E49
movl %r15d, %r12d
incb %r12b
sete %cl
movb 0x89d(%rbx), %dl
andb $0x7d, %dl
movl %r12d, %esi
andb $-0x80, %sil
addb %cl, %cl
orb %sil, %cl
orb %dl, %cl
movb %cl, 0x89d(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1dcaa
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1dcd6
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
movl %r14d, %esi
callq *%rax
movq 0x58(%rbx), %rdi
movzbl %r12b, %edx
movl %r14d, %esi
callq *0x8(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1dce5
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::inc_abs(M6502*)
static inline void inc_abs(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readAbsolute(&addr);
        unsigned char after = cpu->inc("INC", before);
        cpu->writeMemoryWithDummy(addr, before, after);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x898(%rdi), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rdi)
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1dd29
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1dd2c
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1dd3b
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movl 0x898(%rbx), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x1dd6c
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1dd6f
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1dd7e
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
cmpq $0x0, 0x10(%rbx)
movzwl %ax, %r14d
je 0x1ddab
leaq 0x66(%rbx), %rdi
leaq 0x34fc(%rip), %rsi      # 0x2129d
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1ddc1
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1ddc4
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ddd3
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1ddef
movl $0x434e49, 0x62(%rbx)   # imm = 0x434E49
movl %r15d, %r12d
incb %r12b
sete %cl
movb 0x89d(%rbx), %dl
andb $0x7d, %dl
movl %r12d, %esi
andb $-0x80, %sil
addb %cl, %cl
orb %sil, %cl
orb %dl, %cl
movb %cl, 0x89d(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1de2a
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1de56
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
movl %r14d, %esi
callq *%rax
movq 0x58(%rbx), %rdi
movzbl %r12b, %edx
movl %r14d, %esi
callq *0x8(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1de65
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::inc_abs_x(M6502*)
static inline void inc_abs_x(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readAbsoluteX(&addr, true);
        unsigned char after = cpu->inc("INC", before);
        cpu->writeMemoryWithDummy(addr, before, after);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1eb62
movq (%rbx), %rcx
movzwl %ax, %r14d
testq %rcx, %rcx
je 0x1dea6
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1dea9
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1deb8
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1ded4
movl $0x434e49, 0x62(%rbx)   # imm = 0x434E49
movl %r15d, %r12d
incb %r12b
sete %cl
movb 0x89d(%rbx), %dl
andb $0x7d, %dl
movl %r12d, %esi
andb $-0x80, %sil
addb %cl, %cl
orb %sil, %cl
orb %dl, %cl
movb %cl, 0x89d(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1df0f
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1df3b
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
movl %r14d, %esi
callq *%rax
movq 0x58(%rbx), %rdi
movzbl %r12b, %edx
movl %r14d, %esi
callq *0x8(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1df4a
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x1e4af
movl $0x504d4a, 0x62(%rbx)   # imm = 0x504D4A
movl 0x898(%rbx), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x1e4d6
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1e4d9
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e4e8
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movl 0x898(%rbx), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x1e519
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1e51c
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e52b
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %r14d
orl %r15d, %r14d
cmpq $0x0, 0x10(%rbx)
je 0x1e555
leaq 0x66(%rbx), %rdi
movzwl %r14w, %edx
leaq 0x2d4f(%rip), %rsi      # 0x2129d
xorl %eax, %eax
callq 0x1040
movw %r14w, 0x898(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x1e584
movl $0x504d4a, 0x62(%rbx)   # imm = 0x504D4A
movl 0x898(%rbx), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x1e5ab
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1e5ae
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e5bd
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movl 0x898(%rbx), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x1e5ee
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r12d
shll $0x8, %r12d
jmp 0x1e5f1
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e600
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %r15d
orl %r12d, %r15d
cmpq $0x0, 0x10(%rbx)
movzwl %r15w, %r14d
je 0x1e62d
leaq 0x66(%rbx), %rdi
leaq 0x2d07(%rip), %rsi      # 0x2132a
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1e644
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movzbl %al, %r14d
jmp 0x1e647
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e656
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1e67b
incl %r15d
movq 0x58(%rbx), %rdi
movzwl %r15w, %esi
callq *%rax
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1e67e
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e68d
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
movw %ax, 0x898(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x1e6c5
movl $0x52534a, 0x62(%rbx)   # imm = 0x52534A
movl 0x898(%rbx), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x1e6ec
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1e6ef
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e6fe
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movl 0x898(%rbx), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x1e72f
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1e732
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e741
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %r14d
orl %r15d, %r14d
cmpq $0x0, 0x10(%rbx)
je 0x1e76b
leaq 0x66(%rbx), %rdi
movzwl %r14w, %edx
leaq 0x2b39(%rip), %rsi      # 0x2129d
xorl %eax, %eax
callq 0x1040
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1e78e
movzbl 0x898(%rbx), %edx
movzbl 0x89e(%rbx), %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e79d
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movb 0x89e(%rbx), %cl
decb %cl
movb %cl, 0x89e(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1e7d0
movzbl 0x899(%rbx), %edx
movzbl %cl, %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e7e5
movq 0x58(%rbx), %rdi
callq *%rax
movq 0x18(%rbx), %rax
jmp 0x1e7e7
xorl %eax, %eax
movl 0x88(%rbx), %ecx
incl %ecx
movl %ecx, 0x88(%rbx)
decb 0x89e(%rbx)
movw %r14w, 0x898(%rbx)
testq %rax, %rax
je 0x1e814
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %ecx
incl %ecx
movl %ecx, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e843
movl $0x535452, 0x62(%rbx)   # imm = 0x535452
movb 0x89e(%rbx), %cl
incb %cl
movb %cl, 0x89e(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1e872
movzbl %cl, %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movzbl %al, %r14d
shll $0x8, %r14d
jmp 0x1e875
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e884
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movb 0x89e(%rbx), %cl
incb %cl
movb %cl, 0x89e(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1e8b5
movzbl %cl, %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movzbl %al, %r15d
jmp 0x1e8b8
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e936
movq 0x58(%rbx), %rdi
callq *%rax
movq 0x18(%rbx), %rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
testq %rcx, %rcx
je 0x1e93e
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
movq 0x18(%rbx), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x88(%rbx)
movzwl %r15w, %r15d
orl %r14d, %r15d
testq %rcx, %rcx
je 0x1e945
movq 0x58(%rbx), %rdi
callq *%rcx
movq 0x18(%rbx), %rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movw %r15w, 0x898(%rbx)
testq %rcx, %rcx
je 0x1e950
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
jmp 0x1e950
movl 0x88(%rbx), %eax
incl %eax
movzwl %r15w, %r15d
orl %r14d, %r15d
addl $0x2, %eax
movw %r15w, 0x898(%rbx)
incl %eax
movl %eax, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x1e9e5
movl $0x495452, 0x62(%rbx)   # imm = 0x495452
movb 0x89e(%rbx), %cl
incb %cl
movb %cl, 0x89e(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1ea0f
movzbl %cl, %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movl %eax, %r14d
jmp 0x1ea12
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ea21
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movb %r14b, 0x89d(%rbx)
movb 0x89e(%rbx), %cl
incb %cl
movb %cl, 0x89e(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1ea59
movzbl %cl, %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movzbl %al, %r14d
jmp 0x1ea5c
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ea6b
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movb 0x89e(%rbx), %cl
incb %cl
movb %cl, 0x89e(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1eaa0
movzbl %cl, %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1eaa3
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1eb03
movq 0x58(%rbx), %rdi
callq *%rax
movq 0x18(%rbx), %rcx
movl 0x88(%rbx), %eax
leal 0x1(%rax), %edx
movl %edx, 0x88(%rbx)
movzwl %r14w, %edx
orl %r15d, %edx
movw %dx, 0x898(%rbx)
testq %rcx, %rcx
je 0x1eb17
movq 0x58(%rbx), %rdi
callq *%rcx
movq 0x18(%rbx), %rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
testq %rcx, %rcx
je 0x1eb1a
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
jmp 0x1eb1a
movl 0x88(%rbx), %eax
movzwl %r14w, %ecx
orl %r15d, %ecx
movw %cx, 0x898(%rbx)
addl $0x2, %eax
incl %eax
movl %eax, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x898(%rdi), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rdi)
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1eb9d
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r12d
jmp 0x1eba0
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ebaf
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movl 0x898(%rbx), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x1ebe0
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r13d
shll $0x8, %r13d
jmp 0x1ebe3
xorl %r13d, %r13d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ebf2
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movl %r13d, %r15d
orl %r12d, %r15d
cmpq $0x0, 0x10(%rbx)
je 0x1ec21
leaq 0x66(%rbx), %rdi
movzbl 0x89b(%rbx), %ecx
leaq 0x268c(%rip), %rsi      # 0x212a3
movl %r15d, %edx
xorl %eax, %eax
callq 0x1040
movzbl 0x89b(%rbx), %r14d
addl %r14d, %r12d
cmpl $0x100, %r12d           # imm = 0x100
jb 0x1ec4c
movq (%rbx), %rax
testq %rax, %rax
je 0x1ec52
movzbl %r12b, %esi
orl %r13d, %esi
movq 0x58(%rbx), %rdi
callq *%rax
jmp 0x1ec52
cmpb $0x0, -0x2c(%rbp)
je 0x1ec67
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ec61
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
addl %r14d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x898(%rdi), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rdi)
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1ecb7
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r12d
jmp 0x1ecba
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ecc9
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movl 0x898(%rbx), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x1ecfa
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r13d
shll $0x8, %r13d
jmp 0x1ecfd
xorl %r13d, %r13d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ed0c
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movl %r13d, %r15d
orl %r12d, %r15d
cmpq $0x0, 0x10(%rbx)
je 0x1ed3b
leaq 0x66(%rbx), %rdi
movzbl 0x89c(%rbx), %ecx
leaq 0x2581(%rip), %rsi      # 0x212b2
movl %r15d, %edx
xorl %eax, %eax
callq 0x1040
movzbl 0x89c(%rbx), %r14d
addl %r14d, %r12d
cmpl $0x100, %r12d           # imm = 0x100
jb 0x1ed66
movq (%rbx), %rax
testq %rax, %rax
je 0x1ed6c
movzbl %r12b, %esi
orl %r13d, %esi
movq 0x58(%rbx), %rdi
callq *%rax
jmp 0x1ed6c
cmpb $0x0, -0x2c(%rbp)
je 0x1ed81
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ed7b
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
addl %r14d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x898(%rdi), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rdi)
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1edc9
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1edcc
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1eddb
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1ee05
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x24c3(%rip), %rsi      # 0x212c1
xorl %eax, %eax
callq 0x1040
addb 0x89b(%rbx), %r14b
movq (%rbx), %rax
testq %rax, %rax
je 0x1ee24
movq 0x58(%rbx), %rdi
movzbl %r14b, %esi
callq *%rax
movzbl %al, %r15d
jmp 0x1ee27
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ee36
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1ee5b
incb %r14b
movq 0x58(%rbx), %rdi
movzbl %r14b, %esi
callq *%rax
movzbl %al, %r14d
shll $0x8, %r14d
jmp 0x1ee5e
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ee92
movq 0x58(%rbx), %rdi
callq *%rax
movq 0x18(%rbx), %rax
movl 0x88(%rbx), %ecx
incl %ecx
movl %ecx, 0x88(%rbx)
testq %rax, %rax
je 0x1ee9a
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %ecx
jmp 0x1ee9a
movl 0x88(%rbx), %ecx
incl %ecx
movzwl %r15w, %eax
orl %r14d, %eax
incl %ecx
movl %ecx, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x898(%rdi), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rdi)
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1eeee
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1eef1
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ef00
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
movzbl %r15b, %r12d
je 0x1ef2d
leaq 0x66(%rbx), %rdi
movzbl 0x89c(%rbx), %ecx
leaq 0x23af(%rip), %rsi      # 0x212d2
movl %r12d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1ef44
movq 0x58(%rbx), %rdi
movl %r12d, %esi
callq *%rax
movzbl %al, %r12d
jmp 0x1ef47
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ef56
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1ef7b
incb %r15b
movq 0x58(%rbx), %rdi
movzbl %r15b, %esi
callq *%rax
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1ef7e
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ef8d
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movzbl 0x89c(%rbx), %r13d
leal (%r12,%r13), %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x1efd4
movq (%rbx), %rax
testq %rax, %rax
je 0x1efc3
movzbl %cl, %esi
orl %r15d, %esi
movq 0x58(%rbx), %rdi
callq *%rax
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1efe8
movq 0x58(%rbx), %rdi
callq *%rax
jmp 0x1efe8
testb %r14b, %r14b
je 0x1eff6
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1efee
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f020
movl $0x434441, 0x62(%rdi)   # imm = 0x434441
cmpl $0x0, 0x890(%rdi)
setne %dl
movb 0x89a(%rdi), %r8b
movb 0x89d(%rdi), %al
movzbl %al, %ecx
testb $0x8, %cl
sete %r9b
orb %dl, %r9b
movzbl %r8b, %edx
je 0x1f09a
movzbl %sil, %esi
andl $0x1, %ecx
addl %edx, %ecx
addl %esi, %ecx
andb $0x3c, %al
movl %ecx, %r8d
andb $-0x80, %r8b
orb %al, %r8b
testb %cl, %cl
sete %al
addb %al, %al
xorl %edx, %esi
notl %esi
xorl %ecx, %edx
andl %esi, %edx
shrb %dl
andb $0x40, %dl
cmpl $0x100, %ecx            # imm = 0x100
setae %sil
orb %r8b, %sil
orb %al, %sil
orb %dl, %sil
movb %sil, 0x89d(%rdi)
movb %cl, 0x89a(%rdi)
jmp 0x1f12c
movl %edx, %r9d
shrl $0x4, %r9d
leal -0xa(%r9), %r8d
cmpb $-0x60, %dl
cmovbl %r9d, %r8d
andl $0xf, %edx
movl %edx, %r9d
subl $0xa, %r9d
cmovbl %edx, %r9d
movzbl %sil, %esi
movl %esi, %r10d
shrl $0x4, %r10d
leal -0xa(%r10), %edx
cmpb $-0x60, %sil
cmovbl %r10d, %edx
andl $0xf, %esi
movl %esi, %r10d
subl $0xa, %r10d
cmovbl %esi, %r10d
andl $0x1, %ecx
addl %r10d, %ecx
addl %r9d, %ecx
addl %r8d, %edx
movl %ecx, %esi
subl $0xa, %esi
cmovbl %ecx, %esi
sbbl $-0x1, %edx
cmpl $0xa, %edx
setae %cl
andb $-0x4, %al
orb %cl, %al
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rdx, %rcx
shrq $0x23, %rcx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %edx
shll $0x4, %edx
orl %esi, %edx
movb %dl, 0x89a(%rdi)
sete %cl
addb %cl, %cl
orb %al, %cl
movb %cl, 0x89d(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f140
movl $0x434253, 0x62(%rdi)   # imm = 0x434253
cmpl $0x0, 0x890(%rdi)
setne %cl
movb 0x89d(%rdi), %al
movzbl %al, %eax
testb $0x8, %al
sete %dl
orb %cl, %dl
je 0x1f1b8
notb %sil
movzbl 0x89a(%rdi), %ecx
movzbl %sil, %esi
movl %eax, %edx
andl $0x1, %edx
addl %ecx, %edx
addl %esi, %edx
andb $0x3c, %al
movl %edx, %r8d
andb $-0x80, %r8b
orb %al, %r8b
testb %dl, %dl
sete %al
addb %al, %al
xorl %ecx, %esi
notl %esi
xorl %edx, %ecx
andl %esi, %ecx
shrb %cl
andb $0x40, %cl
cmpl $0x100, %edx            # imm = 0x100
setae %sil
orb %r8b, %sil
orb %al, %sil
orb %cl, %sil
movb %sil, 0x89d(%rdi)
movb %dl, 0x89a(%rdi)
jmp 0x1f259
movb 0x89a(%rdi), %cl
movzbl %cl, %r8d
movl %r8d, %ecx
shrl $0x4, %ecx
leal -0xa(%rcx), %edx
cmpb $-0x60, %r8b
cmovbl %ecx, %edx
andl $0xf, %r8d
movl %r8d, %ecx
subl $0xa, %ecx
cmovbl %r8d, %ecx
movzbl %sil, %esi
movl %esi, %r8d
shrl $0x4, %r8d
leal -0xa(%r8), %r9d
cmpb $-0x60, %sil
cmovbl %r8d, %r9d
andl $0xf, %esi
movl %esi, %r8d
subl $0xa, %r8d
cmovbl %esi, %r8d
movl %eax, %esi
notl %esi
andl $0x1, %esi
addl %r8d, %esi
subl %esi, %ecx
subl %r9d, %edx
leal (%rdx,%rdx,4), %edx
leal (%rcx,%rdx,2), %esi
andb $-0x4, %al
testl %esi, %esi
leal 0x64(%rcx,%rdx,2), %ecx
cmovnsl %esi, %ecx
setns %dl
orb %al, %dl
movl $0xcccccccd, %eax       # imm = 0xCCCCCCCD
imulq %rcx, %rax
shrq $0x23, %rax
leal (%rax,%rax), %esi
leal (%rsi,%rsi,4), %esi
subl %esi, %ecx
shll $0x4, %eax
orl %ecx, %eax
movb %al, 0x89a(%rdi)
testb %al, %al
sete %al
addb %al, %al
orb %dl, %al
movb %al, 0x89d(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::branch(char const*, bool)
inline void branch(const char* mne, bool isBranch)
    {
        if (CB.debugMessage) strcpy(DD.mne, mne);
        int rel = (signed char)fetch();
        if (0 == rel) {
            if (CB.onError) CB.onError(CB.arg, M6502_ERROR_BRANCH_ZERO);
        }
        if (CB.debugMessage) sprintf(DD.opp, "$%04X%s$%02X", R.pc, rel & 0x80 ? "-" : "+", abs(rel));
        if (!isBranch) return; // not branch
        if ((R.pc & 0xFF00) != ((R.pc + rel) & 0xFF00)) {
            consumeClock(); // consume a penalty cycle (page crossover)
        }
        R.pc += rel;
        consumeClock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x1f27d
leaq 0x62(%rbx), %rdi
callq 0x10a0
movl 0x898(%rbx), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x898(%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x1f2a3
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1f2a6
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1f2b5
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
testb %r15b, %r15b
jne 0x1f2d4
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x1f2d4
movq 0x58(%rbx), %rdi
movl $0xdead0002, %esi       # imm = 0xDEAD0002
callq *%rax
movsbl %r15b, %r12d
cmpq $0x0, 0x10(%rbx)
je 0x1f317
leaq 0x66(%rbx), %rdi
movzwl 0x898(%rbx), %edx
testb %r15b, %r15b
leaq 0x2018(%rip), %rax      # 0x2130c
leaq 0x210f(%rip), %rcx      # 0x2140a
cmovnsq %rax, %rcx
movl %r12d, %r8d
negl %r8d
cmovsl %r12d, %r8d
leaq 0x1fef(%rip), %rsi      # 0x212ff
xorl %eax, %eax
callq 0x1040
testb %r14b, %r14b
je 0x1f370
movzwl 0x898(%rbx), %ecx
leal (%rcx,%r12), %edx
xorl %ecx, %edx
movq 0x18(%rbx), %rax
testl $0xff00, %edx           # imm = 0xFF00
je 0x1f355
testq %rax, %rax
je 0x1f34d
movq 0x58(%rbx), %rdi
callq *%rax
movzwl 0x898(%rbx), %ecx
movq 0x18(%rbx), %rax
jmp 0x1f34f
xorl %eax, %eax
incl 0x88(%rbx)
addl %r12d, %ecx
movw %cx, 0x898(%rbx)
testq %rax, %rax
je 0x1f36a
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::executeInterrupt(unsigned short, bool)
inline void executeInterrupt(unsigned short addr, bool isBreak)
    {
        unsigned char pcH = (R.pc & 0xFF00) >> 8;
        unsigned char pcL = R.pc & 0x00FF;
        push(pcH);
        push(pcL);
        push(R.p);
        updateStatusI(true);
        updateStatusB(isBreak);
        pcL = readMemory(addr);
        pcH = readMemory(addr + 1);
        R.pc = pcH;
        R.pc <<= 8;
        R.pc |= pcL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
movzwl 0x898(%rdi), %r12d
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1f3b9
movzwl %r12w, %edx
shrl $0x8, %edx
movzbl 0x89e(%rbx), %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1f3c8
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movb 0x89e(%rbx), %cl
decb %cl
movb %cl, 0x89e(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1f3f8
movzbl %cl, %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
movzbl %r12b, %edx
callq *%rax
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1f407
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movb 0x89e(%rbx), %cl
decb %cl
movb %cl, 0x89e(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1f43a
movzbl 0x89d(%rbx), %edx
movzbl %cl, %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1f449
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
decb 0x89e(%rbx)
movb 0x89d(%rbx), %al
andb $-0x15, %al
shlb $0x4, %r15b
orb %al, %r15b
orb $0x4, %r15b
movb %r15b, 0x89d(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1f487
movq 0x58(%rbx), %rdi
movzwl %r14w, %esi
callq *%rax
movzbl %al, %r15d
jmp 0x1f48a
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1f499
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1f4be
incl %r14d
movq 0x58(%rbx), %rdi
movzwl %r14w, %esi
callq *%rax
movzbl %al, %r14d
shll $0x8, %r14d
jmp 0x1f4c1
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1f4d0
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r15w, %eax
orl %r14d, %eax
movw %ax, 0x898(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cssartori[P]ga-qap/src/datafile.cpp
// Function: DataFile::write_solution(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Solution const&)
int DataFile::write_solution(const std::string& filename, const Solution& s){
	FILE *file = fopen(filename.c_str(), "wt");
	
	if(file == NULL)
		return -1;

	fprintf(file, "%li %i\n", n, s.fitness());
	for(size_t i=0;i<n;i++){
		fprintf(file, "%i ", s[i]);
	}
	fprintf(file, "\n");

	fclose(file);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
leaq 0x591a(%rip), %rsi      # 0x8049
callq 0x21c0
testq %rax, %rax
je 0x27ab
movq %rax, %r15
movq 0x30(%r14), %r12
movq %rbx, %rdi
callq 0x3746
leaq 0x58fd(%rip), %rsi      # 0x804c
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0x2200
cmpq $0x0, 0x30(%r14)
je 0x2794
leaq 0x58e6(%rip), %r12      # 0x8054
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x373c
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x2200
incq %r13
cmpq 0x30(%r14), %r13
jb 0x2771
movl $0xa, %edi
movq %r15, %rsi
callq 0x21f0
movq %r15, %rdi
callq 0x2180
jmp 0x27b0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop