LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::Reader::pushError(Json::Value const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::Value const&)
bool Reader::pushError(const Value& value, const JSONCPP_STRING& message, const Value& extra) {
  ptrdiff_t const length = end_ - begin_;
  if(value.getOffsetStart() > length
    || value.getOffsetLimit() > length
    || extra.getOffsetLimit() > length)
    return false;
  Token token;
  token.type_ = tokenError;
  token.start_ = begin_ + value.getOffsetStart();
  token.end_ = begin_ + value.getOffsetLimit();
  ErrorInfo info;
  info.token_ = token;
  info.message_ = message;
  info.extra_ = begin_ + extra.getOffsetStart();
  errors_.push_back(info);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movq 0xc8(%rcx), %rax
movq 0xc0(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa260
cmpq -0x30(%rbp), %rax
jg 0xa308
movq -0x18(%rbp), %rdi
callq 0xa280
cmpq -0x30(%rbp), %rax
jg 0xa308
movq -0x28(%rbp), %rdi
callq 0xa280
cmpq -0x30(%rbp), %rax
jle 0xa311
movb $0x0, -0x1(%rbp)
jmp 0xa42b
movq -0xa8(%rbp), %rax
movl $0xd, -0x48(%rbp)
movq 0xc0(%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa260
movq -0xb8(%rbp), %rcx
movq %rax, %rdx
movq -0xa8(%rbp), %rax
addq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq 0xc0(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa280
movq %rax, %rcx
movq -0xb0(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x38(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1e5f0
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movups -0x48(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x5060
jmp 0xa3a4
movq -0xa8(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa260
movq %rax, -0xc0(%rbp)
jmp 0xa3cb
movq -0xa8(%rbp), %rdi
movq -0xc0(%rbp), %rcx
movq -0xc8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x58(%rbp)
addq $0x50, %rdi
leaq -0x90(%rbp), %rsi
callq 0x1e610
jmp 0xa3f9
movb $0x1, -0x1(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1e670
jmp 0xa42b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1e670
jmp 0xa439
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x5780
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::OurReader::containsNewLine(char const*, char const*)
bool OurReader::containsNewLine(OurReader::Location begin, OurReader::Location end) {
  for (; begin < end; ++begin)
    if (*begin == '\n' || *begin == '\r')
      return true;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xa4f4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0xa4de
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0xa4e4
movb $0x1, -0x1(%rbp)
jmp 0xa4f8
jmp 0xa4e6
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa4bc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::OurReader::normalizeEOL[abi:cxx11](char const*, char const*)
JSONCPP_STRING OurReader::normalizeEOL(OurReader::Location begin, OurReader::Location end) {
  JSONCPP_STRING normalized;
  normalized.reserve(static_cast<size_t>(end - begin));
  OurReader::Location current = begin;
  while (current != end) {
    char c = *current++;
    if (c == '\r') {
      if (current != end && *current == '\n')
         // convert dos EOL
         ++current;
      // convert Mac EOL
      normalized += '\n';
    } else {
      normalized += c;
    }
  }
  return normalized;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x5680
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
subq %rax, %rsi
callq 0x56e0
jmp 0xcdbe
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xce54
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb (%rax), %al
movb %al, -0x39(%rbp)
movsbl -0x39(%rbp), %eax
cmpl $0xd, %eax
jne 0xce3e
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xce2c
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xce2c
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xce2c
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x52c0
jmp 0xce71
movq -0x48(%rbp), %rdi
movl $0xa, %esi
callq 0x52e0
jmp 0xce3c
jmp 0xce4f
movq -0x48(%rbp), %rdi
movsbl -0x39(%rbp), %esi
callq 0x52e0
jmp 0xce4d
jmp 0xce4f
jmp 0xcdc6
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xce67
movq -0x48(%rbp), %rdi
callq 0x52c0
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5780
nopw (%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::fixNumericLocaleInput(char*, char*)
static inline void fixNumericLocaleInput(char* begin, char* end) {
  char decimalPoint = getDecimalPoint();
  if (decimalPoint != '\0' && decimalPoint != '.') {
    while (begin < end) {
      if (*begin == '.') {
        *begin = decimalPoint;
      }
      ++begin;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1dd70
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
je 0xde5b
movsbl -0x11(%rbp), %eax
cmpl $0x2e, %eax
je 0xde5b
jmp 0xde2c
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xde59
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xde4b
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xde2c
jmp 0xde5b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::parseFromStream(Json::CharReader::Factory const&, std::istream&, Json::Value*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool parseFromStream(
    CharReader::Factory const& fact, JSONCPP_ISTREAM& sin,
    Value* root, JSONCPP_STRING* errs)
{
  JSONCPP_OSTRINGSTREAM ssin;
  ssin << sin.rdbuf();
  JSONCPP_STRING doc = ssin.str();
  char const* begin = doc.data();
  char const* end = begin + doc.size();
  // Note that we do not actually need a null-terminator.
  CharReaderPtr const reader(fact.newCharReader());
  return reader->parse(begin, end, root, errs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x5630
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x51a0
movq %rax, -0x1e8(%rbp)
jmp 0x10be3
movq -0x1e8(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x50c0
jmp 0x10bf8
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x54b0
jmp 0x10c0d
leaq -0x1c8(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x55f0
movq -0x200(%rbp), %rdi
movq %rax, -0x1d0(%rbp)
movq -0x1d0(%rbp), %rax
movq %rax, -0x1f8(%rbp)
callq 0x5360
movq %rax, %rcx
movq -0x1f8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x1d8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x1f0(%rbp)
jmp 0x10c6b
movq -0x1f0(%rbp), %rsi
leaq -0x1e0(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x1f0b0
movq -0x210(%rbp), %rdi
callq 0x1f0e0
movq %rax, %rdi
movq -0x1d0(%rbp), %rsi
movq -0x1d8(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movb %al, -0x201(%rbp)
jmp 0x10cbb
leaq -0x1e0(%rbp), %rdi
callq 0x1f100
leaq -0x1c8(%rbp), %rdi
callq 0x52c0
leaq -0x198(%rbp), %rdi
callq 0x50d0
movb -0x201(%rbp), %al
andb $0x1, %al
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x10d42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x10d36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x1f100
leaq -0x1c8(%rbp), %rdi
callq 0x52c0
leaq -0x198(%rbp), %rdi
callq 0x50d0
movq -0x1a0(%rbp), %rdi
callq 0x5780
nopw (%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::operator>>(std::istream&, Json::Value&)
JSONCPP_ISTREAM& operator>>(JSONCPP_ISTREAM& sin, Value& root) {
  CharReaderBuilder b;
  JSONCPP_STRING errs;
  bool ok = parseFromStream(b, sin, &root, &errs);
  if (!ok) {
    throwRuntimeError(errs);
  }
  return sin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xed40
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5680
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rcx
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x10ba0
movb %al, -0x75(%rbp)
jmp 0x10dad
movb -0x75(%rbp), %al
andb $0x1, %al
movb %al, -0x61(%rbp)
testb $0x1, -0x61(%rbp)
jne 0x10de6
leaq -0x60(%rbp), %rdi
callq 0x6ae0
jmp 0x10dc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x52c0
leaq -0x40(%rbp), %rdi
callq 0xf1d0
jmp 0x10e13
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x52c0
leaq -0x40(%rbp), %rdi
callq 0xf1d0
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x5780
nopl (%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::ValueIteratorBase::name[abi:cxx11]() const
JSONCPP_STRING ValueIteratorBase::name() const {
  char const* keey;
  char const* end;
  keey = memberName(&end);
  if (!keey) return JSONCPP_STRING();
  return JSONCPP_STRING(keey, end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1128e
movq -0x48(%rbp), %rdi
callq 0x5680
jmp 0x112e4
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5790
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x1e4e0
jmp 0x112c2
leaq -0x21(%rbp), %rdi
callq 0x54f0
jmp 0x112e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x54f0
jmp 0x112ee
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5780
nopw (%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::duplicateStringValue(char const*, unsigned long)
static inline char* duplicateStringValue(const char* value,
                                         size_t length)
{
  // Avoid an integer overflow in the call to malloc below by limiting length
  // to a sane value.
  if (length >= static_cast<size_t>(Value::maxInt))
    length = Value::maxInt - 1;

  char* newString = static_cast<char*>(malloc(length + 1));
  if (newString == NULL) {
    throwRuntimeError(
        "in Json::Value::duplicateStringValue(): "
        "Failed to allocate string value buffer");
  }
  memcpy(newString, value, length);
  newString[length] = 0;
  return newString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x7fffffff, -0x10(%rbp) # imm = 0x7FFFFFFF
jb 0x11a42
movq $0x7ffffffe, -0x10(%rbp) # imm = 0x7FFFFFFE
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x5620
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11ab6
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x5790
movq -0x58(%rbp), %rdx
leaq 0x27065(%rip), %rsi     # 0x38ad7
leaq -0x38(%rbp), %rdi
callq 0x5650
jmp 0x11a7d
leaq -0x38(%rbp), %rdi
callq 0x6ae0
jmp 0x11a88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x11aab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x52c0
leaq -0x39(%rbp), %rdi
callq 0x54f0
jmp 0x11add
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x53c0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5780
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::Value::CZString::CZString(Json::Value::CZString const&)
Value::CZString::CZString(const CZString& other) {
  cstr_ = (other.storage_.policy_ != noDuplication && other.cstr_ != 0
				 ? duplicateStringValue(other.cstr_, other.storage_.length_)
				 : other.cstr_);
  storage_.policy_ = static_cast<unsigned>(other.cstr_
                 ? (static_cast<DuplicationPolicy>(other.storage_.policy_) == noDuplication
                     ? noDuplication : duplicate)
                 : static_cast<DuplicationPolicy>(other.storage_.policy_)) & 3U;
  storage_.length_ = other.storage_.length_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x11bb1
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x11bb1
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x2, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x11a20
movq %rax, -0x20(%rbp)
jmp 0x11bbc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x11bed
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
andl $0x3, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x11bfa
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x3, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %edx
andl $0x3, %edx
movl 0x8(%rax), %ecx
andl $0x3, %edx
andl $-0x4, %ecx
orl %edx, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %edx
shrl $0x2, %edx
movl 0x8(%rax), %ecx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
shll $0x2, %edx
andl $0x3, %ecx
orl %edx, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::Value::CZString::operator<(Json::Value::CZString const&) const
bool Value::CZString::operator<(const CZString& other) const {
  if (!cstr_) return index_ < other.index_;
  //return strcmp(cstr_, other.cstr_) < 0;
  // Assume both are strings.
  unsigned this_len = this->storage_.length_;
  unsigned other_len = other.storage_.length_;
  unsigned min_len = std::min<unsigned>(this_len, other_len);
  JSON_ASSERT(this->cstr_ && other.cstr_);
  int comp = memcmp(this->cstr_, other.cstr_, min_len);
  if (comp < 0) return true;
  if (comp > 0) return false;
  return (this_len < other_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, (%rax)
jne 0x11db9
movq -0x68(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11e99
movq -0x68(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x2, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x2, %eax
movl %eax, -0x20(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1f380
movq %rax, %rcx
movq -0x68(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x24(%rbp)
cmpq $0x0, (%rax)
je 0x11dfc
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x11e58
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5790
movq -0x70(%rbp), %rdx
leaq 0x26315(%rip), %rsi     # 0x38129
leaq -0x48(%rbp), %rdi
callq 0x5650
jmp 0x11e1f
leaq -0x48(%rbp), %rdi
callq 0x117c0
jmp 0x11e2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x11e4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x52c0
leaq -0x49(%rbp), %rdi
callq 0x54f0
jmp 0x11ea4
movq -0x68(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x51b0
movl %eax, -0x60(%rbp)
cmpl $0x0, -0x60(%rbp)
jge 0x11e7f
movb $0x1, -0x1(%rbp)
jmp 0x11e99
cmpl $0x0, -0x60(%rbp)
jle 0x11e8b
movb $0x0, -0x1(%rbp)
jmp 0x11e99
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x5780
nopl (%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::Value::Value(Json::ValueType)
Value::Value(ValueType vtype) {
  static char const emptyString[] = "";
  initBasic(vtype);
  switch (vtype) {
  case nullValue:
    break;
  case intValue:
  case uintValue:
    value_.int_ = 0;
    break;
  case realValue:
    value_.real_ = 0.0;
    break;
  case stringValue:
    // allocated_ == false, so this is safe.
    value_.string_ = const_cast<char*>(static_cast<char const*>(emptyString));
    break;
  case arrayValue:
  case objectValue:
    value_.map_ = new ObjectValues();
    break;
  case booleanValue:
    value_.bool_ = false;
    break;
  default:
    JSON_ASSERT_UNREACHABLE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x120a0
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x1206d
movq -0x18(%rbp), %rax
leaq 0x2574b(%rip), %rcx     # 0x37744
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x1208c
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0x1208c
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x1208c
movq -0x20(%rbp), %rax
leaq 0x258ea(%rip), %rcx     # 0x37916
movq %rcx, (%rax)
jmp 0x1208c
movl $0x30, %edi
callq 0x5490
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x5230
movq -0x28(%rbp), %rdi
callq 0x1f3c0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1208c
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0x1208c
leaq 0x26101(%rip), %rdi     # 0x38175
leaq 0x25c97(%rip), %rsi     # 0x37d12
movl $0xb31, %edx            # imm = 0xB31
leaq 0x260f4(%rip), %rcx     # 0x3817b
callq 0x5320
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::Value::dupMeta(Json::Value const&)
void Value::dupMeta(const Value& other) {
  if (other.comments_) {
    comments_ = new CommentInfo[numberOfCommentPlacement];
    for (int comment = 0; comment < numberOfCommentPlacement; ++comment) {
      const CommentInfo& otherComment = other.comments_[comment];
      if (otherComment.comment_)
        comments_[comment].setComment(
            otherComment.comment_, strlen(otherComment.comment_));
    }
  } else {
    comments_ = 0;
  }
  start_ = other.start_;
  limit_ = other.limit_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x12966
movl $0x20, %edi
callq 0x5040
movq %rax, -0x50(%rbp)
movq $0x3, (%rax)
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x11820
jmp 0x12875
movq -0x40(%rbp), %rcx
movq -0x58(%rbp), %rax
addq $0x8, %rax
cmpq %rcx, %rax
movq %rax, -0x38(%rbp)
jne 0x12866
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x12964
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x12954
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x5190
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x118a0
jmp 0x12954
movq -0x48(%rbp), %rcx
movq %rax, %rsi
movq -0x58(%rbp), %rax
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq %rax, %rcx
movq %rax, -0x70(%rbp)
je 0x12949
movq -0x70(%rbp), %rdi
addq $-0x8, %rdi
movq %rdi, -0x78(%rbp)
callq 0x11840
movq -0x48(%rbp), %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x70(%rbp)
jne 0x12927
movq -0x50(%rbp), %rdi
callq 0x55e0
jmp 0x12997
jmp 0x12956
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1289d
jmp 0x12972
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5780
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::Value::releasePayload()
void Value::releasePayload() {
  switch (type_) {
  case nullValue:
  case intValue:
  case uintValue:
  case realValue:
  case booleanValue:
    break;
  case stringValue:
    if (allocated_)
      releasePrefixedStringValue(value_.string_);
    break;
  case arrayValue:
  case objectValue:
    delete value_.map_;
    break;
  default:
    JSON_ASSERT_UNREACHABLE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movl %ecx, -0xc(%rbp)
subw $0x4, %ax
jb 0x12b37
jmp 0x12b16
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x12b39
jmp 0x12b20
movl -0xc(%rbp), %eax
subl $0x5, %eax
je 0x12b37
jmp 0x12b2a
movl -0xc(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0x12b5f
jmp 0x12b84
jmp 0x12ba3
movq -0x18(%rbp), %rax
movw 0x8(%rax), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x12b5d
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x15790
jmp 0x12ba3
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x12b82
movq -0x20(%rbp), %rdi
callq 0x1f7f0
movq -0x20(%rbp), %rdi
callq 0x5410
jmp 0x12ba3
leaq 0x255ea(%rip), %rdi     # 0x38175
leaq 0x25180(%rip), %rsi     # 0x37d12
movl $0xdc8, %edx            # imm = 0xDC8
leaq 0x25ace(%rip), %rcx     # 0x3866c
callq 0x5320
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::Value::isInt() const
bool Value::isInt() const {
  switch (type_) {
  case intValue:
#if defined(JSON_HAS_INT64)
    return value_.int_ >= minInt && value_.int_ <= maxInt;
#else
    return true;
#endif
  case uintValue:
    return value_.uint_ <= UInt(maxInt);
  case realValue:
    return value_.real_ >= minInt && value_.real_ <= maxInt &&
           IsIntegral(value_.real_);
  default:
    break;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movl %ecx, -0x14(%rbp)
subw $0x1, %ax
je 0x1372d
jmp 0x13716
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x1375a
jmp 0x13720
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x1376f
jmp 0x137bb
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $-0x80000000, (%rcx)    # imm = 0x80000000
movb %al, -0x21(%rbp)
jl 0x13750
movq -0x20(%rbp), %rax
cmpq $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
setle %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x137c1
movq -0x20(%rbp), %rax
cmpq $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
setbe %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x137c1
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
xorl %eax, %eax
movsd 0x244af(%rip), %xmm1    # 0x37c30
ucomisd %xmm1, %xmm0
movb %al, -0x22(%rbp)
jb 0x137b1
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movsd 0x244a0(%rip), %xmm0    # 0x37c38
ucomisd (%rcx), %xmm0
movb %al, -0x22(%rbp)
jb 0x137b1
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
callq 0x16c10
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x137c1
jmp 0x137bd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::Value::isUInt() const
bool Value::isUInt() const {
  switch (type_) {
  case intValue:
#if defined(JSON_HAS_INT64)
    return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
#else
    return value_.int_ >= 0;
#endif
  case uintValue:
#if defined(JSON_HAS_INT64)
    return value_.uint_ <= maxUInt;
#else
    return true;
#endif
  case realValue:
    return value_.real_ >= 0 && value_.real_ <= maxUInt &&
           IsIntegral(value_.real_);
  default:
    break;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movl %ecx, -0x14(%rbp)
subw $0x1, %ax
je 0x13b9d
jmp 0x13b86
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x13bc8
jmp 0x13b90
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x13bde
jmp 0x13c25
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x21(%rbp)
jl 0x13bbe
movq -0x20(%rbp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, (%rax)
setbe %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x13c2b
movq -0x20(%rbp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, (%rax)
setbe %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x13c2b
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x22(%rbp)
jb 0x13c1b
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movsd 0x2403e(%rip), %xmm0    # 0x37c40
ucomisd (%rcx), %xmm0
movb %al, -0x22(%rbp)
jb 0x13c1b
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
callq 0x16c10
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x13c2b
jmp 0x13c27
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::Value::removeMember(char const*, char const*, Json::Value*)
bool Value::removeMember(const char* key, const char* cend, Value* removed)
{
  if (type_ != objectValue) {
    return false;
  }
  CZString actualKey(key, static_cast<unsigned>(cend-key), CZString::noDuplication);
  ObjectValues::iterator it = value_.map_->find(actualKey);
  if (it == value_.map_->end())
    return false;
  if (removed)
#if JSON_HAS_RVALUE_REFERENCES
    *removed = std::move(it->second);
#else
    *removed = it->second;
#endif
  value_.map_->erase(it);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x7, %eax
je 0x1646f
movb $0x0, -0x1(%rbp)
jmp 0x165b5
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
movl %esi, %eax
subl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
xorl %ecx, %ecx
callq 0x11b10
movq -0xa0(%rbp), %rax
movq -0xb0(%rbp), %rsi
movq (%rax), %rdi
callq 0x1f760
movq %rax, -0xa8(%rbp)
jmp 0x164ab
movq -0xa0(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq (%rax), %rdi
callq 0x1f560
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1f230
testb $0x1, %al
jne 0x164dc
jmp 0x164fd
movb $0x0, -0x1(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0x1659f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x165aa
cmpq $0x0, -0x28(%rbp)
je 0x1655c
leaq -0x40(%rbp), %rdi
callq 0x1f180
movq %rax, %rsi
addq $0x10, %rsi
leaq -0x88(%rbp), %rdi
callq 0x129a0
jmp 0x16522
movq -0x28(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x9130
jmp 0x16534
leaq -0x88(%rbp), %rdi
callq 0x12a50
jmp 0x1655c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x12a50
jmp 0x165aa
movq -0xa0(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rsi
callq 0x1f810
movq %rax, -0xb8(%rbp)
jmp 0x16586
movq -0xb8(%rbp), %rax
movq %rax, -0x98(%rbp)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11c80
jmp 0x165b5
leaq -0x38(%rbp), %rdi
callq 0x11c80
jmp 0x165c3
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5780
nopl (%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::writeString[abi:cxx11](Json::StreamWriter::Factory const&, Json::Value const&)
JSONCPP_STRING writeString(StreamWriter::Factory const& builder, Value const& root) {
  JSONCPP_OSTRINGSTREAM sout;
  StreamWriterPtr const writer(builder.newStreamWriter());
  writer->write(root, &sout);
  return sout.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x5630
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x1b0(%rbp)
jmp 0x171ea
movq -0x1b0(%rbp), %rsi
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x20300
movq -0x1c8(%rbp), %rdi
callq 0x20330
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x190(%rbp), %rdx
callq *%rax
jmp 0x17229
movq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x54b0
jmp 0x1723e
leaq -0x198(%rbp), %rdi
callq 0x20350
leaq -0x190(%rbp), %rdi
callq 0x50d0
movq -0x1b8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x17298
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x20350
leaq -0x190(%rbp), %rdi
callq 0x50d0
movq -0x1a0(%rbp), %rdi
callq 0x5780
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::StyledStreamWriter::write(std::ostream&, Json::Value const&)
void StyledStreamWriter::write(JSONCPP_OSTREAM& out, const Value& root) {
  document_ = &out;
  addChildValues_ = false;
  indentString_.clear();
  indented_ = true;
  writeCommentBeforeValue(root);
  if (!indented_) writeIndent();
  indented_ = true;
  writeValue(root);
  writeCommentAfterValueOnSameLine(root);
  *document_ << "\n";
  document_ = NULL; // Forget the stream, for safety.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x18(%rdi)
movb 0x68(%rdi), %al
andb $-0x2, %al
orb $0x0, %al
movb %al, 0x68(%rdi)
addq $0x20, %rdi
callq 0x5610
movq -0x20(%rbp), %rdi
movb 0x68(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0x68(%rdi)
movq -0x18(%rbp), %rsi
callq 0x1a370
movq -0x20(%rbp), %rax
movb 0x68(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0x1a326
movq -0x20(%rbp), %rdi
callq 0x1a520
movq -0x20(%rbp), %rdi
movb 0x68(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0x68(%rdi)
movq -0x18(%rbp), %rsi
callq 0x1a560
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1acb0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x1f95a(%rip), %rsi     # 0x39cb3
callq 0x5460
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::BuiltStyledStreamWriter::write(Json::Value const&, std::ostream*)
int BuiltStyledStreamWriter::write(Value const& root, JSONCPP_OSTREAM* sout)
{
  sout_ = sout;
  addChildValues_ = false;
  indented_ = true;
  indentString_.clear();
  writeCommentBeforeValue(root);
  if (!indented_) writeIndent();
  indented_ = true;
  writeValue(root);
  writeCommentAfterValueOnSameLine(root);
  *sout_ << endingLineFeedSymbol_;
  sout_ = NULL;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movb 0xd8(%rdi), %al
andb $-0x2, %al
orb $0x0, %al
movb %al, 0xd8(%rdi)
movb 0xd8(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0xd8(%rdi)
addq $0x28, %rdi
callq 0x5610
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b810
movq -0x20(%rbp), %rax
movb 0xd8(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0x1b7b5
movq -0x20(%rbp), %rdi
callq 0x1b9e0
movq -0x20(%rbp), %rdi
movb 0xd8(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0xd8(%rdi)
movq -0x10(%rbp), %rsi
callq 0x1ba30
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c130
movq -0x20(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0xb8, %rsi
callq 0x5400
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::BuiltStyledStreamWriter::writeCommentBeforeValue(Json::Value const&)
void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
  if (cs_ == CommentStyle::None) return;
  if (!root.hasComment(commentBefore))
    return;

  if (!indented_) writeIndent();
  const JSONCPP_STRING& comment = root.getComment(commentBefore);
  JSONCPP_STRING::const_iterator iter = comment.begin();
  while (iter != comment.end()) {
    *sout_ << *iter;
    if (*iter == '\n' &&
       ((iter+1) != comment.end() && *(iter + 1) == '/'))
      // writeIndent();  // would write extra newline
      *sout_ << indentString_;
    ++iter;
  }
  indented_ = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpl $0x0, 0x70(%rax)
jne 0x1b836
jmp 0x1b9c0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x16f00
testb $0x1, %al
jne 0x1b84a
jmp 0x1b9c0
movq -0x78(%rbp), %rax
movb 0xd8(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0x1b865
movq -0x78(%rbp), %rdi
callq 0x1b9e0
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0x16f40
leaq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5430
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5800
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x201f0
testb $0x1, %al
jne 0x1b8ac
jmp 0x1b9a1
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x20230
movq -0x80(%rbp), %rdi
movsbl (%rax), %esi
callq 0x5560
jmp 0x1b8cf
leaq -0x40(%rbp), %rdi
callq 0x20230
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x81(%rbp)
jne 0x1b95b
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x20250
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5800
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x201f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x82(%rbp)
jne 0x1b925
jmp 0x1b94f
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x20250
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20230
movsbl (%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x82(%rbp)
movb -0x82(%rbp), %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x1b967
jmp 0x1b993
movq -0x78(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0x28, %rsi
callq 0x5400
jmp 0x1b97a
jmp 0x1b993
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x52c0
jmp 0x1b9c9
leaq -0x40(%rbp), %rdi
callq 0x20290
jmp 0x1b889
movq -0x78(%rbp), %rax
movb 0xd8(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0xd8(%rax)
leaq -0x38(%rbp), %rdi
callq 0x52c0
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5780
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::getDecimalPoint()
static char getDecimalPoint() {
#ifdef JSONCPP_NO_LOCALE_SUPPORT
  return '\0';
#else
  struct lconv* lc = localeconv();
  return lc ? *(lc->decimal_point) : '\0';
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x5850
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1dd96
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x9(%rbp)
jmp 0x1dd9d
xorl %eax, %eax
movb %al, -0x9(%rbp)
jmp 0x1dd9d
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::fixZerosInTheEnd(char*, char*)
static inline void fixZerosInTheEnd(char* begin, char* end) {
  end--;
  while ((begin < end) && (*end == '0')) {
    // don't delete last zero before point.
    if (*(end - 1) != '.') {
      *end = '\0';
    }
    end--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x11(%rbp)
jae 0x1de27
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x1de30
jmp 0x1de52
movq -0x10(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2e, %eax
je 0x1de44
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1de08
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/include/jsoncpp.cpp
// Function: Json::OurCharReader::parse(char const*, char const*, Json::Value*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool parse(
      char const* beginDoc, char const* endDoc,
      Value* root, JSONCPP_STRING* errs) JSONCPP_OVERRIDE {
    bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_);
    if (errs) {
      *errs = reader_.getFormattedErrorMessages();
    }
    return ok;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0xa5f0
andb $0x1, %al
movb %al, -0x29(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x21e68
movq -0x58(%rbp), %rsi
addq $0x10, %rsi
leaq -0x50(%rbp), %rdi
callq 0xe520
movq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x55a0
leaq -0x50(%rbp), %rdi
callq 0x52c0
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: RegulusImpact[P]sadboy/src/CPU.cpp
// Function: CPU::CPU(MMU*)
CPU::CPU(MMU* m) {
    mmu = m;

    IME = 0xFF;
    halt = false;

    for (int i = 0; i < 8; i++) {
        regs[i] = 0;
    }

    programCounter = 0;
    stackPointer = 0;
    cycles = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movb $-0x1, 0x9(%rax)
movb $0x0, 0x1d(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x2dde8
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2ddcb
movq -0x20(%rbp), %rax
movw $0x0, 0x18(%rax)
movw $0x0, 0x1a(%rax)
movb $0x0, 0x8(%rax)
popq %rbp
retq
nop
// File: RegulusImpact[P]sadboy/src/CPU.cpp
// Function: CPU::Get(FULL_REGISTERS)
std::uint16_t CPU::Get(FULL_REGISTERS r) {
    std::uint16_t value = 0;
    switch (r) {
        case FULL_REGISTERS::AF:
            value = regs[REGISTERS::A] << 8 | regs[REGISTERS::F];
            break;
        case FULL_REGISTERS::BC:
            value = regs[REGISTERS::B] << 8 | regs[REGISTERS::C];
            break;
        case FULL_REGISTERS::DE:
            value = regs[REGISTERS::D] << 8 | regs[REGISTERS::E];
            break;
        case FULL_REGISTERS::HL:
            value = regs[REGISTERS::H] << 8 | regs[REGISTERS::L];
            break;
    }

    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw $0x0, -0xe(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x2def3
movq -0x18(%rbp), %rax
leaq 0xafd3(%rip), %rcx      # 0x38e64
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rcx
movzbl 0x7(%rcx), %eax
shll $0x8, %eax
movzbl 0x6(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0xe(%rbp)
jmp 0x2def3
movq -0x20(%rbp), %rcx
movzbl (%rcx), %eax
shll $0x8, %eax
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0xe(%rbp)
jmp 0x2def3
movq -0x20(%rbp), %rcx
movzbl 0x2(%rcx), %eax
shll $0x8, %eax
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0xe(%rbp)
jmp 0x2def3
movq -0x20(%rbp), %rcx
movzbl 0x4(%rcx), %eax
shll $0x8, %eax
movzbl 0x5(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movw -0xe(%rbp), %ax
popq %rbp
retq
nopl (%rax)
// File: RegulusImpact[P]sadboy/src/CPU.cpp
// Function: CPU::Set(FULL_REGISTERS, unsigned short)
void CPU::Set(FULL_REGISTERS r, std::uint16_t value) {
    uint8_t hi = (uint8_t)(value >> 8);
    uint8_t lo = (uint8_t)(value);
    switch (r) {
        case FULL_REGISTERS::AF:
            regs[REGISTERS::A] = hi;
            regs[REGISTERS::F] = lo;
            break;
        case FULL_REGISTERS::BC:
            regs[REGISTERS::B] = hi;
            regs[REGISTERS::C] = lo;
            break;
        case FULL_REGISTERS::DE:
            regs[REGISTERS::D] = hi;
            regs[REGISTERS::E] = lo;
            break;
        case FULL_REGISTERS::HL:
            regs[REGISTERS::H] = hi;
            regs[REGISTERS::L] = lo;
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw %ax, -0xe(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb -0xd(%rbp), %al
movb %al, -0xf(%rbp)
movb -0xe(%rbp), %al
movb %al, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x2dfac
movq -0x18(%rbp), %rax
leaq 0xaf16(%rip), %rcx      # 0x38e74
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movb -0xf(%rbp), %cl
movb %cl, 0x7(%rax)
movb -0x10(%rbp), %cl
movb %cl, 0x6(%rax)
jmp 0x2dfac
movq -0x20(%rbp), %rax
movb -0xf(%rbp), %cl
movb %cl, (%rax)
movb -0x10(%rbp), %cl
movb %cl, 0x1(%rax)
jmp 0x2dfac
movq -0x20(%rbp), %rax
movb -0xf(%rbp), %cl
movb %cl, 0x2(%rax)
movb -0x10(%rbp), %cl
movb %cl, 0x3(%rax)
jmp 0x2dfac
movq -0x20(%rbp), %rax
movb -0xf(%rbp), %cl
movb %cl, 0x4(%rax)
movb -0x10(%rbp), %cl
movb %cl, 0x5(%rax)
popq %rbp
retq
nop
// File: RegulusImpact[P]sadboy/src/CPU.cpp
// Function: CPU::SetZ(bool)
void CPU::SetZ(bool b) {
    if (b)
        Set(FLAGS::Z);
    else
        Clear(FLAGS::Z);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x2e062
movq -0x18(%rbp), %rdi
movl $0x80, %esi
callq 0x2dfb0
jmp 0x2e070
movq -0x18(%rbp), %rdi
movl $0x80, %esi
callq 0x2dff0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/src/CPU.cpp
// Function: CPU::SetN(bool)
void CPU::SetN(bool b) {
    if (b)
        Set(FLAGS::N);
    else
        Clear(FLAGS::N);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x2e0b2
movq -0x18(%rbp), %rdi
movl $0x40, %esi
callq 0x2dfb0
jmp 0x2e0c0
movq -0x18(%rbp), %rdi
movl $0x40, %esi
callq 0x2dff0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/src/CPU.cpp
// Function: CPU::SetCY(bool)
void CPU::SetCY(bool b) {
    if (b)
        Set(FLAGS::CY);
    else
        Clear(FLAGS::CY);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x2e102
movq -0x18(%rbp), %rdi
movl $0x10, %esi
callq 0x2dfb0
jmp 0x2e110
movq -0x18(%rbp), %rdi
movl $0x10, %esi
callq 0x2dff0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/src/CPU.cpp
// Function: CPU::SetH(bool)
void CPU::SetH(bool b) {
    if (b)
        Set(FLAGS::H);
    else
        Clear(FLAGS::H);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x2e152
movq -0x18(%rbp), %rdi
movl $0x20, %esi
callq 0x2dfb0
jmp 0x2e160
movq -0x18(%rbp), %rdi
movl $0x20, %esi
callq 0x2dff0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/src/CPU.cpp
// Function: CPU::Increment(FULL_REGISTERS)
void CPU::Increment(FULL_REGISTERS r) {
    std::uint16_t value = 0;
    REGISTERS hi;
    REGISTERS lo;
    switch (r) {
        case FULL_REGISTERS::AF:
            hi = REGISTERS::A;
            lo = REGISTERS::F;
            break;
        case FULL_REGISTERS::BC:
            hi = REGISTERS::B;
            lo = REGISTERS::C;
            break;
        case FULL_REGISTERS::DE:
            hi = REGISTERS::D;
            lo = REGISTERS::E;
            break;
        case FULL_REGISTERS::HL:
            hi = REGISTERS::H;
            lo = REGISTERS::L;
            break;
    }

    value = (regs[hi] << 8) | regs[lo];
    value++;
    uint8_t top = (value & 0xFF00) >> 8;
    uint8_t bot = (value & 0x00FF);
    Set(hi, top);
    Set(lo, bot);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movw $0x0, -0xe(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x3, %rax
ja 0x2e35c
movq -0x28(%rbp), %rax
leaq 0xab6f(%rip), %rcx      # 0x38e84
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x7, -0x14(%rbp)
movl $0x6, -0x18(%rbp)
jmp 0x2e35c
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
jmp 0x2e35c
movl $0x2, -0x14(%rbp)
movl $0x3, -0x18(%rbp)
jmp 0x2e35c
movl $0x4, -0x14(%rbp)
movl $0x5, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl (%rdi,%rax), %eax
shll $0x8, %eax
movl -0x18(%rbp), %ecx
movzbl (%rdi,%rcx), %ecx
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movw -0xe(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movb %al, -0x19(%rbp)
movzwl -0xe(%rbp), %eax
andl $0xff, %eax
movb %al, -0x1a(%rbp)
movl -0x14(%rbp), %esi
movzbl -0x19(%rbp), %edx
callq 0x2df00
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %esi
movzbl -0x1a(%rbp), %edx
callq 0x2df00
addq $0x30, %rsp
popq %rbp
retq
// File: RegulusImpact[P]sadboy/src/CPU.cpp
// Function: CPU::ReadPC16()
std::uint16_t CPU::ReadPC16() {
    std::uint8_t lo = ReadPC();
    std::uint8_t hi = ReadPC();
    std::uint16_t addr = (((uint16_t)hi) << 8) | lo;

    return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x2e4a0
movq -0x18(%rbp), %rdi
movb %al, -0x9(%rbp)
callq 0x2e4a0
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
movzwl %ax, %eax
shll $0x8, %eax
movzbl -0x9(%rbp), %ecx
orl %ecx, %eax
movw %ax, -0xc(%rbp)
movw -0xc(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: RegulusImpact[P]sadboy/src/CPU.cpp
// Function: CPU::PopSP()
uint8_t CPU::PopSP() {
    uint16_t addr = stackPointer++;
    uint8_t n = mmu->Read(addr);
    //mmu->Write(addr, (uint8_t)0x00);
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw 0x1a(%rax), %cx
movw %cx, %dx
addw $0x1, %dx
movw %dx, 0x1a(%rax)
movw %cx, -0xa(%rbp)
movq 0x10(%rax), %rdi
movzwl -0xa(%rbp), %esi
callq 0x334c0
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)