LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/fatiiates[P]CDLL-with-cpp-make-gcc/./src/ArrayList.cpp
// Function: ArrayList::insert(int, CircularDoublyLinkedList*)
void ArrayList::insert(int index,CircularDoublyLinkedList* item){
      if(index < 0 || index > length)
        throw invalid_argument("İndex 0'dan küçük veya kapasiteden büyük olamaz . Error Code: 101");
      else{
        if(length == capacity) reserve(2*capacity);
        for (int i = length - 1; i >= index; i--)
          items[i+1] = items[i];
        items[index] = item;
        length++;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x25e3
movl %esi, %r15d
movq %rdi, %rbx
movl 0x8(%rdi), %esi
cmpl %r15d, %esi
jl 0x25e3
movq %rdx, %r14
cmpl 0xc(%rbx), %esi
jne 0x25ab
addl %esi, %esi
movq %rbx, %rdi
callq 0x245c
movl 0x8(%rbx), %esi
cmpl %r15d, %esi
jle 0x25c9
movl %esi, %eax
movl %eax, %ecx
leal -0x1(%rax), %edx
movq (%rbx), %rax
movq (%rax,%rdx,8), %rdi
movq %rdi, (%rax,%rcx,8)
movl %edx, %eax
cmpl %r15d, %edx
jg 0x25b2
movq (%rbx), %rax
movl %r15d, %ecx
movq %r14, (%rax,%rcx,8)
incl %esi
movl %esi, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x1a67(%rip), %rsi      # 0x405e
movq %rax, %rdi
callq 0x2280
movq 0x39d2(%rip), %rsi      # 0x5fd8
movq 0x39bb(%rip), %rdx      # 0x5fc8
movq %rbx, %rdi
callq 0x2220
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::FindPreNode(int)
Node* CircularDoublyLinkedList::FindPreNode(int index){
      int i=1;
      Node* prv = head;
      for (Node* itr = head;i != index; itr=itr->next,i++) {
        prv = prv->next;
      }
      return prv;
    }

// Assembly:
movq (%rdi), %rax
cmpl $0x1, %esi
je 0x26b7
pushq %rbp
movq %rsp, %rbp
decl %esi
movq 0x8(%rax), %rax
decl %esi
jne 0x26ae
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::insert(int, unsigned char const&)
void CircularDoublyLinkedList::insert(int index, const unsigned char& item){
      if(index < 0  || index > size){
        throw invalid_argument("Index 0'dan kucuk veya eleman sayisindan buyuk olamaz.  Error Code: 103");
      }else{
        if(index == 0){
          if(isEmpty()){
            head = new Node(item);
            head->next = head;
            head->prev = head;
          }
          else{
            head = new Node(item, head, head->prev);
            head->prev->next = head;
            head->next->prev = head;
          }
        }else{
          Node* preNodeIndex = FindPreNode(index);
          preNodeIndex->next = new Node(item, preNodeIndex->next, preNodeIndex);
          preNodeIndex->next->next->prev = preNodeIndex->next;
        }
        size++;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %esi, %esi
js 0x286e
movq %rdi, %rbx
movl 0x8(%rdi), %r12d
cmpl %esi, %r12d
jl 0x286e
movq %rdx, %r15
testl %esi, %esi
je 0x2810
movq (%rbx), %r12
cmpl $0x1, %esi
je 0x27e9
decl %esi
movq 0x8(%r12), %r12
decl %esi
jne 0x27e0
movl $0x18, %edi
callq 0x2180
movq %rax, %r14
movq 0x8(%r12), %rdx
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x268c
movq %r14, 0x8(%r12)
jmp 0x283f
movl $0x18, %edi
callq 0x2180
movq %rax, %r14
testl %r12d, %r12d
je 0x2853
movq (%rbx), %rdx
movq 0x10(%rdx), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x268c
movq %r14, (%rbx)
movq 0x10(%r14), %rax
movq %r14, 0x8(%rax)
movq 0x8(%r14), %rax
movq %r14, 0x10(%rax)
incl 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x268c
movq %r14, (%rbx)
movq %r14, 0x8(%r14)
movq %r14, %rax
jmp 0x2843
movl $0x10, %edi
callq 0x20d0
movq %rax, %r14
leaq 0x187a(%rip), %rsi      # 0x40fc
movq %rax, %rdi
callq 0x2280
movq 0x3747(%rip), %rsi      # 0x5fd8
movq 0x3730(%rip), %rdx      # 0x5fc8
movq %r14, %rdi
callq 0x2220
jmp 0x28a4
jmp 0x28a4
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
callq 0x2190
jmp 0x28c1
movq %rax, %rbx
movq %r14, %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O3/fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::indexOf(unsigned char const&) const
int CircularDoublyLinkedList::indexOf(const unsigned char& item) const {
      int i = 0;
      for (Node* itr=head;i != size;itr=itr->next) {
        if(itr->data == item) return i;
				i++;
      }
      return -1;
    }

// Assembly:
movl 0x8(%rdi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
je 0x28f6
pushq %rbp
movq %rsp, %rbp
movb (%rsi), %sil
xorl %edx, %edx
movq (%rdi), %rdi
cmpb %sil, (%rdi)
je 0x28f3
incl %edx
addq $0x8, %rdi
cmpl %edx, %ecx
jne 0x28df
jmp 0x28f5
movl %edx, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::remove(unsigned char const&)
void CircularDoublyLinkedList::remove(const unsigned char& item){
      int index = indexOf(item);
      if (index == -1)
        throw invalid_argument("Eleman listeye ait degil. Error Code: 104");
      else
        removeAt(index);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x291e
movb (%rsi), %cl
xorl %esi, %esi
movq %rdi, %rdx
movq (%rdx), %rdx
cmpb %cl, (%rdx)
je 0x2950
incl %esi
addq $0x8, %rdx
cmpl %esi, %eax
jne 0x290d
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x1812(%rip), %rsi      # 0x4144
movq %rax, %rdi
callq 0x2280
movq 0x3697(%rip), %rsi      # 0x5fd8
movq 0x3680(%rip), %rdx      # 0x5fc8
movq %rbx, %rdi
callq 0x2220
popq %rbx
popq %r14
popq %rbp
jmp 0x296c
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::removeAt(int)
void CircularDoublyLinkedList::removeAt(int index){

      if(isEmpty()){
        throw invalid_argument("Listede hic eleman bulunmuyor. Error Code: 105");
      }else{
        if(index < 0  || index >= size){
          throw invalid_argument("Index 0'dan kucuk, eleman sayisina esit veya buyuk olamaz. Error Code: 106");
        }else{
          Node* del;

          if(index == 0){
            del = head;

            if(size == 1){
              head = head->next = head->prev = NULL;
            }else{
              head = head->next;
              head->prev = del->prev;
              del->prev->next = head;
            }
          }else{
            Node* preNodeIndex = FindPreNode(index);
            del = preNodeIndex->next;
            preNodeIndex->next = del->next;
            del->next->prev = preNodeIndex;
          }

          delete del;
          size--;
        }
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x29f5
testl %esi, %esi
js 0x2a13
cmpl %esi, %eax
jle 0x2a13
movq %rdi, %rbx
movq (%rdi), %rdi
testl %esi, %esi
je 0x29c8
cmpl $0x1, %esi
je 0x29a3
decl %esi
movq 0x8(%rdi), %rdi
decl %esi
jne 0x299b
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq %rdi, 0x10(%rcx)
movq %rax, %rdi
movl $0x18, %esi
callq 0x2190
decl 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x1, %eax
jne 0x29e0
leaq 0x8(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, (%rbx)
jmp 0x29b6
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x8(%rcx)
jmp 0x29b6
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x1765(%rip), %rsi      # 0x416e
movq %rax, %rdi
callq 0x2280
jmp 0x2a2f
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x1776(%rip), %rsi      # 0x419d
movq %rax, %rdi
callq 0x2280
movq 0x35a2(%rip), %rsi      # 0x5fd8
movq 0x358b(%rip), %rdx      # 0x5fc8
movq %rbx, %rdi
callq 0x2220
jmp 0x2a47
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::find(unsigned char const&)
bool CircularDoublyLinkedList::find(const unsigned char& item){
      int i=0;
      for (Node* itr=head;i != size;itr=itr->next,i++)
        if(itr->data == item) return true;

      return false;
    }

// Assembly:
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
je 0x2aa1
pushq %rbp
movq %rsp, %rbp
movb (%rsi), %dl
decl %ecx
movq (%rdi), %rdi
subl $0x1, %ecx
setb %sil
cmpb %dl, (%rdi)
sete %al
je 0x2a9f
addq $0x8, %rdi
testb %sil, %sil
je 0x2a85
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::elementAt(int)
const unsigned char& CircularDoublyLinkedList::elementAt(int index){
      if(index == 0)
        return first();
      else if(index == (size -1))
        return last();

      return FindPreNode(index)->next->data;
    }

// Assembly:
testl %esi, %esi
je 0x26d6
movl 0x8(%rdi), %eax
decl %eax
cmpl %esi, %eax
je 0x273e
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
cmpl $0x1, %esi
je 0x2acf
decl %esi
movq 0x8(%rax), %rax
decl %esi
jne 0x2ac7
movq 0x8(%rax), %rax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: operator<<(std::ostream&, CircularDoublyLinkedList&)
ostream& operator<<(ostream& screen, CircularDoublyLinkedList& right){
      if (right.isEmpty()) {
        screen << "Listede eleman bulunmuyor. Error Code: 107";
      }else{
        int i=0;
        for(Node* itr=right.head;i != right.size;itr=itr->next,i++)
          screen << itr->data;
      }
      return screen;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rsi)
je 0x2b4a
movq %rsi, %r14
xorl %r12d, %r12d
leaq -0x29(%rbp), %r15
movq %rsi, %r13
movq (%r13), %r13
movb (%r13), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21a0
addq $0x8, %r13
incl %r12d
cmpl 0x8(%r14), %r12d
jne 0x2b20
jmp 0x2b5e
leaq 0x1697(%rip), %rsi      # 0x41e8
movl $0x2a, %edx
movq %rbx, %rdi
callq 0x21a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::printListPositionReverse(int)
void CircularDoublyLinkedList::printListPositionReverse(int index){
      if (isEmpty()) {
        cout << "Listede eleman bulunmuyor. Error Code: 108";
      }else{
        if(index<=0 || index>=size){
          throw invalid_argument("Index 0'dan kucuk, 0'a esit, eleman sayisina esit veya buyuk olamaz. Error Code: 109");
        }else{
          int i=0;
    			for(Node* itr = FindPreNode(index+1);i != size;itr=itr->prev,i++)
    				cout<<itr->data<<" ";
    			cout<<endl;
        }
      }
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x2c23
testl %esi, %esi
jle 0x2c49
cmpl %esi, %eax
jle 0x2c49
movq %rdi, %rbx
movq (%rdi), %r13
movq 0x8(%r13), %r13
decl %esi
jne 0x2b9f
xorl %r14d, %r14d
movq 0x340f(%rip), %r15      # 0x5fc0
leaq 0x173b(%rip), %r12      # 0x42f3
movb (%r13), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
leaq -0x29(%rbp), %rsi
callq 0x21a0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21a0
movq 0x10(%r13), %r13
incl %r14d
cmpl 0x8(%rbx), %r14d
jne 0x2bb8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3396(%rip), %rdi      # 0x5fc0
leaq 0x15e2(%rip), %rsi      # 0x4213
movl $0x2a, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x15e1(%rip), %rsi      # 0x423e
movq %rax, %rdi
callq 0x2280
movq 0x336c(%rip), %rsi      # 0x5fd8
movq 0x3355(%rip), %rdx      # 0x5fc8
movq %rbx, %rdi
callq 0x2220
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/fatiiates[P]CDLL-with-cpp-make-gcc/./src/Test.cpp
// Function: obeb(unsigned char, unsigned char)
int obeb(unsigned char n1, unsigned char n2){
  int largest = 0;
  for(int i=1; i <= n1 && i <= n2; i++)
    if(n1%i==0 && n2%i==0)
      largest = i;
  return largest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb %sil, %dil
movl %esi, %eax
cmovbl %edi, %eax
testl %eax, %eax
je 0x3405
movzbl %al, %r8d
negl %r8d
xorl %ecx, %ecx
movl $0x1, %r9d
movzbl %dil, %edx
movzbl %sil, %esi
movl %edx, %eax
divb %r9b
movzbl %ah, %eax
testb %al, %al
jne 0x33f0
movl %esi, %eax
divb %r9b
movzbl %ah, %eax
testb %al, %al
cmovel %r9d, %ecx
leal (%r8,%r9), %eax
incl %eax
movl %r9d, %edi
incl %edi
movl %edi, %r9d
cmpl $0x1, %eax
jne 0x33d6
jmp 0x3407
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/fatiiates[P]CDLL-with-cpp-make-gcc/./src/Test.cpp
// Function: mod(unsigned char, unsigned char)
int mod(unsigned char n1, unsigned char n2){
  if(n1 > n2)
    return n1 % n2;
  else
    return n2 % n1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb %sil, %dil
jbe 0x341d
movzbl %dil, %eax
divb %sil
jmp 0x3424
movzbl %sil, %eax
divb %dil
movzbl %ah, %eax
movzbl %al, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/fatiiates[P]CDLL-with-cpp-make-gcc/./src/Test.cpp
// Function: createSayilar()
void createSayilar(){
  ofstream file;
  file.open ("doc/Sayilar.txt");

  for (int i = 0; i < 500; i++) {
    for (int j = 0; j < 250; j++) {
      int v1 = rand() % 254 + 1;
      file << v1<<" ";
    }
    file << endl;
  }
  file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
leaq -0x220(%rbp), %rbx
movq %rbx, %rdi
callq 0x2210
leaq 0xe3f(%rip), %rsi       # 0x4293
movq %rbx, %rdi
movl $0x10, %edx
callq 0x2050
xorl %r15d, %r15d
leaq 0xe88(%rip), %r14       # 0x42f3
movl $0xfa, %r12d
callq 0x2080
cltq
imulq $-0x7efdfbf7, %rax, %rcx # imm = 0x81020409
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x7, %ecx
addl %edx, %ecx
movl %ecx, %edx
shll $0x8, %edx
addl %ecx, %ecx
subl %edx, %ecx
leal (%rax,%rcx), %esi
incl %esi
movq %rbx, %rdi
callq 0x2230
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21a0
decl %r12d
jne 0x3471
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20f0
incl %r15d
cmpl $0x1f4, %r15d           # imm = 0x1F4
jne 0x346b
leaq -0x220(%rbp), %rdi
callq 0x21c0
movq 0x2ab0(%rip), %rax      # 0x5fb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x218(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x220(%rbp,%rcx)
callq 0x2140
leaq -0x128(%rbp), %rdi
callq 0x20a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x354b
jmp 0x354b
movq %rax, %rbx
leaq -0x220(%rbp), %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::M6502(int, unsigned char (*)(void*, unsigned short), void (*)(void*, unsigned short, unsigned char), void*)
M6502(int mode, unsigned char (*readMemory)(void* arg, unsigned short addr), void (*writeMemory)(void* arg, unsigned short addr, unsigned char value), void* arg)
    {
        this->mode = mode;
        memset(&R, 0, sizeof(R));
        CB.readMemory = readMemory;
        CB.writeMemory = writeMemory;
        CB.debugMessage = NULL;
        CB.consumeClock = NULL;
        CB.breakPoints.clear();
        CB.breakOperands.clear();
        CB.arg = arg;
        setupOperands();
        reset();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x28(%rdi)
movl %esi, 0x890(%rdi)
movq $0x0, 0x894(%rdi)
movl $0x0, 0x89c(%rdi)
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
movups %xmm0, 0x10(%rdi)
movq %r8, 0x58(%rdi)
callq 0x1736e
movq %rbx, %rdi
callq 0x17bdc
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x17dba
movq %r14, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/test.cpp
// Function: TestMMU::outputMemoryDump()
void outputMemoryDump()
    {
        FILE* fp = fopen("result.dump", "wt");
        if (fp) {
            char buf[256];
            char ascii[17];
            ascii[16] = '\0';
            for (int i = 0; i < 4096; i++) {
                unsigned short addr = i * 16;
                sprintf(buf, "$%04X:", addr);
                for (int j = 0; j < 16; j++) {
                    if (j == 8) strcat(buf, " -");
                    unsigned char c = ram[addr++];
                    sprintf(&buf[strlen(buf)], " %02X", c);
                    ascii[j] = isprint(c) ? c : '.';
                }
                fprintf(fp, "%s : %s\n", buf, ascii);
            }
            fclose(fp);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq 0xa1d1(%rip), %rdi      # 0x213f3
leaq 0xa1d6(%rip), %rsi      # 0x213ff
callq 0x10e0
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x1730d
leaq -0x50(%rbp), %rax
movb $0x0, 0x10(%rax)
leaq -0x150(%rbp), %r13
leaq 0xa1bb(%rip), %r12      # 0x2140c
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
shll $0x4, %eax
movzwl %ax, %edx
movq %r13, %rdi
leaq 0xa19c(%rip), %rsi      # 0x21402
xorl %eax, %eax
callq 0x1040
xorl %r14d, %r14d
cmpq $0x8, %r14
jne 0x17290
movq %r13, %rdi
callq 0x1060
movw $0x2d20, -0x150(%rbp,%rax) # imm = 0x2D20
movb $0x0, -0x14e(%rbp,%rax)
movzbl (%rbx,%r14), %r15d
movq %r13, %rdi
callq 0x1060
leaq (%rax,%rbp), %rdi
addq $-0x150, %rdi           # imm = 0xFEB0
movq %r12, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x1040
movl %r15d, %edi
callq 0x1140
movl $0x2e, %ecx
testl %eax, %eax
je 0x172c9
movl %r15d, %ecx
movb %cl, -0x50(%rbp,%r14)
incq %r14
cmpq $0x10, %r14
jne 0x17270
movq -0x38(%rbp), %rdi
leaq 0xa130(%rip), %rsi      # 0x21412
movq %r13, %rdx
leaq -0x50(%rbp), %rcx
xorl %eax, %eax
callq 0x1100
movl -0x2c(%rbp), %eax
incl %eax
addq $0x10, %rbx
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x17253
movq -0x38(%rbp), %rdi
callq 0x10b0
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::reset()
void reset()
    {
        R.tickCount = 0;
        R.s = 0;
        consumeClock();
        updateStatusI(true, true);
        updateStatusB(false, true);
        push(0);
        unsigned char pcL = readMemory(0xFFFC);
        unsigned char pcH = readMemory(0xFFFD);
        R.pc = pcH;
        R.pc <<= 8;
        R.pc |= pcL;
        consumeClock();
        consumeClock();
        consumeClock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x894(%rdi)
movb $0x0, 0x89e(%rdi)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x17c0f
movq 0x58(%rbx), %rdi
callq *%rax
movq 0x18(%rbx), %rcx
jmp 0x17c11
xorl %ecx, %ecx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
orb $0x4, 0x89d(%rbx)
testq %rcx, %rcx
je 0x17c37
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x17c4f
movl $0x494553, 0x62(%rbx)   # imm = 0x494553
andb $-0x11, 0x89d(%rbx)
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0x17c6f
movq 0x58(%rbx), %rdi
callq *%rdx
movl 0x88(%rbx), %eax
movq 0x10(%rbx), %rcx
incl %eax
movl %eax, 0x88(%rbx)
testq %rcx, %rcx
je 0x17c83
movl $0x424c43, 0x62(%rbx)   # imm = 0x424C43
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x17ca1
movzbl 0x89e(%rbx), %esi
orl $0x100, %esi            # imm = 0x100
movq 0x58(%rbx), %rdi
xorl %edx, %edx
callq *%rax
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x17cb0
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
decb 0x89e(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x17cd5
movq 0x58(%rbx), %rdi
movl $0xfffc, %esi           # imm = 0xFFFC
callq *%rax
movzbl %al, %r14d
jmp 0x17cd8
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x17ce7
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x17d0a
movq 0x58(%rbx), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq *%rax
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x17d0d
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x17d8b
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 0x17d9f
movq 0x58(%rbx), %rdi
callq *%rcx
movq 0x18(%rbx), %rcx
movl 0x88(%rbx), %eax
leal 0x1(%rax), %edx
movl %edx, 0x88(%rbx)
testq %rcx, %rcx
je 0x17db5
movq 0x58(%rbx), %rdi
callq *%rcx
movq 0x18(%rbx), %rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
testq %rcx, %rcx
je 0x17da2
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
jmp 0x17da2
movl 0x88(%rbx), %eax
movzwl %r14w, %ecx
orl %r15d, %ecx
movw %cx, 0x898(%rbx)
addl $0x3, %eax
incl %eax
movl %eax, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addl $0x2, %eax
jmp 0x17da2
// File: /workspace/github_cpp_makefile_star2_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::asl_zpg_x(M6502*)
static inline void asl_zpg_x(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readZeroPageX(&addr);
        unsigned char after = cpu->asl(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 0x1bf11
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1bf14
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1bf23
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1bf4d
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x5348(%rip), %rsi      # 0x2128e
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %r15b
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1bf63
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 0x1bf8a
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1bf8d
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1bf9c
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1bfb8
movl $0x4c5341, 0x62(%rbx)   # imm = 0x4C5341
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
testb $0x7f, %r15b
sete %dl
addb %dl, %dl
movl %r15d, %esi
rolb %sil
andb $-0x7f, %sil
orb %dl, %sil
orb %cl, %sil
movb %sil, 0x89d(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1bff6
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c025
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
addb %r15b, %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 0x1c034
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_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::asl_abs(M6502*)
static inline void asl_abs(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readAbsolute(&addr);
        unsigned char after = cpu->asl(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 0x1c07a
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1c07d
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c08c
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 0x1c0bd
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1c0c0
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c0cf
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
cmpq $0x0, 0x10(%rbx)
movzwl %ax, %r14d
je 0x1c0fc
leaq 0x66(%rbx), %rdi
leaq 0x51ab(%rip), %rsi      # 0x2129d
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1c112
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1c115
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c124
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1c140
movl $0x4c5341, 0x62(%rbx)   # imm = 0x4C5341
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
testb $0x7f, %r15b
sete %dl
addb %dl, %dl
movl %r15d, %esi
rolb %sil
andb $-0x7f, %sil
orb %dl, %sil
orb %cl, %sil
movb %sil, 0x89d(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1c17e
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c1ad
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
addb %r15b, %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 0x1c1bc
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_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::asl_abs_x(M6502*)
static inline void asl_abs_x(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readAbsoluteX(&addr, true);
        unsigned char after = cpu->asl(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 0x1eb62
movq (%rbx), %rcx
movzwl %ax, %r14d
testq %rcx, %rcx
je 0x1c1ff
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1c202
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c211
movq 0x58(%rbx), %rdi
callq *%rax
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1c22d
movl $0x4c5341, 0x62(%rbx)   # imm = 0x4C5341
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
testb $0x7f, %r15b
sete %dl
addb %dl, %dl
movl %r15d, %esi
rolb %sil
andb $-0x7f, %sil
orb %dl, %sil
orb %cl, %sil
movb %sil, 0x89d(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x1c26b
movq 0x58(%rbx), %rdi
callq *%rcx
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c29a
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
addb %r15b, %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 0x1c2a9
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_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::lsr_zpg_x(M6502*)
static inline void lsr_zpg_x(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readZeroPageX(&addr);
        unsigned char after = cpu->lsr(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 0x1c4b5
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1c4b8
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c4c7
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1c4f1
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x4da4(%rip), %rsi      # 0x2128e
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %r15b
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c507
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 0x1c52e
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1c531
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c540
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1c573
movl $0x52534c, 0x62(%rbx)   # imm = 0x52534C
cmpb $0x0, 0x66(%rbx)
jne 0x1c573
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x4d86(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movl %r15d, %eax
andb $0x1, %al
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
cmpb $0x2, %r15b
setb %dl
addb %dl, %dl
orb %al, %dl
orb %cl, %dl
movb %dl, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c5a3
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c5d0
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
shrb %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 0x1c5df
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_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::lsr_abs(M6502*)
static inline void lsr_abs(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readAbsolute(&addr);
        unsigned char after = cpu->lsr(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 0x1c624
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1c627
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c636
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 0x1c667
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1c66a
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c679
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
cmpq $0x0, 0x10(%rbx)
movzwl %ax, %r14d
je 0x1c6a6
leaq 0x66(%rbx), %rdi
leaq 0x4c01(%rip), %rsi      # 0x2129d
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1c6bc
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1c6bf
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c6ce
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1c701
movl $0x52534c, 0x62(%rbx)   # imm = 0x52534C
cmpb $0x0, 0x66(%rbx)
jne 0x1c701
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x4bf8(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movl %r15d, %eax
andb $0x1, %al
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
cmpb $0x2, %r15b
setb %dl
addb %dl, %dl
orb %al, %dl
orb %cl, %dl
movb %dl, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c731
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c75e
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
shrb %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 0x1c76d
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_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::lsr_abs_x(M6502*)
static inline void lsr_abs_x(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readAbsoluteX(&addr, true);
        unsigned char after = cpu->lsr(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 0x1eb62
movq (%rbx), %rcx
movzwl %ax, %r14d
testq %rcx, %rcx
je 0x1c7af
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1c7b2
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c7c1
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1c7f4
movl $0x52534c, 0x62(%rbx)   # imm = 0x52534C
cmpb $0x0, 0x66(%rbx)
jne 0x1c7f4
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x4b05(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movl %r15d, %eax
andb $0x1, %al
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
cmpb $0x2, %r15b
setb %dl
addb %dl, %dl
orb %al, %dl
orb %cl, %dl
movb %dl, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c824
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c851
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
shrb %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 0x1c860
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_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::rol_zpg_x(M6502*)
static inline void rol_zpg_x(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readZeroPageX(&addr);
        unsigned char after = cpu->rol(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 0x1ca95
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1ca98
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1caa7
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1cad1
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x47c4(%rip), %rsi      # 0x2128e
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %r15b
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cae7
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 0x1cb0e
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1cb11
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cb20
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1cb53
movl $0x4c4f52, 0x62(%rbx)   # imm = 0x4C4F52
cmpb $0x0, 0x66(%rbx)
jne 0x1cb53
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x47a6(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movb 0x89d(%rbx), %al
andb $0x7c, %al
movl %r15d, %ecx
shrb $0x7, %cl
leal (%r15,%r15), %edx
andb $-0x80, %dl
testb %r15b, %r15b
sete %sil
addb %sil, %sil
orb %dl, %sil
orb %al, %sil
orb %cl, %sil
movb %sil, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cb91
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1cbbe
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
rolb %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 0x1cbcd
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_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::rol_abs(M6502*)
static inline void rol_abs(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readAbsolute(&addr);
        unsigned char after = cpu->rol(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 0x1cc12
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1cc15
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cc24
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 0x1cc55
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1cc58
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cc67
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
cmpq $0x0, 0x10(%rbx)
movzwl %ax, %r14d
je 0x1cc94
leaq 0x66(%rbx), %rdi
leaq 0x4613(%rip), %rsi      # 0x2129d
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1ccaa
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1ccad
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ccbc
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1ccef
movl $0x4c4f52, 0x62(%rbx)   # imm = 0x4C4F52
cmpb $0x0, 0x66(%rbx)
jne 0x1ccef
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x460a(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movb 0x89d(%rbx), %al
andb $0x7c, %al
movl %r15d, %ecx
shrb $0x7, %cl
leal (%r15,%r15), %edx
andb $-0x80, %dl
testb %r15b, %r15b
sete %sil
addb %sil, %sil
orb %dl, %sil
orb %al, %sil
orb %cl, %sil
movb %sil, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cd2d
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1cd5a
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
rolb %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 0x1cd69
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_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::rol_abs_x(M6502*)
static inline void rol_abs_x(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readAbsoluteX(&addr, true);
        unsigned char after = cpu->rol(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 0x1eb62
movq (%rbx), %rcx
movzwl %ax, %r14d
testq %rcx, %rcx
je 0x1cdab
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1cdae
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cdbd
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1cdf0
movl $0x4c4f52, 0x62(%rbx)   # imm = 0x4C4F52
cmpb $0x0, 0x66(%rbx)
jne 0x1cdf0
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x4509(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movb 0x89d(%rbx), %al
andb $0x7c, %al
movl %r15d, %ecx
shrb $0x7, %cl
leal (%r15,%r15), %edx
andb $-0x80, %dl
testb %r15b, %r15b
sete %sil
addb %sil, %sil
orb %dl, %sil
orb %al, %sil
orb %cl, %sil
movb %sil, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ce2e
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1ce5b
movq 0x58(%rbx), %rdi
movzbl %r15b, %edx
rolb %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 0x1ce6a
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_O3/suzukiplan[P]M6502/test/./../m6502.hpp
// Function: M6502::ror_zpg_x(M6502*)
static inline void ror_zpg_x(M6502* cpu)
    {
        unsigned short addr;
        unsigned char before = cpu->readZeroPageX(&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 0x1d09d
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1d0a0
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d0af
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d0d9
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x41bc(%rip), %rsi      # 0x2128e
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %r15b
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d0ef
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 0x1d116
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1d119
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d128
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d15b
movl $0x524f52, 0x62(%rbx)   # imm = 0x524F52
cmpb $0x0, 0x66(%rbx)
jne 0x1d15b
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x419e(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movl %r15d, %eax
andb $0x1, %al
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
movl %r15d, %edx
shlb $0x7, %dl
testb %r15b, %r15b
sete %sil
addb %sil, %sil
orb %al, %sil
orb %cl, %sil
orb %dl, %sil
movb %sil, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d198
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d1c5
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 0x1d1d4
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_O3/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 0x1d21a
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1d21d
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d22c
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 0x1d25d
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1d260
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d26f
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
cmpq $0x0, 0x10(%rbx)
movzwl %ax, %r14d
je 0x1d29c
leaq 0x66(%rbx), %rdi
leaq 0x400b(%rip), %rsi      # 0x2129d
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1d2b2
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1d2b5
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d2c4
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d2f7
movl $0x524f52, 0x62(%rbx)   # imm = 0x524F52
cmpb $0x0, 0x66(%rbx)
jne 0x1d2f7
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x4002(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movl %r15d, %eax
andb $0x1, %al
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
movl %r15d, %edx
shlb $0x7, %dl
testb %r15b, %r15b
sete %sil
addb %sil, %sil
orb %al, %sil
orb %cl, %sil
orb %dl, %sil
movb %sil, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d334
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d361
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 0x1d370
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_O3/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 0x1eb62
movq (%rbx), %rcx
movzwl %ax, %r14d
testq %rcx, %rcx
je 0x1d3b3
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1d3b6
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d3c5
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1d3f8
movl $0x524f52, 0x62(%rbx)   # imm = 0x524F52
cmpb $0x0, 0x66(%rbx)
jne 0x1d3f8
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x3f01(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movl %r15d, %eax
andb $0x1, %al
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
movl %r15d, %edx
shlb $0x7, %dl
testb %r15b, %r15b
sete %sil
addb %sil, %sil
orb %al, %sil
orb %cl, %sil
orb %dl, %sil
movb %sil, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1d435
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d462
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 0x1d471
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq