LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::MmcNone::cpuMemRead(unsigned short)
uint8_t MmcNone::cpuMemRead(uint16_t addr) {
  assert(addr >= mmcCpuAddrBase);
  // prg rom 1
  if ((addr >= 0x8000) and (addr < 0x8000 + 0x4000) and (progRoms.size() == 2)) {
    return *(progRoms[0] + addr - 0x8000);
  }
  // prg rom 2
  if ((addr >= 0xc000) and (progRoms.size() >= 1)) {
    if (progRoms.size() == 1) {
      return *(progRoms[0] + addr - 0xc000);
    } else {
      return *(progRoms[1] + addr - 0xc000);
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzwl -0x12(%rbp), %eax
cmpl $0x6000, %eax           # imm = 0x6000
jl 0x41c68
jmp 0x41c87
leaq 0x27f9f(%rip), %rdi     # 0x69c0e
leaq 0x27f01(%rip), %rsi     # 0x69b77
movl $0x44, %edx
leaq 0x27fde(%rip), %rcx     # 0x69c60
callq 0xe240
movzwl -0x12(%rbp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jl 0x41cda
movzwl -0x12(%rbp), %eax
cmpl $0xc000, %eax           # imm = 0xC000
jge 0x41cda
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x3fb30
cmpq $0x2, %rax
jne 0x41cda
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x43600
movq (%rax), %rax
movzwl -0x12(%rbp), %ecx
movslq %ecx, %rcx
movb -0x8000(%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x41d5e
movzwl -0x12(%rbp), %eax
cmpl $0xc000, %eax           # imm = 0xC000
jl 0x41d5a
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x3fb30
cmpq $0x1, %rax
jb 0x41d5a
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x3fb30
cmpq $0x1, %rax
jne 0x41d32
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x43600
movq (%rax), %rax
movzwl -0x12(%rbp), %ecx
movslq %ecx, %rcx
movb -0xc000(%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x41d5e
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x43600
movq (%rax), %rax
movzwl -0x12(%rbp), %ecx
movslq %ecx, %rcx
movb -0xc000(%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x41d5e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::MmcNone::vidAddrTranslate(unsigned short)
uint16_t MmcNone::vidAddrTranslate(uint16_t addr) {
  if (verticalMirror) {
    return translateVerticalMirror(addr);
  } else {
    return translateHorizMirror(addr);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x3c(%rax)
je 0x41d9c
movzwl -0x12(%rbp), %edi
callq 0x41dc0
movw %ax, -0x2(%rbp)
jmp 0x41da9
movzwl -0x12(%rbp), %edi
callq 0x41e30
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::translateVerticalMirror(unsigned short)
static uint16_t translateVerticalMirror(uint16_t addr) {
  if (addr >= nameTable3 && addr < (nameTable3 + nameTableSize)) {
    addr = (addr & (nameTableSize - 1)) + nameTable1;
  } else if (addr >= nameTable2 && addr < nameTable3) {
    addr = (addr & (nameTableSize - 1)) + nameTable0;
  }
  return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x2c00, %eax           # imm = 0x2C00
jl 0x41df5
movzwl -0x2(%rbp), %eax
cmpl $0x3000, %eax           # imm = 0x3000
jge 0x41df5
movzwl -0x2(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
addl $0x2400, %eax           # imm = 0x2400
movw %ax, -0x2(%rbp)
jmp 0x41e1f
movzwl -0x2(%rbp), %eax
cmpl $0x2800, %eax           # imm = 0x2800
jl 0x41e1d
movzwl -0x2(%rbp), %eax
cmpl $0x2c00, %eax           # imm = 0x2C00
jge 0x41e1d
movzwl -0x2(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
addl $0x2000, %eax           # imm = 0x2000
movw %ax, -0x2(%rbp)
jmp 0x41e1f
movw -0x2(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::translateHorizMirror(unsigned short)
static uint16_t translateHorizMirror(uint16_t addr) {
  if (addr >= nameTable1 && addr < (nameTable2)) {
    addr = (addr & (nameTableSize - 1)) + nameTable0;
  } else if (addr >= nameTable3 && addr < (nameTable3 + nameTableSize)) {
    addr = (addr & (nameTableSize - 1)) + nameTable2;
  }
  return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x2400, %eax           # imm = 0x2400
jl 0x41e65
movzwl -0x2(%rbp), %eax
cmpl $0x2800, %eax           # imm = 0x2800
jge 0x41e65
movzwl -0x2(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
addl $0x2000, %eax           # imm = 0x2000
movw %ax, -0x2(%rbp)
jmp 0x41e8f
movzwl -0x2(%rbp), %eax
cmpl $0x2c00, %eax           # imm = 0x2C00
jl 0x41e8d
movzwl -0x2(%rbp), %eax
cmpl $0x3000, %eax           # imm = 0x3000
jge 0x41e8d
movzwl -0x2(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
addl $0x2800, %eax           # imm = 0x2800
movw %ax, -0x2(%rbp)
jmp 0x41e8f
movw -0x2(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::Mmc1::updateMmcRegister(unsigned short, unsigned char)
void Mmc1::updateMmcRegister(uint16_t addr, uint8_t shiftRegister) {
  switch ((addr >> 13) & 0x7) {
  case 4:
    controlReg = shiftRegister;
    if (debug) {
      std::cerr << "mmc1 " << std::hex << addr << ": control reg: " << std::hex << (int)controlReg
                << std::endl;
    }
    break;
  case 5:
    chr0Bank = shiftRegister;
    if (debug) {
      std::cerr << "mmc1 " << std::hex << addr << ": chr0Bank reg: " << std::hex << (int)chr0Bank
                << std::endl;
    }
    break;
  case 6:
    chr1Bank = shiftRegister;
    if (debug) {
      std::cerr << "mmc1 " << std::hex << addr << ": chr1Bank reg: " << std::hex << (int)chr1Bank
                << std::endl;
    }
    break;
  case 7:
    prgBank = shiftRegister;
    if (debug) {
      std::cerr << "mmc1 " << std::hex << addr << ": prgBank reg: " << std::hex << (int)prgBank
                << std::endl;
    }
    break;
  default:
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movzwl -0xa(%rbp), %eax
shrl $0xd, %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x42165
movq -0x18(%rbp), %rax
leaq 0x279e0(%rip), %rcx     # 0x69b0c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movb -0xb(%rbp), %cl
movb %cl, 0x50(%rax)
jmp 0x42167
movq -0x20(%rbp), %rax
movb -0xb(%rbp), %cl
movb %cl, 0x51(%rax)
jmp 0x42167
movq -0x20(%rbp), %rax
movb -0xb(%rbp), %cl
movb %cl, 0x52(%rax)
jmp 0x42167
movq -0x20(%rbp), %rax
movb -0xb(%rbp), %cl
movb %cl, 0x53(%rax)
jmp 0x42167
jmp 0x42167
popq %rbp
retq
nopl (%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::Mmc1::cpuMemWrite(unsigned short, unsigned char)
void Mmc1::cpuMemWrite(uint16_t addr, uint8_t val) {
  // shift register writes
  if ((addr >= shiftWriteAddr) and (addr <= shiftWriteAddrLimit)) {
    // initialize shift register when 7th bit is set.
    if (val & (1 << 7)) {
      shiftRegister = shiftInit;
      controlReg |= 0x3 << 2;
      if (debug) {
        std::cerr << "mmc1: control reg reset: " << std::hex << (int)controlReg << std::endl;
      }
    } else {
      uint8_t oldShiftRegister = shiftRegister;
      shiftRegister >>= 1;
      shiftRegister |= (val & 0x1) << 4;
      // lowest bit is set on last write.
      if (oldShiftRegister & 0x1) {
        updateMmcRegister(addr, shiftRegister);
        shiftRegister = shiftInit;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzwl -0xa(%rbp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jl 0x42221
movzwl -0xa(%rbp), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jg 0x42221
movzbl -0xb(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x421cc
movq -0x18(%rbp), %rax
movb $0x10, 0x54(%rax)
movzbl 0x50(%rax), %ecx
orl $0xc, %ecx
movb %cl, 0x50(%rax)
jmp 0x4221f
movq -0x18(%rbp), %rax
movb 0x54(%rax), %cl
movb %cl, -0xc(%rbp)
movzbl 0x54(%rax), %ecx
sarl %ecx
movb %cl, 0x54(%rax)
movzbl -0xb(%rbp), %edx
andl $0x1, %edx
shll $0x4, %edx
movzbl 0x54(%rax), %ecx
orl %edx, %ecx
movb %cl, 0x54(%rax)
movzbl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4221d
movq -0x18(%rbp), %rax
movw -0xa(%rbp), %cx
movq %rax, %rdi
movzwl %cx, %esi
movzbl 0x54(%rax), %edx
callq 0x420f0
movq -0x18(%rbp), %rax
movb $0x10, 0x54(%rax)
jmp 0x4221f
jmp 0x42221
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::Mmc1::vidMemWrite(unsigned short, unsigned char)
void Mmc1::vidMemWrite(uint16_t addr, uint8_t val) {
  addr = vidAddrTranslate(addr);
  bool chr8kMode = getChrRomMode() == 0;
  if ((charRoms.size() == 0) and (addr < 0x1000)) {
    if (chr8kMode) {
      videoMemory->patternTableMemory[addr] = val;
    } else {
      videoMemory->patternTableMemory[addr + ((chr0Bank & 0x1) ? 0x1000 : 0)] = val;
    }
  } else if ((charRoms.size() == 0) and (addr >= 0x1000) and (addr <= 0x1fff)) {
    if (chr8kMode) {
      videoMemory->patternTableMemory[addr] = val;
    } else {
      videoMemory->patternTableMemory[addr - 0x1000 + ((chr1Bank & 0x1) ? 0x1000 : 0)] = val;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movw -0xa(%rbp), %cx
movq (%rdi), %rax
movzwl %cx, %esi
callq *0x50(%rax)
movq -0x18(%rbp), %rdi
movw %ax, -0xa(%rbp)
callq 0x43640
movq -0x18(%rbp), %rdi
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0xc(%rbp)
addq $0x20, %rdi
callq 0x3fb30
cmpq $0x0, %rax
jne 0x4252f
movzwl -0xa(%rbp), %eax
cmpl $0x1000, %eax           # imm = 0x1000
jge 0x4252f
testb $0x1, -0xc(%rbp)
je 0x424fe
movq -0x18(%rbp), %rax
movb -0xb(%rbp), %dl
movq 0x48(%rax), %rax
movzwl -0xa(%rbp), %ecx
movb %dl, 0x8(%rax,%rcx)
jmp 0x4252d
movq -0x18(%rbp), %rsi
movb -0xb(%rbp), %dl
movq 0x48(%rsi), %rax
movzwl -0xa(%rbp), %ecx
movzbl 0x51(%rsi), %r8d
andl $0x1, %r8d
xorl %esi, %esi
movl $0x1000, %edi           # imm = 0x1000
cmpl $0x0, %r8d
cmovnel %edi, %esi
addl %esi, %ecx
movslq %ecx, %rcx
movb %dl, 0x8(%rax,%rcx)
jmp 0x425ac
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x3fb30
cmpq $0x0, %rax
jne 0x425aa
movzwl -0xa(%rbp), %eax
cmpl $0x1000, %eax           # imm = 0x1000
jl 0x425aa
movzwl -0xa(%rbp), %eax
cmpl $0x1fff, %eax           # imm = 0x1FFF
jg 0x425aa
testb $0x1, -0xc(%rbp)
je 0x42573
movq -0x18(%rbp), %rax
movb -0xb(%rbp), %dl
movq 0x48(%rax), %rax
movzwl -0xa(%rbp), %ecx
movb %dl, 0x8(%rax,%rcx)
jmp 0x425a8
movq -0x18(%rbp), %rsi
movb -0xb(%rbp), %dl
movq 0x48(%rsi), %rax
movzwl -0xa(%rbp), %ecx
subl $0x1000, %ecx           # imm = 0x1000
movzbl 0x52(%rsi), %r8d
andl $0x1, %r8d
xorl %esi, %esi
movl $0x1000, %edi           # imm = 0x1000
cmpl $0x0, %r8d
cmovnel %edi, %esi
addl %esi, %ecx
movslq %ecx, %rcx
movb %dl, 0x8(%rax,%rcx)
jmp 0x425aa
jmp 0x425ac
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::Mmc1::vidAddrTranslate(unsigned short)
uint16_t Mmc1::vidAddrTranslate(uint16_t addr) {
  uint32_t mirrorMode = getMirroringMode();
  switch (mirrorMode) {
  case 0:
    return translateSingleMirror(addr);
  case 1:
    return translateSingleMirror(addr) + nameTableSize;
  case 2:
    return translateVerticalMirror(addr);
  case 3:
    return translateHorizMirror(addr);
  default:
    assert(0);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43660
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x42884
movq -0x20(%rbp), %rax
leaq 0x272e5(%rip), %rcx     # 0x69b1c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzwl -0x12(%rbp), %edi
callq 0x428b0
movw %ax, -0x2(%rbp)
jmp 0x428a3
movzwl -0x12(%rbp), %edi
callq 0x428b0
movzwl %ax, %eax
addl $0x400, %eax            # imm = 0x400
movw %ax, -0x2(%rbp)
jmp 0x428a3
movzwl -0x12(%rbp), %edi
callq 0x41dc0
movw %ax, -0x2(%rbp)
jmp 0x428a3
movzwl -0x12(%rbp), %edi
callq 0x41e30
movw %ax, -0x2(%rbp)
jmp 0x428a3
leaq 0x25c3e(%rip), %rdi     # 0x684c9
leaq 0x272e5(%rip), %rsi     # 0x69b77
movl $0x11e, %edx            # imm = 0x11E
leaq 0x274a4(%rip), %rcx     # 0x69d42
callq 0xe240
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::Mmc1::save(Rnes::MmcState&)
void Mmc1::save(MmcState &pb) {
  MmcState_Mmc1State *mmc1 = pb.mutable_mmc1();
  mmc1->set_controlreg(controlReg);
  mmc1->set_chr0bank(chr0Bank);
  mmc1->set_chr1bank(chr1Bank);
  mmc1->set_prgbank(prgBank);
  mmc1->set_shiftregister(shiftRegister);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43680
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x50(%rax), %esi
callq 0x436a0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movzbl 0x51(%rax), %esi
callq 0x436d0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movzbl 0x52(%rax), %esi
callq 0x43700
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movzbl 0x53(%rax), %esi
callq 0x43730
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movzbl 0x54(%rax), %esi
callq 0x43760
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::Mmc1::restore(Rnes::MmcState&)
void Mmc1::restore(MmcState &pb) {
  const MmcState_Mmc1State &mmc1 = pb.mmc1();
  controlReg = mmc1.controlreg();
  chr0Bank = mmc1.chr0bank();
  chr1Bank = mmc1.chr1bank();
  prgBank = mmc1.prgbank();
  shiftRegister = mmc1.shiftregister();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43790
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x437b0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, 0x50(%rax)
movq -0x18(%rbp), %rdi
callq 0x437d0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, 0x51(%rax)
movq -0x18(%rbp), %rdi
callq 0x437f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, 0x52(%rax)
movq -0x18(%rbp), %rdi
callq 0x43810
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, 0x53(%rax)
movq -0x18(%rbp), %rdi
callq 0x43830
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, 0x54(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::Mmc3::get1kChrBank(unsigned int)
uint8_t *Mmc3::get1kChrBank(uint32_t bank) {
  if (charRoms.size() == 0) {
    return &videoMemory->patternTableMemory[bank * 1024];
  } else {
    return charRoms[bank >> 3] + (bank & 0x7) * 1024;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x20, %rdi
callq 0x3fb30
cmpq $0x0, %rax
jne 0x42c73
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
addq $0x8, %rax
movl -0x14(%rbp), %ecx
shll $0xa, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x42c9f
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl -0x14(%rbp), %eax
shrl $0x3, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x43600
movq (%rax), %rax
movl -0x14(%rbp), %ecx
andl $0x7, %ecx
shll $0xa, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::Mmc3::vidAddrTranslate(unsigned short)
uint16_t Mmc3::vidAddrTranslate(uint16_t addr) {
  if (isHorizMirroring()) {
    return translateHorizMirror(addr);
  } else {
    return translateVerticalMirror(addr);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43870
testb $0x1, %al
jne 0x42cd2
jmp 0x42ce1
movzwl -0x12(%rbp), %edi
callq 0x41e30
movw %ax, -0x2(%rbp)
jmp 0x42cee
movzwl -0x12(%rbp), %edi
callq 0x41dc0
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::Mmc3::cpuMemWrite(unsigned short, unsigned char)
void Mmc3::cpuMemWrite(uint16_t addr, uint8_t val) {
  assert(addr >= mmcCpuAddrBase);

  // mmc control register writes
  if (addr >= 0x8000 and addr <= 0x9fff) {
    if (addr & 0x1) {
      updateBankRegister(val);
    } else {
      bankSelectReg = val;
    }
  } else if (addr >= 0xa000 and addr <= 0xbfff) {
    if (addr & 0x1) {
      prgRamReg = val;
    } else {
      mirrorReg = val;
    }
  } else if (addr >= 0xc000 and addr <= 0xdfff) {
    if (addr & 0x1) {
      irqCounterReg = 0;
    } else {
      irqReloadReg = val;
    }
  } else if (addr >= 0xe000 and addr <= 0xffff) {
    if (addr & 0x1) {
      irqEnabled = true;
    } else {
      irqEnabled = false;
      irqPending = false;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzwl -0xa(%rbp), %eax
cmpl $0x6000, %eax           # imm = 0x6000
jl 0x42d2d
jmp 0x42d4c
leaq 0x26eda(%rip), %rdi     # 0x69c0e
leaq 0x26e3c(%rip), %rsi     # 0x69b77
movl $0x15b, %edx            # imm = 0x15B
leaq 0x270b0(%rip), %rcx     # 0x69df7
callq 0xe240
movzwl -0xa(%rbp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jl 0x42d8c
movzwl -0xa(%rbp), %eax
cmpl $0x9fff, %eax           # imm = 0x9FFF
jg 0x42d8c
movzwl -0xa(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x42d7d
movq -0x18(%rbp), %rdi
movzbl -0xb(%rbp), %esi
callq 0x42bf0
jmp 0x42d87
movq -0x18(%rbp), %rax
movb -0xb(%rbp), %cl
movb %cl, 0x50(%rax)
jmp 0x42e3e
movzwl -0xa(%rbp), %eax
cmpl $0xa000, %eax           # imm = 0xA000
jl 0x42dc6
movzwl -0xa(%rbp), %eax
cmpl $0xbfff, %eax           # imm = 0xBFFF
jg 0x42dc6
movzwl -0xa(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x42dba
movq -0x18(%rbp), %rax
movb -0xb(%rbp), %cl
movb %cl, 0x52(%rax)
jmp 0x42dc4
movq -0x18(%rbp), %rax
movb -0xb(%rbp), %cl
movb %cl, 0x51(%rax)
jmp 0x42e3c
movzwl -0xa(%rbp), %eax
cmpl $0xc000, %eax           # imm = 0xC000
jl 0x42dfe
movzwl -0xa(%rbp), %eax
cmpl $0xdfff, %eax           # imm = 0xDFFF
jg 0x42dfe
movzwl -0xa(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x42df2
movq -0x18(%rbp), %rax
movb $0x0, 0x5c(%rax)
jmp 0x42dfc
movq -0x18(%rbp), %rax
movb -0xb(%rbp), %cl
movb %cl, 0x5b(%rax)
jmp 0x42e3a
movzwl -0xa(%rbp), %eax
cmpl $0xe000, %eax           # imm = 0xE000
jl 0x42e38
movzwl -0xa(%rbp), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jg 0x42e38
movzwl -0xa(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x42e2a
movq -0x18(%rbp), %rax
movb $0x1, 0x5d(%rax)
jmp 0x42e36
movq -0x18(%rbp), %rax
movb $0x0, 0x5d(%rax)
movb $0x0, 0x5e(%rax)
jmp 0x42e38
jmp 0x42e3a
jmp 0x42e3c
jmp 0x42e3e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::Mmc3::vidMemRead(unsigned short)
uint8_t Mmc3::vidMemRead(uint16_t addr) {
  // chr banks
  if (addr <= 0x1fff) {
    return *getChrPointer(addr);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzwl -0x12(%rbp), %eax
cmpl $0x1fff, %eax           # imm = 0x1FFF
jg 0x4326a
movq -0x20(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x42ff0
movb (%rax), %al
movb %al, -0x1(%rbp)
jmp 0x4326e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::Mmc3::notifyScanlineComplete()
void Mmc3::notifyScanlineComplete() {
  if (irqCounterReg == 0) {
    irqCounterReg = irqReloadReg;
  } else {
    irqCounterReg--;
    if (irqCounterReg == 0 and irqEnabled) {
      irqPending = true;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movzbl 0x5c(%rax), %eax
cmpl $0x0, %eax
jne 0x432a5
movq -0x10(%rbp), %rax
movb 0x5b(%rax), %cl
movb %cl, 0x5c(%rax)
jmp 0x432cf
movq -0x10(%rbp), %rax
movb 0x5c(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x5c(%rax)
movzbl 0x5c(%rax), %eax
cmpl $0x0, %eax
jne 0x432cd
movq -0x10(%rbp), %rax
testb $0x1, 0x5d(%rax)
je 0x432cd
movq -0x10(%rbp), %rax
movb $0x1, 0x5e(%rax)
jmp 0x432cf
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::Mmc3::save(Rnes::MmcState&)
void Mmc3::save(MmcState &pb) {
  /*
  // internal control registers
  uint8_t bankSelectReg = 1 << 6;
  uint8_t mirrorReg = 0;
  uint8_t prgRamReg = 0;
  uint8_t bankRegister[8] = {0};
  uint8_t irqReloadReg = 0;
  uint8_t irqCounterReg = 0;
  bool irqEnabled = false;
  bool irqPending = false;
  */

  MmcState_Mmc3State *mmc3 = pb.mutable_mmc3();
  mmc3->set_bankselectreg(bankSelectReg);
  mmc3->set_mirrorreg(mirrorReg);
  mmc3->set_prgramreg(prgRamReg);
  mmc3->set_bankregister(bankRegister, bankRegisterCount);
  mmc3->set_irqreloadreg(irqReloadReg);
  mmc3->set_irqcounterreg(irqCounterReg);
  mmc3->set_irqenabled(irqEnabled);
  mmc3->set_irqpending(irqPending);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43990
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x50(%rax), %esi
callq 0x439b0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movzbl 0x51(%rax), %esi
callq 0x439e0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movzbl 0x52(%rax), %esi
callq 0x43a10
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x53, %rsi
movl $0x8, %edx
callq 0x43a40
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movzbl 0x5b(%rax), %esi
callq 0x43b50
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movzbl 0x5c(%rax), %esi
callq 0x43b80
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movb 0x5d(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x43bb0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movb 0x5e(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x43be0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/mmc.cpp
// Function: Rnes::Mmc3::restore(Rnes::MmcState&)
void Mmc3::restore(MmcState &pb) {
  const MmcState_Mmc3State &mmc3 = pb.mmc3();
  bankSelectReg = mmc3.bankselectreg();
  mirrorReg = mmc3.mirrorreg();
  prgRamReg = mmc3.prgramreg();
  const std::string &bytes = mmc3.bankregister();
  for (unsigned i = 0; i < bytes.size(); i++) {
    bankRegister[i] = bytes[i];
  }
  irqReloadReg = mmc3.irqreloadreg();
  irqCounterReg = mmc3.irqcounterreg();
  irqEnabled = mmc3.irqenabled();
  irqPending = mmc3.irqpending();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43c10
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x43c30
movl %eax, %ecx
movq -0x30(%rbp), %rax
movb %cl, 0x50(%rax)
movq -0x18(%rbp), %rdi
callq 0x43c50
movl %eax, %ecx
movq -0x30(%rbp), %rax
movb %cl, 0x51(%rax)
movq -0x18(%rbp), %rdi
callq 0x43c70
movl %eax, %ecx
movq -0x30(%rbp), %rax
movb %cl, 0x52(%rax)
movq -0x18(%rbp), %rdi
callq 0x43c90
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe3a0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x43494
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0xebe0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movb (%rcx), %dl
movl -0x24(%rbp), %ecx
movb %dl, 0x53(%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4344f
movq -0x18(%rbp), %rdi
callq 0x43cb0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movb %cl, 0x5b(%rax)
movq -0x18(%rbp), %rdi
callq 0x43cd0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movb %cl, 0x5c(%rax)
movq -0x18(%rbp), %rdi
callq 0x43cf0
movb %al, %cl
movq -0x30(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x5d(%rax)
movq -0x18(%rbp), %rdi
callq 0x43d10
movb %al, %cl
movq -0x30(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x5e(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mindbeast[P]rnes/./bin/save.pb.h
// Function: Rnes::MmcState_Mmc3State::set_bankregister(void const*, unsigned long)
inline void MmcState_Mmc3State::set_bankregister(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  bankregister_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:Rnes.MmcState.Mmc3State.bankRegister)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
addq $0x18, %rax
movq %rax, -0x88(%rbp)
callq 0x442b0
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xea50
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0xec40
jmp 0x43acd
movq -0x90(%rbp), %rdi
callq 0x284d0
movq %rax, -0x98(%rbp)
jmp 0x43ae2
movq -0x98(%rbp), %rcx
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x44250
jmp 0x43aff
leaq -0x48(%rbp), %rdi
callq 0xed78
leaq -0x49(%rbp), %rdi
callq 0xed50
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x43b3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xed78
leaq -0x49(%rbp), %rdi
callq 0xed50
movq -0x58(%rbp), %rdi
callq 0xe700
nop
// File: mindbeast[P]rnes/./bin/save.pb.h
// Function: Rnes::MmcState::_internal_mutable_mmc1()
inline ::Rnes::MmcState_Mmc1State* MmcState::_internal_mutable_mmc1() {
  _has_bits_[0] |= 0x00000002u;
  if (mmc1_ == nullptr) {
    auto* p = CreateMaybeMessage<::Rnes::MmcState_Mmc1State>(GetArena());
    mmc1_ = p;
  }
  return mmc1_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x2, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x20(%rax)
jne 0x43e92
movq -0x28(%rbp), %rdi
callq 0x284d0
movq %rax, %rdi
callq 0x43ea0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: mindbeast[P]rnes/./bin/save.pb.h
// Function: Rnes::MmcState::_internal_mutable_mmc3()
inline ::Rnes::MmcState_Mmc3State* MmcState::_internal_mutable_mmc3() {
  _has_bits_[0] |= 0x00000004u;
  if (mmc3_ == nullptr) {
    auto* p = CreateMaybeMessage<::Rnes::MmcState_Mmc3State>(GetArena());
    mmc3_ = p;
  }
  return mmc3_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x4, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x28(%rax)
jne 0x44162
movq -0x28(%rbp), %rdi
callq 0x284d0
movq %rax, %rdi
callq 0x44170
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: mindbeast[P]rnes/memory.cpp
// Function: Rnes::CpuMemory::load(unsigned short) const
uint8_t CpuMemory::load(uint16_t addr) const {
  if (addr < cpuSramSize) {
    return cpuSram[addr];
  } else if ((addr >= prgSramBase) and (addr < prgSramBase + prgSramSize) and
             mmc->isPrgSramEnabled()) {
    return prgSram[addr - prgSramBase];
  } else {
    return mmc->cpuMemRead(addr);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzwl -0x12(%rbp), %eax
cmpl $0x800, %eax            # imm = 0x800
jge 0x44d77
movq -0x20(%rbp), %rax
movzwl -0x12(%rbp), %ecx
movb 0x8(%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x44dd4
movzwl -0x12(%rbp), %eax
cmpl $0x6000, %eax           # imm = 0x6000
jl 0x44dbd
movzwl -0x12(%rbp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jge 0x44dbd
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testb $0x1, %al
jne 0x44da0
jmp 0x44dbd
movq -0x20(%rbp), %rax
movzwl -0x12(%rbp), %ecx
subl $0x6000, %ecx           # imm = 0x6000
movslq %ecx, %rcx
movb 0x808(%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x44dd4
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movw -0x12(%rbp), %cx
movq (%rdi), %rax
movzwl %cx, %esi
callq *0x18(%rax)
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mindbeast[P]rnes/memory.cpp
// Function: Rnes::CpuMemory::store(unsigned short, unsigned char)
void CpuMemory::store(uint16_t addr, uint8_t data) {
  if (addr < cpuSramSize) {
    cpuSram[addr] = data;
  } else if ((addr >= prgSramBase) and (addr < prgSramBase + prgSramSize) and
             mmc->isPrgSramWriteable()) {
    prgSram[addr - prgSramBase] = data;
  } else {
    mmc->cpuMemWrite(addr, data);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzwl -0xa(%rbp), %eax
cmpl $0x800, %eax            # imm = 0x800
jge 0x44e1c
movq -0x18(%rbp), %rax
movb -0xb(%rbp), %dl
movzwl -0xa(%rbp), %ecx
movb %dl, 0x8(%rax,%rcx)
jmp 0x44e7e
movzwl -0xa(%rbp), %eax
cmpl $0x6000, %eax           # imm = 0x6000
jl 0x44e62
movzwl -0xa(%rbp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jge 0x44e62
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb $0x1, %al
jne 0x44e45
jmp 0x44e62
movq -0x18(%rbp), %rax
movb -0xb(%rbp), %dl
movzwl -0xa(%rbp), %ecx
subl $0x6000, %ecx           # imm = 0x6000
movslq %ecx, %rcx
movb %dl, 0x808(%rax,%rcx)
jmp 0x44e7c
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movw -0xa(%rbp), %dx
movb -0xb(%rbp), %cl
movq (%rdi), %rax
movzwl %dx, %esi
movzbl %cl, %edx
callq *0x10(%rax)
jmp 0x44e7e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/memory.cpp
// Function: Rnes::CpuMemory::restore(Rnes::CpuMemoryState const&)
void CpuMemory::restore(const CpuMemoryState &pb) {
  const std::string &bytes = pb.cpusram();
  for (unsigned i = 0; i < bytes.size(); i++) {
    cpuSram[i] = bytes[i];
  }

  const std::string &prgBytes = pb.prgsram();
  for (unsigned i = 0; i < prgBytes.size(); i++) {
    prgSram[i] = prgBytes[i];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x454f0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe3a0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x44f51
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0xebe0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movb (%rcx), %dl
movl -0x1c(%rbp), %ecx
movb %dl, 0x8(%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x44f0c
movq -0x10(%rbp), %rdi
callq 0x45510
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe3a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x44fad
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0xebe0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movb (%rcx), %dl
movl -0x2c(%rbp), %ecx
movb %dl, 0x808(%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x44f65
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/memory.cpp
// Function: Rnes::VideoMemory::load(unsigned short) const
uint8_t VideoMemory::load(uint16_t addr) const {
  if (addr >= 0x2000 and addr < 0x2000 + 0x1000) {
    addr = mmc->vidAddrTranslate(addr);
    return nameTableMemory[addr - 0x2000];
  } else if (addr >= 0x3f00 and addr <= 0x3f1f) {
    return paletteMemory[addr - 0x3f00];
  } else {
    return mmc->vidMemRead(addr);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzwl -0x12(%rbp), %eax
cmpl $0x2000, %eax           # imm = 0x2000
jl 0x45029
movzwl -0x12(%rbp), %eax
cmpl $0x3000, %eax           # imm = 0x3000
jge 0x45029
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movw -0x12(%rbp), %cx
movq (%rdi), %rax
movzwl %cx, %esi
callq *0x50(%rax)
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, -0x12(%rbp)
movzwl -0x12(%rbp), %ecx
subl $0x2000, %ecx           # imm = 0x2000
movslq %ecx, %rcx
movb 0x2008(%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x45073
movzwl -0x12(%rbp), %eax
cmpl $0x3f00, %eax           # imm = 0x3F00
jl 0x4505c
movzwl -0x12(%rbp), %eax
cmpl $0x3f1f, %eax           # imm = 0x3F1F
jg 0x4505c
movq -0x20(%rbp), %rax
movzwl -0x12(%rbp), %ecx
subl $0x3f00, %ecx           # imm = 0x3F00
movslq %ecx, %rcx
movb 0x3008(%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x45073
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movw -0x12(%rbp), %cx
movq (%rdi), %rax
movzwl %cx, %esi
callq *0x28(%rax)
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mindbeast[P]rnes/memory.cpp
// Function: Rnes::VideoMemory::store(unsigned short, unsigned char)
void VideoMemory::store(uint16_t addr, uint8_t data) {
  if (addr >= 0x2000 and addr < 0x2000 + 0x1000) {
    nameTableMemory[addr - 0x2000] = data;
  } else if (addr >= 0x3f00 and addr <= 0x3f1f) {
    paletteMemory[addr - 0x3f00] = data;
  } else {
    mmc->vidMemWrite(addr, data);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzwl -0xa(%rbp), %eax
cmpl $0x2000, %eax           # imm = 0x2000
jl 0x450d3
movzwl -0xa(%rbp), %eax
cmpl $0x3000, %eax           # imm = 0x3000
jge 0x450d3
movq -0x18(%rbp), %rax
movb -0xb(%rbp), %dl
movzwl -0xa(%rbp), %ecx
subl $0x2000, %ecx           # imm = 0x2000
movslq %ecx, %rcx
movb %dl, 0x2008(%rax,%rcx)
jmp 0x45122
movzwl -0xa(%rbp), %eax
cmpl $0x3f00, %eax           # imm = 0x3F00
jl 0x45106
movzwl -0xa(%rbp), %eax
cmpl $0x3f1f, %eax           # imm = 0x3F1F
jg 0x45106
movq -0x18(%rbp), %rax
movb -0xb(%rbp), %dl
movzwl -0xa(%rbp), %ecx
subl $0x3f00, %ecx           # imm = 0x3F00
movslq %ecx, %rcx
movb %dl, 0x3008(%rax,%rcx)
jmp 0x45120
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movw -0xa(%rbp), %dx
movb -0xb(%rbp), %cl
movq (%rdi), %rax
movzwl %dx, %esi
movzbl %cl, %edx
callq *0x20(%rax)
jmp 0x45122
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mindbeast[P]rnes/memory.cpp
// Function: Rnes::VideoMemory::restore(Rnes::VideoMemoryState const&)
void VideoMemory::restore(const VideoMemoryState &pb) {
  {
    const std::string &bytes = pb.patterntablememory();
    for (unsigned i = 0; i < bytes.size(); i++) {
      patternTableMemory[i] = bytes[i];
    }
  }
  {
    const std::string &bytes = pb.nametablememory();
    for (unsigned i = 0; i < bytes.size(); i++) {
      nameTableMemory[i] = bytes[i];
    }
  }
  {
    const std::string &bytes = pb.palettememory();
    for (unsigned i = 0; i < bytes.size(); i++) {
      paletteMemory[i] = bytes[i];
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x45860
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe3a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x45211
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0xebe0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movb (%rcx), %dl
movl -0x1c(%rbp), %ecx
movb %dl, 0x8(%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x451cc
movq -0x10(%rbp), %rdi
callq 0x45880
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe3a0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x4526d
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0xebe0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movb (%rcx), %dl
movl -0x2c(%rbp), %ecx
movb %dl, 0x2008(%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x45225
movq -0x10(%rbp), %rdi
callq 0x458a0
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rdi
callq 0xe3a0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x452c9
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0xebe0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movb (%rcx), %dl
movl -0x3c(%rbp), %ecx
movb %dl, 0x3008(%rax,%rcx)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x45281
addq $0x60, %rsp
popq %rbp
retq
nop
// File: mindbeast[P]rnes/./bin/save.pb.h
// Function: Rnes::CpuMemoryState::set_cpusram(void const*, unsigned long)
inline void CpuMemoryState::set_cpusram(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  cpusram_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:Rnes.CpuMemoryState.cpuSram)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
addq $0x18, %rax
movq %rax, -0x88(%rbp)
callq 0x442b0
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xea50
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0xec40
jmp 0x4535d
movq -0x90(%rbp), %rdi
callq 0x284d0
movq %rax, -0x98(%rbp)
jmp 0x45372
movq -0x98(%rbp), %rcx
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x44250
jmp 0x4538f
leaq -0x48(%rbp), %rdi
callq 0xed78
leaq -0x49(%rbp), %rdi
callq 0xed50
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x453cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xed78
leaq -0x49(%rbp), %rdi
callq 0xed50
movq -0x58(%rbp), %rdi
callq 0xe700
nop
// File: mindbeast[P]rnes/./bin/save.pb.h
// Function: Rnes::CpuMemoryState::set_prgsram(void const*, unsigned long)
inline void CpuMemoryState::set_prgsram(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  prgsram_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:Rnes.CpuMemoryState.prgSram)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x2, %esi
movl %esi, (%rcx,%rdx,4)
addq $0x20, %rax
movq %rax, -0x88(%rbp)
callq 0x442b0
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xea50
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0xec40
jmp 0x4546d
movq -0x90(%rbp), %rdi
callq 0x284d0
movq %rax, -0x98(%rbp)
jmp 0x45482
movq -0x98(%rbp), %rcx
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x44250
jmp 0x4549f
leaq -0x48(%rbp), %rdi
callq 0xed78
leaq -0x49(%rbp), %rdi
callq 0xed50
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x454dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xed78
leaq -0x49(%rbp), %rdi
callq 0xed50
movq -0x58(%rbp), %rdi
callq 0xe700
nop
// File: mindbeast[P]rnes/./bin/save.pb.h
// Function: Rnes::VideoMemoryState::set_patterntablememory(void const*, unsigned long)
inline void VideoMemoryState::set_patterntablememory(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  patterntablememory_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:Rnes.VideoMemoryState.patternTableMemory)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
addq $0x18, %rax
movq %rax, -0x88(%rbp)
callq 0x442b0
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xea50
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0xec40
jmp 0x455bd
movq -0x90(%rbp), %rdi
callq 0x284d0
movq %rax, -0x98(%rbp)
jmp 0x455d2
movq -0x98(%rbp), %rcx
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x44250
jmp 0x455ef
leaq -0x48(%rbp), %rdi
callq 0xed78
leaq -0x49(%rbp), %rdi
callq 0xed50
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x4562d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xed78
leaq -0x49(%rbp), %rdi
callq 0xed50
movq -0x58(%rbp), %rdi
callq 0xe700
nop
// File: mindbeast[P]rnes/./bin/save.pb.h
// Function: Rnes::VideoMemoryState::set_palettememory(void const*, unsigned long)
inline void VideoMemoryState::set_palettememory(const void* value,
    size_t size) {
  _has_bits_[0] |= 0x00000004u;
  palettememory_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:Rnes.VideoMemoryState.paletteMemory)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x4, %esi
movl %esi, (%rcx,%rdx,4)
addq $0x28, %rax
movq %rax, -0x88(%rbp)
callq 0x442b0
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xea50
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0xec40
jmp 0x457dd
movq -0x90(%rbp), %rdi
callq 0x284d0
movq %rax, -0x98(%rbp)
jmp 0x457f2
movq -0x98(%rbp), %rcx
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x44250
jmp 0x4580f
leaq -0x48(%rbp), %rdi
callq 0xed78
leaq -0x49(%rbp), %rdi
callq 0xed50
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x4584d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xed78
leaq -0x49(%rbp), %rdi
callq 0xed50
movq -0x58(%rbp), %rdi
callq 0xe700
nop
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: InitDefaultsscc_info_ApuState_save_2eproto()
static void InitDefaultsscc_info_ApuState_save_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::Rnes::_ApuState_default_instance_;
    new (ptr) ::Rnes::ApuState();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::Rnes::ApuState::InitAsDefaultInstance();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x257b8(%rip), %rdx     # 0x6b131
callq 0xe1b0
leaq 0x4d1bb(%rip), %rax     # 0x92b40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x65600
movq -0x8(%rbp), %rdi
callq 0x65620
callq 0x4be40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: InitDefaultsscc_info_ControllerState_save_2eproto()
static void InitDefaultsscc_info_ControllerState_save_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::Rnes::_ControllerState_default_instance_;
    new (ptr) ::Rnes::ControllerState();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::Rnes::ControllerState::InitAsDefaultInstance();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x25768(%rip), %rdx     # 0x6b131
callq 0xe1b0
leaq 0x4d32b(%rip), %rax     # 0x92d00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x65650
movq -0x8(%rbp), %rdi
callq 0x65620
callq 0x56ee0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: InitDefaultsscc_info_CpuMemoryState_save_2eproto()
static void InitDefaultsscc_info_CpuMemoryState_save_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::Rnes::_CpuMemoryState_default_instance_;
    new (ptr) ::Rnes::CpuMemoryState();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::Rnes::CpuMemoryState::InitAsDefaultInstance();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x25718(%rip), %rdx     # 0x6b131
callq 0xe1b0
leaq 0x4d2fb(%rip), %rax     # 0x92d20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x65670
movq -0x8(%rbp), %rdi
callq 0x65620
callq 0x57e10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: InitDefaultsscc_info_CpuState_save_2eproto()
static void InitDefaultsscc_info_CpuState_save_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::Rnes::_CpuState_default_instance_;
    new (ptr) ::Rnes::CpuState();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::Rnes::CpuState::InitAsDefaultInstance();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x256c8(%rip), %rdx     # 0x6b131
callq 0xe1b0
leaq 0x4cff3(%rip), %rax     # 0x92a68
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x65690
movq -0x8(%rbp), %rdi
callq 0x65620
callq 0x45e60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)