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

// 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 0x1d064
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1d067
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d076
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 0x1d0a7
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1d0aa
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d0b9
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
cmpq $0x0, 0x10(%rbx)
movzwl %ax, %r14d
je 0x1d0e6
leaq 0x66(%rbx), %rdi
leaq 0x41c1(%rip), %rsi      # 0x2129d
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1d0fc
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1d0ff
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d10e
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d141
movl $0x524f52, 0x62(%rbx)   # imm = 0x524F52
cmpb $0x0, 0x66(%rbx)
jne 0x1d141
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x41b8(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movl %r15d, %eax
andb $0x1, %al
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
leal (%rcx,%rax), %edx
orb $-0x80, %dl
testb %al, %al
movzbl %dl, %eax
movzbl %cl, %ecx
cmovnel %eax, %ecx
testb %r15b, %r15b
sete %al
addb %al, %al
orb %cl, %al
movb %al, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d17f
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d1ac
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
rorb %r15b
movl %r14d, %esi
callq *%rax
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
movl %r14d, %esi
callq *0x8(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d1bb
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::ror_abs_x(M6502*)
static inline void ror_abs_x(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readAbsoluteX(&addr, true);
        unsigned char after = cpu->ror(before);
        cpu->writeMemoryWithDummy(addr, before, after);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1e88a
movq (%rbx), %rcx
movzwl %ax, %r14d
testq %rcx, %rcx
je 0x1d1fd
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1d200
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d20f
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d242
movl $0x524f52, 0x62(%rbx)   # imm = 0x524F52
cmpb $0x0, 0x66(%rbx)
jne 0x1d242
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x40b7(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movl %r15d, %eax
andb $0x1, %al
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
leal (%rcx,%rax), %edx
orb $-0x80, %dl
testb %al, %al
movzbl %dl, %eax
movzbl %cl, %ecx
cmovnel %eax, %ecx
testb %r15b, %r15b
sete %al
addb %al, %al
orb %cl, %al
movb %al, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d280
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d2ad
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
rorb %r15b
movl %r14d, %esi
callq *%rax
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
movl %r14d, %esi
callq *0x8(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d2bc
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d302
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1d305
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d314
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
movzbl %r14b, %r14d
je 0x1d33a
leaq 0x66(%rbx), %rdi
leaq 0x3f58(%rip), %rsi      # 0x21288
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movzwl %r14w, %r14d
testq %rax, %rax
je 0x1d354
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1d357
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d366
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d37a
movl $0x434544, 0x62(%rbx)   # imm = 0x434544
leal -0x1(%r15), %r12d
movb 0x89d(%rbx), %al
andb $0x7d, %al
movl %r12d, %ecx
andb $-0x80, %cl
orb %al, %cl
testb %r12b, %r12b
sete %al
addb %al, %al
orb %cl, %al
movb %al, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d3ad
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d3d7
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 0x1d3e6
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_O1/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 0x1d42a
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1d42d
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d43c
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d466
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x3e2f(%rip), %rsi      # 0x2128e
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %r15b
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d47c
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 0x1d4a3
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1d4a6
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d4b5
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d4c9
movl $0x434544, 0x62(%rbx)   # imm = 0x434544
leal -0x1(%r15), %r12d
movb 0x89d(%rbx), %al
andb $0x7d, %al
movl %r12d, %ecx
andb $-0x80, %cl
orb %al, %cl
testb %r12b, %r12b
sete %al
addb %al, %al
orb %cl, %al
movb %al, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d4fc
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d526
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 0x1d535
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_O1/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 0x1d579
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1d57c
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d58b
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 0x1d5bc
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1d5bf
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d5ce
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
cmpq $0x0, 0x10(%rbx)
movzwl %ax, %r14d
je 0x1d5fb
leaq 0x66(%rbx), %rdi
leaq 0x3cac(%rip), %rsi      # 0x2129d
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1d611
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1d614
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d623
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d637
movl $0x434544, 0x62(%rbx)   # imm = 0x434544
leal -0x1(%r15), %r12d
movb 0x89d(%rbx), %al
andb $0x7d, %al
movl %r12d, %ecx
andb $-0x80, %cl
orb %al, %cl
testb %r12b, %r12b
sete %al
addb %al, %al
orb %cl, %al
movb %al, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d66a
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d694
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 0x1d6a3
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_O1/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 0x1e88a
movq (%rbx), %rcx
movzwl %ax, %r14d
testq %rcx, %rcx
je 0x1d6e4
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1d6e7
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d6f6
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d70a
movl $0x434544, 0x62(%rbx)   # imm = 0x434544
leal -0x1(%r15), %r12d
movb 0x89d(%rbx), %al
andb $0x7d, %al
movl %r12d, %ecx
andb $-0x80, %cl
orb %al, %cl
testb %r12b, %r12b
sete %al
addb %al, %al
orb %cl, %al
movb %al, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d73d
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d767
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 0x1d776
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_O1/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 0x1d882
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1d885
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d894
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
movzbl %r14b, %r14d
je 0x1d8ba
leaq 0x66(%rbx), %rdi
leaq 0x39d8(%rip), %rsi      # 0x21288
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movzwl %r14w, %r14d
testq %rax, %rax
je 0x1d8d4
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1d8d7
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d8e6
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d8fa
movl $0x434e49, 0x62(%rbx)   # imm = 0x434E49
movl %r15d, %r12d
incb %r12b
sete %al
movb 0x89d(%rbx), %cl
andb $0x7d, %cl
movl %r12d, %edx
andb $-0x80, %dl
orb %cl, %dl
addb %al, %al
orb %dl, %al
movb %al, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d92d
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d957
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 0x1d966
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_O1/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 0x1d9aa
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1d9ad
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d9bc
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d9e6
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x38af(%rip), %rsi      # 0x2128e
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %r15b
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d9fc
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 0x1da23
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1da26
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1da35
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1da49
movl $0x434e49, 0x62(%rbx)   # imm = 0x434E49
movl %r15d, %r12d
incb %r12b
sete %al
movb 0x89d(%rbx), %cl
andb $0x7d, %cl
movl %r12d, %edx
andb $-0x80, %dl
orb %cl, %dl
addb %al, %al
orb %dl, %al
movb %al, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1da7c
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1daa6
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 0x1dab5
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_O1/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 0x1daf9
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1dafc
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1db0b
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 0x1db3c
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1db3f
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1db4e
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
cmpq $0x0, 0x10(%rbx)
movzwl %ax, %r14d
je 0x1db7b
leaq 0x66(%rbx), %rdi
leaq 0x372c(%rip), %rsi      # 0x2129d
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1db91
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1db94
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1dba3
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1dbb7
movl $0x434e49, 0x62(%rbx)   # imm = 0x434E49
movl %r15d, %r12d
incb %r12b
sete %al
movb 0x89d(%rbx), %cl
andb $0x7d, %cl
movl %r12d, %edx
andb $-0x80, %dl
orb %cl, %dl
addb %al, %al
orb %dl, %al
movb %al, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1dbea
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1dc14
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 0x1dc23
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_O1/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 0x1e88a
movq (%rbx), %rcx
movzwl %ax, %r14d
testq %rcx, %rcx
je 0x1dc64
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1dc67
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1dc76
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1dc8a
movl $0x434e49, 0x62(%rbx)   # imm = 0x434E49
movl %r15d, %r12d
incb %r12b
sete %al
movb 0x89d(%rbx), %cl
andb $0x7d, %cl
movl %r12d, %edx
andb $-0x80, %dl
orb %cl, %dl
addb %al, %al
orb %dl, %al
movb %al, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1dcbd
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1dce7
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 0x1dcf6
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_O1/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 0x1e25b
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 0x1e282
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1e285
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e294
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 0x1e2c5
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1e2c8
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e2d7
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %r14d
orl %r15d, %r14d
cmpq $0x0, 0x10(%rbx)
je 0x1e301
leaq 0x66(%rbx), %rdi
movzwl %r14w, %edx
leaq 0x2fa3(%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_O1/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 0x1e330
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 0x1e357
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1e35a
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e369
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 0x1e39a
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r12d
shll $0x8, %r12d
jmp 0x1e39d
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e3ac
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %r15d
orl %r12d, %r15d
cmpq $0x0, 0x10(%rbx)
movzwl %r15w, %r14d
je 0x1e3d9
leaq 0x66(%rbx), %rdi
leaq 0x2f5b(%rip), %rsi      # 0x2132a
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1e3f0
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movzbl %al, %r14d
jmp 0x1e3f3
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e402
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1e427
incl %r15d
movq 0x58(%rbx), %rdi
movzwl %r15w, %esi
callq *%rax
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1e42a
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e439
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_O1/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 0x1e471
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 0x1e498
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1e49b
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e4aa
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 0x1e4db
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1e4de
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e4ed
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %r14d
orl %r15d, %r14d
cmpq $0x0, 0x10(%rbx)
je 0x1e517
leaq 0x66(%rbx), %rdi
movzwl %r14w, %edx
leaq 0x2d8d(%rip), %rsi      # 0x2129d
xorl %eax, %eax
callq 0x1040
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1e53a
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 0x1e549
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 0x1e57c
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 0x1e58b
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
decb 0x89e(%rbx)
movw %r14w, 0x898(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e5ae
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e5db
movl $0x535452, 0x62(%rbx)   # imm = 0x535452
movb 0x89e(%rbx), %cl
incb %cl
movb %cl, 0x89e(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1e60a
movzbl %cl, %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movzbl %al, %r14d
shll $0x8, %r14d
jmp 0x1e60d
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e61c
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 0x1e64d
movzbl %cl, %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movzbl %al, %r15d
jmp 0x1e650
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e65f
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e674
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r15w, %r15d
orl %r14d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e690
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movw %r15w, 0x898(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e6ad
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e73f
movl $0x495452, 0x62(%rbx)   # imm = 0x495452
movb 0x89e(%rbx), %cl
incb %cl
movb %cl, 0x89e(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1e769
movzbl %cl, %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movl %eax, %r14d
jmp 0x1e76c
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e77b
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 0x1e7b3
movzbl %cl, %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movzbl %al, %r14d
jmp 0x1e7b6
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e7c5
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 0x1e7fa
movzbl %cl, %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
callq *%rax
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1e7fd
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e80c
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
movw %ax, 0x898(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e82f
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e844
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e8c5
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r12d
jmp 0x1e8c8
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e8d7
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 0x1e908
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r13d
shll $0x8, %r13d
jmp 0x1e90b
xorl %r13d, %r13d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e91a
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movl %r13d, %r15d
orl %r12d, %r15d
cmpq $0x0, 0x10(%rbx)
je 0x1e949
leaq 0x66(%rbx), %rdi
movzbl 0x89b(%rbx), %ecx
leaq 0x2964(%rip), %rsi      # 0x212a3
movl %r15d, %edx
xorl %eax, %eax
callq 0x1040
movzbl 0x89b(%rbx), %r14d
addl %r14d, %r12d
cmpl $0x100, %r12d           # imm = 0x100
jb 0x1e974
movq (%rbx), %rax
testq %rax, %rax
je 0x1e97a
movzbl %r12b, %esi
orl %r13d, %esi
movq 0x58(%rbx), %rdi
callq *%rax
jmp 0x1e97a
cmpb $0x0, -0x2c(%rbp)
je 0x1e98f
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e989
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_O1/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 0x1e9df
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r12d
jmp 0x1e9e2
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1e9f1
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 0x1ea22
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r13d
shll $0x8, %r13d
jmp 0x1ea25
xorl %r13d, %r13d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ea34
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movl %r13d, %r15d
orl %r12d, %r15d
cmpq $0x0, 0x10(%rbx)
je 0x1ea63
leaq 0x66(%rbx), %rdi
movzbl 0x89c(%rbx), %ecx
leaq 0x2859(%rip), %rsi      # 0x212b2
movl %r15d, %edx
xorl %eax, %eax
callq 0x1040
movzbl 0x89c(%rbx), %r14d
addl %r14d, %r12d
cmpl $0x100, %r12d           # imm = 0x100
jb 0x1ea8e
movq (%rbx), %rax
testq %rax, %rax
je 0x1ea94
movzbl %r12b, %esi
orl %r13d, %esi
movq 0x58(%rbx), %rdi
callq *%rax
jmp 0x1ea94
cmpb $0x0, -0x2c(%rbp)
je 0x1eaa9
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1eaa3
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_O1/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 0x1eaf1
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1eaf4
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1eb03
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1eb2d
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x279b(%rip), %rsi      # 0x212c1
xorl %eax, %eax
callq 0x1040
addb 0x89b(%rbx), %r14b
movq (%rbx), %rax
testq %rax, %rax
je 0x1eb4c
movq 0x58(%rbx), %rdi
movzbl %r14b, %esi
callq *%rax
movzbl %al, %r15d
jmp 0x1eb4f
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1eb5e
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1eb83
incb %r14b
movq 0x58(%rbx), %rdi
movzbl %r14b, %esi
callq *%rax
movzbl %al, %r14d
shll $0x8, %r14d
jmp 0x1eb86
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1eb95
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ebaa
movq 0x58(%rbx), %rdi
callq *%rax
movzwl %r15w, %eax
orl %r14d, %eax
incl 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ebfc
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1ebff
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ec0e
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
movzbl %r15b, %r12d
je 0x1ec3b
leaq 0x66(%rbx), %rdi
movzbl 0x89c(%rbx), %ecx
leaq 0x26a1(%rip), %rsi      # 0x212d2
movl %r12d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1ec52
movq 0x58(%rbx), %rdi
movl %r12d, %esi
callq *%rax
movzbl %al, %r12d
jmp 0x1ec55
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ec64
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1ec89
incb %r15b
movq 0x58(%rbx), %rdi
movzbl %r15b, %esi
callq *%rax
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1ec8c
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ec9b
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzbl 0x89c(%rbx), %r13d
leal (%r12,%r13), %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x1eccb
movq (%rbx), %rax
testq %rax, %rax
je 0x1ecd0
movzbl %cl, %esi
orl %r15d, %esi
movq 0x58(%rbx), %rdi
callq *%rax
jmp 0x1ecd0
testb %r14b, %r14b
je 0x1ece5
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ecdf
movq 0x58(%rbx), %rdi
callq *%rax
incl 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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ed10
movl $0x434441, 0x62(%rdi)   # imm = 0x434441
cmpl $0x0, 0x890(%rdi)
jne 0x1ed24
movzbl 0x89d(%rdi), %eax
testb $0x8, %al
jne 0x1ed82
movzbl 0x89a(%rdi), %eax
movzbl %sil, %edx
movzbl 0x89d(%rdi), %r8d
movl %r8d, %ecx
andl $0x1, %ecx
addl %eax, %ecx
addl %edx, %ecx
andb $0x3c, %r8b
movl %ecx, %esi
andb $-0x80, %sil
orb %r8b, %sil
testb %cl, %cl
sete %r8b
addb %r8b, %r8b
xorl %eax, %edx
notl %edx
xorl %ecx, %eax
andl %edx, %eax
shrb %al
andb $0x40, %al
cmpl $0x100, %ecx            # imm = 0x100
setae %dl
orb %sil, %dl
orb %r8b, %dl
orb %al, %dl
movb %dl, 0x89d(%rdi)
movb %cl, 0x89a(%rdi)
popq %rbp
retq
movzbl 0x89a(%rdi), %edx
movl %edx, %r8d
shrl $0x4, %r8d
imulq $0x1999999a, %r8, %rcx  # imm = 0x1999999A
shrq $0x20, %rcx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %r8d
andl $0xf, %edx
imulq $0x1999999a, %rdx, %rcx # imm = 0x1999999A
shrq $0x20, %rcx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %edx
movzbl %sil, %esi
movl %esi, %ecx
shrl $0x4, %ecx
imulq $0x1999999a, %rcx, %r9  # imm = 0x1999999A
shrq $0x20, %r9
addl %r9d, %r9d
leal (%r9,%r9,4), %r9d
subl %r9d, %ecx
addl %r8d, %ecx
andl $0xf, %esi
imulq $0x1999999a, %rsi, %r8  # imm = 0x1999999A
shrq $0x20, %r8
addl %r8d, %r8d
leal (%r8,%r8,4), %r8d
subl %r8d, %esi
movl %eax, %r8d
andl $0x1, %r8d
addl %esi, %r8d
addl %edx, %r8d
imulq $0x1999999a, %r8, %rdx  # imm = 0x1999999A
shrq $0x20, %rdx
addl %edx, %edx
leal (%rdx,%rdx,4), %edx
movl %r8d, %esi
subl %edx, %esi
cmpl $0xa, %r8d
sbbl $-0x1, %ecx
cmpl $0xa, %ecx
setae %dl
andb $-0x2, %al
orb %dl, %al
movb %al, 0x89d(%rdi)
imulq $0x1999999a, %rcx, %rdx # imm = 0x1999999A
shrq $0x20, %rdx
addl %edx, %edx
leal (%rdx,%rdx,4), %edx
subl %edx, %ecx
shll $0x4, %ecx
orl %esi, %ecx
movb %cl, 0x89a(%rdi)
je 0x1ee4d
andb $-0x3, %al
jmp 0x1ee4f
orb $0x2, %al
movb %al, 0x89d(%rdi)
jmp 0x1ed80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ee6c
movl $0x434253, 0x62(%rdi)   # imm = 0x434253
cmpl $0x0, 0x890(%rdi)
jne 0x1ee80
movzbl 0x89d(%rdi), %eax
testb $0x8, %al
jne 0x1eee1
notb %sil
movzbl 0x89a(%rdi), %eax
movzbl %sil, %edx
movzbl 0x89d(%rdi), %r8d
movl %r8d, %ecx
andl $0x1, %ecx
addl %eax, %ecx
addl %edx, %ecx
andb $0x3c, %r8b
movl %ecx, %esi
andb $-0x80, %sil
orb %r8b, %sil
testb %cl, %cl
sete %r8b
addb %r8b, %r8b
xorl %eax, %edx
notl %edx
xorl %ecx, %eax
andl %edx, %eax
shrb %al
andb $0x40, %al
cmpl $0x100, %ecx            # imm = 0x100
setae %dl
orb %sil, %dl
orb %r8b, %dl
orb %al, %dl
movb %dl, 0x89d(%rdi)
movb %cl, 0x89a(%rdi)
popq %rbp
retq
movl %eax, %r8d
notl %r8d
movzbl 0x89a(%rdi), %ecx
movl %ecx, %edx
shrl $0x4, %edx
imulq $0x1999999a, %rdx, %r9  # imm = 0x1999999A
shrq $0x20, %r9
addl %r9d, %r9d
leal (%r9,%r9,4), %r9d
subl %r9d, %edx
andl $0xf, %ecx
imulq $0x1999999a, %rcx, %r9  # imm = 0x1999999A
shrq $0x20, %r9
addl %r9d, %r9d
leal (%r9,%r9,4), %r9d
subl %r9d, %ecx
movzbl %sil, %r9d
movl %r9d, %esi
shrl $0x4, %esi
imulq $0x1999999a, %rsi, %r10 # imm = 0x1999999A
shrq $0x20, %r10
addl %r10d, %r10d
leal (%r10,%r10,4), %r10d
andl $0xf, %r9d
imulq $0x1999999a, %r9, %r11  # imm = 0x1999999A
shrq $0x20, %r11
addl %r11d, %r11d
leal (%r11,%r11,4), %r11d
subl %r11d, %r9d
andl $0x1, %r8d
addl %r9d, %r8d
subl %r8d, %ecx
subl %esi, %r10d
addl %edx, %r10d
leal (%r10,%r10,4), %esi
leal (%rcx,%rsi,2), %r8d
andb $-0x2, %al
testl %r8d, %r8d
setns %dl
leal 0x64(%rcx,%rsi,2), %ecx
cmovnsl %r8d, %ecx
orb %al, %dl
movb %dl, 0x89d(%rdi)
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
je 0x1efae
andb $-0x3, %dl
jmp 0x1efb1
orb $0x2, %dl
movb %dl, 0x89d(%rdi)
jmp 0x1eedf
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1efdd
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 0x1f003
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1f006
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1f015
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
testb %r15b, %r15b
jne 0x1f034
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x1f034
movq 0x58(%rbx), %rdi
movl $0xdead0002, %esi       # imm = 0xDEAD0002
callq *%rax
movsbl %r15b, %r12d
cmpq $0x0, 0x10(%rbx)
je 0x1f077
leaq 0x66(%rbx), %rdi
movzwl 0x898(%rbx), %edx
testb %r15b, %r15b
leaq 0x22b8(%rip), %rax      # 0x2130c
leaq 0x23af(%rip), %rcx      # 0x2140a
cmovnsq %rax, %rcx
movl %r12d, %r8d
negl %r8d
cmovsl %r12d, %r8d
leaq 0x228f(%rip), %rsi      # 0x212ff
xorl %eax, %eax
callq 0x1040
testb %r14b, %r14b
je 0x1f0c3
movzwl 0x898(%rbx), %eax
leal (%rax,%r12), %ecx
xorl %eax, %ecx
testl $0xff00, %ecx           # imm = 0xFF00
je 0x1f0a6
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1f0a0
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
addw %r12w, 0x898(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1f0bd
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_O1/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 0x1f10b
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 0x1f11a
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 0x1f14a
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 0x1f159
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 0x1f18c
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 0x1f19b
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
decb 0x89e(%rbx)
movb 0x89d(%rbx), %al
movl %eax, %ecx
andb $-0x15, %cl
orb $0x4, %cl
orb $0x14, %al
movzbl %al, %eax
movzbl %cl, %ecx
testb %r15b, %r15b
cmovnel %eax, %ecx
movb %cl, 0x89d(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1f1e1
movq 0x58(%rbx), %rdi
movzwl %r14w, %esi
callq *%rax
movzbl %al, %r15d
jmp 0x1f1e4
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1f1f3
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x1f218
incl %r14d
movq 0x58(%rbx), %rdi
movzwl %r14w, %esi
callq *%rax
movzbl %al, %r14d
shll $0x8, %r14d
jmp 0x1f21b
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1f22a
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