LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/fatiiates[P]CDLL-with-cpp-make-gcc/./src/ArrayList.cpp
// Function: ArrayList::reserve(int)
void ArrayList::reserve(int newCapacity){
      CircularDoublyLinkedList **temp = new CircularDoublyLinkedList*[newCapacity];

      for (int i = 0; i < length; i++)
        temp[i] = items[i];

      delete [] items;
      items = temp;
      capacity =  newCapacity;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %rax
leaq (,%rax,8), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, %r15
movslq 0x8(%r14), %rax
testq %rax, %rax
jle 0x24a9
movq (%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movq %rsi, (%r15,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x2499
movq (%r14), %rdi
testq %rdi, %rdi
je 0x24b6
callq 0x21b0
movq %r15, (%r14)
movl %ebx, 0xc(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fatiiates[P]CDLL-with-cpp-make-gcc/./src/ArrayList.cpp
// Function: ArrayList::elementAt(int)
CircularDoublyLinkedList* ArrayList::elementAt(int index){
      if(index < 0 || index >= length)
        throw invalid_argument("İndex 0'dan küçük, kapasiteye eşit veya kapasiteden büyük olamaz . Error Code: 101");
      else
        return items[index];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
js 0x252a
cmpl %esi, 0x8(%rdi)
jle 0x252a
movq (%rdi), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x1ac6(%rip), %rsi      # 0x4004
movq %rax, %rdi
callq 0x2280
movq 0x3a8b(%rip), %rsi      # 0x5fd8
movq 0x3a74(%rip), %rdx      # 0x5fc8
movq %rbx, %rdi
callq 0x2220
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25ea
movl %esi, %r15d
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl %esi, %eax
jl 0x25ea
movq %rdx, %r14
movl 0xc(%rbx), %esi
cmpl %esi, %eax
jne 0x25af
addl %esi, %esi
movq %rbx, %rdi
callq 0x245c
movl 0x8(%rbx), %eax
cmpl %r15d, %eax
jle 0x25d0
movl %eax, %ecx
movl %ecx, %edx
leal -0x1(%rcx), %esi
movq (%rbx), %rcx
movq (%rcx,%rsi,8), %rdi
movq %rdi, (%rcx,%rdx,8)
movl %esi, %ecx
cmpl %r15d, %esi
jg 0x25b9
movq (%rbx), %rcx
movl %r15d, %edx
movq %r14, (%rcx,%rdx,8)
incl %eax
movl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x1a60(%rip), %rsi      # 0x405e
movq %rax, %rdi
callq 0x2280
movq 0x39cb(%rip), %rsi      # 0x5fd8
movq 0x39b4(%rip), %rdx      # 0x5fc8
movq %rbx, %rdi
callq 0x2220
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26bf
pushq %rbp
movq %rsp, %rbp
decl %esi
movq 0x8(%rax), %rax
decl %esi
jne 0x26b6
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2876
movq %rdi, %rbx
movl 0x8(%rdi), %r12d
cmpl %esi, %r12d
jl 0x2876
movq %rdx, %r15
testl %esi, %esi
je 0x2818
movq (%rbx), %r12
cmpl $0x1, %esi
je 0x27f1
decl %esi
movq 0x8(%r12), %r12
decl %esi
jne 0x27e8
movl $0x18, %edi
callq 0x2180
movq %rax, %r14
movq 0x8(%r12), %rdx
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x2694
movq %r14, 0x8(%r12)
jmp 0x2847
movl $0x18, %edi
callq 0x2180
movq %rax, %r14
testl %r12d, %r12d
je 0x285b
movq (%rbx), %rdx
movq 0x10(%rdx), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2694
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 0x2694
movq %r14, (%rbx)
movq %r14, 0x8(%r14)
movq %r14, %rax
jmp 0x284b
movl $0x10, %edi
callq 0x20d0
movq %rax, %r14
leaq 0x1872(%rip), %rsi      # 0x40fc
movq %rax, %rdi
callq 0x2280
movq 0x373f(%rip), %rsi      # 0x5fd8
movq 0x3728(%rip), %rdx      # 0x5fc8
movq %r14, %rdi
callq 0x2220
jmp 0x28ac
jmp 0x28ac
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
callq 0x2190
jmp 0x28c9
movq %rax, %rbx
movq %r14, %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28fe
pushq %rbp
movq %rsp, %rbp
movb (%rsi), %sil
xorl %edx, %edx
movq (%rdi), %rdi
cmpb %sil, (%rdi)
je 0x28fb
incl %edx
addq $0x8, %rdi
cmpl %edx, %ecx
jne 0x28e7
jmp 0x28fd
movl %edx, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %rax
movl 0x8(%rdi), %ecx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
testl %ecx, %ecx
je 0x2933
movb (%rax), %dl
xorl %eax, %eax
movq %rdi, %r8
movq (%r8), %r8
cmpb %dl, (%r8)
je 0x2931
incl %eax
addq $0x8, %r8
cmpl %eax, %ecx
jne 0x291d
jmp 0x2933
movl %eax, %esi
cmpl $-0x1, %esi
je 0x2941
popq %rbx
popq %r14
popq %rbp
jmp 0x2986
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x17ef(%rip), %rsi      # 0x4144
movq %rax, %rdi
callq 0x2280
movq 0x3674(%rip), %rsi      # 0x5fd8
movq 0x365d(%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_O1/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 0x2a20
testl %esi, %esi
js 0x2a3e
cmpl %esi, %eax
jle 0x2a3e
movq %rdi, %rbx
movq (%rdi), %rdi
testl %esi, %esi
je 0x29ef
cmpl $0x1, %esi
je 0x29c1
decl %esi
movq 0x8(%rdi), %rdi
decl %esi
jne 0x29b9
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq 0x8(%rax), %rcx
movq %rdi, 0x10(%rcx)
movq %rax, %rdi
testq %rdi, %rdi
je 0x29e7
movl $0x18, %esi
callq 0x2190
decl 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x1, %eax
jne 0x2a07
leaq 0x8(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, (%rbx)
jmp 0x29d8
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rdi), %rcx
movq %rax, 0x8(%rcx)
jmp 0x29d8
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x173a(%rip), %rsi      # 0x416e
movq %rax, %rdi
callq 0x2280
jmp 0x2a5a
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x174b(%rip), %rsi      # 0x419d
movq %rax, %rdi
callq 0x2280
movq 0x3577(%rip), %rsi      # 0x5fd8
movq 0x3560(%rip), %rdx      # 0x5fc8
movq %rbx, %rdi
callq 0x2220
jmp 0x2a72
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
setne %al
je 0x2ac7
pushq %rbp
movq %rsp, %rbp
movb (%rsi), %dl
movq (%rdi), %rsi
cmpb %dl, (%rsi)
je 0x2ac6
decl %ecx
setne %al
je 0x2ac6
movq 0x8(%rsi), %rsi
jmp 0x2ab5
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26de
movl 0x8(%rdi), %eax
decl %eax
cmpl %esi, %eax
je 0x2746
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
cmpl $0x1, %esi
je 0x2af3
decl %esi
movq 0x8(%rax), %rax
decl %esi
jne 0x2aeb
movq 0x8(%rax), %rax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b74
movq %rsi, %r14
cmpl $0x0, 0x8(%rsi)
je 0x2b88
xorl %r12d, %r12d
leaq -0x29(%rbp), %r15
movq %r14, %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 0x2b4a
jmp 0x2b88
leaq 0x166d(%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_O1/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 0x2c5a
testl %esi, %esi
jle 0x2c80
cmpl %esi, %eax
jle 0x2c80
movq %rdi, %rbx
movq (%rdi), %r13
movq 0x8(%r13), %r13
decl %esi
jne 0x2bc9
cmpl $0x0, 0x8(%rbx)
je 0x2c1d
xorl %r14d, %r14d
leaq -0x29(%rbp), %r15
leaq 0x170e(%rip), %r12      # 0x42f3
movb (%r13), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq 0x33c8(%rip), %rdi      # 0x5fc0
movq %r15, %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 0x2be5
movq 0x339c(%rip), %rbx      # 0x5fc0
movq (%rbx), %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
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x335f(%rip), %rdi      # 0x5fc0
leaq 0x15ab(%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 0x15aa(%rip), %rsi      # 0x423e
movq %rax, %rdi
callq 0x2280
movq 0x3335(%rip), %rsi      # 0x5fd8
movq 0x331e(%rip), %rdx      # 0x5fc8
movq %rbx, %rdi
callq 0x2220
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl %esi, %edi
movl %esi, %r8d
cmovbl %edi, %r8d
testl %r8d, %r8d
je 0x3462
negl %r8d
xorl %ecx, %ecx
movl $0x1, %r9d
movl %edi, %eax
xorl %edx, %edx
divl %r9d
testl %edx, %edx
jne 0x344d
movl %esi, %eax
xorl %edx, %edx
divl %r9d
testl %edx, %edx
cmovel %r9d, %ecx
leal (%r8,%r9), %eax
incl %eax
movl %r9d, %edx
incl %edx
movl %edx, %r9d
cmpl $0x1, %eax
jne 0x3435
jmp 0x3464
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3479
movl %edi, %eax
xorl %edx, %edx
divl %esi
jmp 0x347f
movl %esi, %eax
xorl %edx, %edx
divl %edi
movl %edx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xde8(%rip), %rsi       # 0x4293
movq %rbx, %rdi
movl $0x10, %edx
callq 0x2050
xorl %r15d, %r15d
leaq 0xe31(%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 0x34c8
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 0x34c2
leaq -0x220(%rbp), %rdi
callq 0x21c0
movq 0x2a59(%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 0x35a2
jmp 0x35a2
movq %rax, %rbx
leaq -0x220(%rbp), %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/ruippeixotog[P]algo-lib/union-find.cpp
// Function: main
int main() {
  int n = 5;
  UnionFind uf(n);

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

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

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

  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
xorl %eax, %eax
movl %eax, (%rsp,%rax,4)
movl $0x0, 0xfa0(%rsp,%rax,4)
incq %rax
cmpq $0x5, %rax
jne 0x1149
xorl %ebx, %ebx
movq %rsp, %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x12e0
cmpl %eax, %ebx
jne 0x1245
incl %ebx
cmpl $0x5, %ebx
jne 0x1165
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x3, %esi
movl $0x4, %edx
callq 0x1306
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12e0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12e0
cmpl %eax, %ebp
jne 0x1264
movq %rsp, %rdi
movl $0x3, %esi
callq 0x12e0
cmpl $0x4, %eax
je 0x11df
movq %rsp, %rdi
movl $0x4, %esi
callq 0x12e0
cmpl $0x3, %eax
jne 0x12c1
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x1306
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12e0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12e0
cmpl %eax, %ebp
jne 0x1283
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x12e0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12e0
cmpl %eax, %ebp
jne 0x12a2
xorl %eax, %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xdb8(%rip), %rdi       # 0x2004
leaq 0xdc0(%rip), %rsi       # 0x2013
leaq 0xdc8(%rip), %rcx       # 0x2022
movl $0x4c, %edx
callq 0x1030
leaq 0xdc2(%rip), %rdi       # 0x202d
leaq 0xda1(%rip), %rsi       # 0x2013
leaq 0xda9(%rip), %rcx       # 0x2022
movl $0x4f, %edx
callq 0x1030
leaq 0xddb(%rip), %rdi       # 0x2065
leaq 0xd82(%rip), %rsi       # 0x2013
leaq 0xd8a(%rip), %rcx       # 0x2022
movl $0x53, %edx
callq 0x1030
leaq 0xdcd(%rip), %rdi       # 0x2076
leaq 0xd63(%rip), %rsi       # 0x2013
leaq 0xd6b(%rip), %rcx       # 0x2022
movl $0x54, %edx
callq 0x1030
leaq 0xd7c(%rip), %rdi       # 0x2044
leaq 0xd44(%rip), %rsi       # 0x2013
leaq 0xd4c(%rip), %rcx       # 0x2022
movl $0x50, %edx
callq 0x1030
// File: /workspace/github_cpp_makefile_star2_O1/ruippeixotog[P]algo-lib/union-find.cpp
// Function: UnionFind::join(int, int)
void join(int i, int j) {
    int xRoot = get(i);
    int yRoot = get(j);
    if (xRoot == yRoot) return;
    if (rank[xRoot] < rank[yRoot])
      pset[xRoot] = yRoot;
    else if (rank[xRoot] > rank[yRoot])
      pset[yRoot] = xRoot;
    else {
      pset[yRoot] = xRoot;
      rank[xRoot] = rank[xRoot] + 1;
    }
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
callq 0x12e0
movl %eax, %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x12e0
cmpl %eax, %ebp
je 0x134d
movslq %ebp, %rcx
movslq %eax, %rdx
movl 0xfa0(%rbx,%rdx,4), %esi
cmpl %esi, 0xfa0(%rbx,%rcx,4)
jge 0x1341
movl %eax, (%rbx,%rcx,4)
jmp 0x134d
movl %ebp, (%rbx,%rdx,4)
jg 0x134d
incl 0xfa0(%rbx,%rcx,4)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x28(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x38(%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 0x28(%rdi), %rax
cmpq %rax, 0x30(%rdi)
je 0x16e07
movq %rax, 0x30(%rbx)
movq 0x40(%rbx), %rax
cmpq %rax, 0x48(%rbx)
je 0x16e15
movq %rax, 0x48(%rbx)
movq %r8, 0x58(%rbx)
movq %rbx, %rdi
callq 0x17324
movq %rbx, %rdi
callq 0x17b92
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x17d10
movq %r14, %rdi
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa21b(%rip), %rdi      # 0x213f3
leaq 0xa220(%rip), %rsi      # 0x213ff
callq 0x10e0
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x172c3
leaq -0x50(%rbp), %rax
movb $0x0, 0x10(%rax)
leaq -0x150(%rbp), %r13
leaq 0xa205(%rip), %r12      # 0x2140c
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
shll $0x4, %eax
movzwl %ax, %edx
movq %r13, %rdi
leaq 0xa1e6(%rip), %rsi      # 0x21402
xorl %eax, %eax
callq 0x1040
xorl %r14d, %r14d
cmpq $0x8, %r14
jne 0x17246
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 0x1727f
movl %r15d, %ecx
movb %cl, -0x50(%rbp,%r14)
incq %r14
cmpq $0x10, %r14
jne 0x17226
movq -0x38(%rbp), %rdi
leaq 0xa17a(%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 0x17209
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_O1/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 0x17bbf
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
orb $0x4, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x17bdb
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x17bef
movl $0x494553, 0x62(%rbx)   # imm = 0x494553
andb $-0x11, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x17c05
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x17c19
movl $0x424c43, 0x62(%rbx)   # imm = 0x424C43
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x17c37
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 0x17c46
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
decb 0x89e(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x17c6b
movq 0x58(%rbx), %rdi
movl $0xfffc, %esi           # imm = 0xFFFC
callq *%rax
movzbl %al, %r14d
jmp 0x17c6e
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x17c7d
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq (%rbx), %rax
testq %rax, %rax
je 0x17ca0
movq 0x58(%rbx), %rdi
movl $0xfffd, %esi           # imm = 0xFFFD
callq *%rax
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x17ca3
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x17cb2
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 0x17cd5
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x17cea
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x17cff
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::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 %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 0x1bd9e
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1bda1
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1bdb0
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1bdda
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x54bb(%rip), %rsi      # 0x2128e
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %r15b
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1bdf0
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 0x1be17
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1be1a
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1be29
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1be3d
movl $0x4c5341, 0x62(%rbx)   # imm = 0x4C5341
movb 0x89d(%rbx), %al
andb $0x7c, %al
leal (%r15,%r15), %r12d
movl %r12d, %ecx
andb $-0x80, %cl
orb %al, %cl
testb $0x7f, %r15b
sete %al
addb %al, %al
orb %cl, %al
movl %r15d, %ecx
shrb $0x7, %cl
orb %al, %cl
movb %cl, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1be79
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1bea3
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 0x1beb2
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::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 %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 0x1bef7
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1befa
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1bf09
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 0x1bf3a
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1bf3d
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1bf4c
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
cmpq $0x0, 0x10(%rbx)
movzwl %ax, %r14d
je 0x1bf79
leaq 0x66(%rbx), %rdi
leaq 0x532e(%rip), %rsi      # 0x2129d
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1bf8f
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1bf92
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1bfa1
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1bfb5
movl $0x4c5341, 0x62(%rbx)   # imm = 0x4C5341
movb 0x89d(%rbx), %al
andb $0x7c, %al
leal (%r15,%r15), %r12d
movl %r12d, %ecx
andb $-0x80, %cl
orb %al, %cl
testb $0x7f, %r15b
sete %al
addb %al, %al
orb %cl, %al
movl %r15d, %ecx
shrb $0x7, %cl
orb %al, %cl
movb %cl, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1bff1
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c01b
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 0x1c02a
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::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 %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x1e88a
movq (%rbx), %rcx
movzwl %ax, %r14d
testq %rcx, %rcx
je 0x1c06c
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1c06f
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c07e
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1c092
movl $0x4c5341, 0x62(%rbx)   # imm = 0x4C5341
movb 0x89d(%rbx), %al
andb $0x7c, %al
leal (%r15,%r15), %r12d
movl %r12d, %ecx
andb $-0x80, %cl
orb %al, %cl
testb $0x7f, %r15b
sete %al
addb %al, %al
orb %cl, %al
movl %r15d, %ecx
shrb $0x7, %cl
orb %al, %cl
movb %cl, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c0ce
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c0f8
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 0x1c107
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::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 0x1c31b
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1c31e
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c32d
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1c357
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x4f3e(%rip), %rsi      # 0x2128e
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %r15b
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c36d
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 0x1c394
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1c397
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c3a6
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1c3d9
movl $0x52534c, 0x62(%rbx)   # imm = 0x52534C
cmpb $0x0, 0x66(%rbx)
jne 0x1c3d9
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x4f20(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movl %r15d, %eax
andb $0x1, %al
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
orb %al, %cl
leal 0x2(%rcx), %eax
cmpb $0x2, %r15b
movzbl %cl, %ecx
movzbl %al, %eax
cmovael %ecx, %eax
movb %al, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c40e
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c43b
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 0x1c44a
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::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 0x1c490
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1c493
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c4a2
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 0x1c4d3
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1c4d6
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c4e5
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
cmpq $0x0, 0x10(%rbx)
movzwl %ax, %r14d
je 0x1c512
leaq 0x66(%rbx), %rdi
leaq 0x4d95(%rip), %rsi      # 0x2129d
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1c528
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1c52b
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c53a
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1c56d
movl $0x52534c, 0x62(%rbx)   # imm = 0x52534C
cmpb $0x0, 0x66(%rbx)
jne 0x1c56d
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x4d8c(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movl %r15d, %eax
andb $0x1, %al
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
orb %al, %cl
leal 0x2(%rcx), %eax
cmpb $0x2, %r15b
movzbl %cl, %ecx
movzbl %al, %eax
cmovael %ecx, %eax
movb %al, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c5a2
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c5cf
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 0x1c5de
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::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 0x1e88a
movq (%rbx), %rcx
movzwl %ax, %r14d
testq %rcx, %rcx
je 0x1c621
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1c624
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c633
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1c666
movl $0x52534c, 0x62(%rbx)   # imm = 0x52534C
cmpb $0x0, 0x66(%rbx)
jne 0x1c666
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x4c93(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movl %r15d, %eax
andb $0x1, %al
movb 0x89d(%rbx), %cl
andb $0x7c, %cl
orb %al, %cl
leal 0x2(%rcx), %eax
cmpb $0x2, %r15b
movzbl %cl, %ecx
movzbl %al, %eax
cmovael %ecx, %eax
movb %al, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c69b
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c6c8
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 0x1c6d7
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::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 0x1c8fd
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1c900
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c90f
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1c939
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x495c(%rip), %rsi      # 0x2128e
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %r15b
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c94f
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 0x1c976
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1c979
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c988
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1c9bb
movl $0x4c4f52, 0x62(%rbx)   # imm = 0x4C4F52
cmpb $0x0, 0x66(%rbx)
jne 0x1c9bb
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x493e(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movb 0x89d(%rbx), %al
andb $0x7c, %al
movl %r15d, %ecx
shrb $0x7, %cl
orb %al, %cl
leal (%r15,%r15), %eax
andb $-0x80, %al
orb %cl, %al
testb %r15b, %r15b
sete %cl
addb %cl, %cl
orb %al, %cl
movb %cl, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1c9f2
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1ca1f
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 0x1ca2e
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::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 0x1ca74
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r14d
jmp 0x1ca77
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1ca86
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 0x1cab7
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movzbl %al, %r15d
shll $0x8, %r15d
jmp 0x1caba
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cac9
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movzwl %r14w, %eax
orl %r15d, %eax
cmpq $0x0, 0x10(%rbx)
movzwl %ax, %r14d
je 0x1caf6
leaq 0x66(%rbx), %rdi
leaq 0x47b1(%rip), %rsi      # 0x2129d
movl %r14d, %edx
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
testq %rax, %rax
je 0x1cb0c
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1cb0f
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cb1e
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1cb51
movl $0x4c4f52, 0x62(%rbx)   # imm = 0x4C4F52
cmpb $0x0, 0x66(%rbx)
jne 0x1cb51
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x47a8(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movb 0x89d(%rbx), %al
andb $0x7c, %al
movl %r15d, %ecx
shrb $0x7, %cl
orb %al, %cl
leal (%r15,%r15), %eax
andb $-0x80, %al
orb %cl, %al
testb %r15b, %r15b
sete %cl
addb %cl, %cl
orb %al, %cl
movb %cl, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cb88
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1cbb5
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 0x1cbc4
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::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 0x1e88a
movq (%rbx), %rcx
movzwl %ax, %r14d
testq %rcx, %rcx
je 0x1cc07
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rcx
movl %eax, %r15d
jmp 0x1cc0a
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cc19
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1cc4c
movl $0x4c4f52, 0x62(%rbx)   # imm = 0x4C4F52
cmpb $0x0, 0x66(%rbx)
jne 0x1cc4c
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x46ad(%rip), %rsi      # 0x212f2
xorl %eax, %eax
callq 0x1040
movb 0x89d(%rbx), %al
andb $0x7c, %al
movl %r15d, %ecx
shrb $0x7, %cl
orb %al, %cl
leal (%r15,%r15), %eax
andb $-0x80, %al
orb %cl, %al
testb %r15b, %r15b
sete %cl
addb %cl, %cl
orb %al, %cl
movb %cl, 0x89d(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cc83
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1ccb0
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 0x1ccbf
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_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 0x1cee7
movq 0x58(%rbx), %rdi
movzwl %ax, %esi
callq *%rcx
movl %eax, %r14d
jmp 0x1ceea
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cef9
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1cf23
leaq 0x66(%rbx), %rdi
movzbl %r14b, %edx
movzbl 0x89b(%rbx), %ecx
leaq 0x4372(%rip), %rsi      # 0x2128e
xorl %eax, %eax
callq 0x1040
movb 0x89b(%rbx), %r15b
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cf39
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 0x1cf60
movq 0x58(%rbx), %rdi
movl %r14d, %esi
callq *%rax
movl %eax, %r15d
jmp 0x1cf63
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1cf72
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x1cfa5
movl $0x524f52, 0x62(%rbx)   # imm = 0x524F52
cmpb $0x0, 0x66(%rbx)
jne 0x1cfa5
leaq 0x66(%rbx), %rdi
movzbl 0x89a(%rbx), %edx
leaq 0x4354(%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 0x1cfe3
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1d010
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 0x1d01f
movq 0x58(%rbx), %rdi
callq *%rax
incl 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq