LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: DoubleString[P]RtConverter/src/Json/json_reader.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 0x12c20
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x9a50
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rcx
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x14080
movb %al, -0x75(%rbp)
jmp 0x1428d
movb -0x75(%rbp), %al
andb $0x1, %al
movb %al, -0x61(%rbp)
testb $0x1, -0x61(%rbp)
jne 0x142c6
leaq -0x60(%rbp), %rdi
callq 0x1db90
jmp 0x142a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9480
leaq -0x40(%rbp), %rdi
callq 0x130b0
jmp 0x142f3
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9480
leaq -0x40(%rbp), %rdi
callq 0x130b0
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/../Json/json_tool.h
// Function: Json::getDecimalPoint()
static inline 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 0x9e60
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x14326
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x9(%rbp)
jmp 0x1432d
xorl %eax, %eax
movb %al, -0x9(%rbp)
jmp 0x1432d
movb -0x9(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/../Json/json_tool.h
// Function: void Json::fixNumericLocaleInput<char*>(char*, char*)
void fixNumericLocaleInput(Iter begin, Iter end) {
  char decimalPoint = getDecimalPoint();
  if (decimalPoint == '\0' || decimalPoint == '.') {
    return;
  }
  for (; begin != end; ++begin) {
    if (*begin == '.') {
      *begin = decimalPoint;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x14300
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
je 0x14bda
movsbl -0x11(%rbp), %eax
cmpl $0x2e, %eax
jne 0x14bdc
jmp 0x14c0d
jmp 0x14bde
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x14c0d
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x14bfd
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
jmp 0x14bff
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x14bde
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_reader.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 0xe8b0
andb $0x1, %al
movb %al, -0x29(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x16b08
movq -0x58(%rbp), %rsi
addq $0x10, %rsi
leaq -0x50(%rbp), %rdi
callq 0x12400
movq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x9920
leaq -0x50(%rbp), %rdi
callq 0x9480
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::CommentInfo::setComment(char const*, unsigned long)
void Value::CommentInfo::setComment(const char* text, size_t len) {
  if (comment_) {
    releaseStringValue(comment_, 0u);
    comment_ = 0;
  }
  JSON_ASSERT(text != 0);
  JSON_ASSERT_MESSAGE(
      text[0] == '\0' || text[0] == '/',
      "in Json::Value::setComment(): Comments must start with /");
  // It seems that /**/ style comments are acceptable as well.
  comment_ = duplicateStringValue(text, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f0(%rbp)
cmpq $0x0, (%rax)
je 0x1dee7
movq -0x1f0(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1de80
movq -0x1f0(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x1df53
leaq -0x39(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x9d30
movq -0x1f8(%rbp), %rdx
leaq 0x9dfbb(%rip), %rsi     # 0xbbec7
leaq -0x38(%rbp), %rdi
callq 0x9a30
jmp 0x1df17
leaq -0x38(%rbp), %rdi
callq 0x1ddc0
jmp 0x1df22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1df45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9480
leaq -0x39(%rbp), %rdi
callq 0x97e0
jmp 0x1e011
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1dfee
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x1dfee
leaq -0x1c8(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x9a00
movq -0x200(%rbp), %rdi
leaq 0x9df4a(%rip), %rsi     # 0xbbeda
callq 0x9760
jmp 0x1df97
leaq -0x1e8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x9790
jmp 0x1dfac
leaq -0x1e8(%rbp), %rdi
callq 0x1ddc0
jmp 0x1dfba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1dfe0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x9480
leaq -0x1c8(%rbp), %rdi
callq 0x91d0
jmp 0x1e011
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e020
movq %rax, %rcx
movq -0x1f0(%rbp), %rax
movq %rcx, (%rax)
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x9d20
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.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 0x1e042
movq $0x7ffffffe, -0x10(%rbp) # imm = 0x7FFFFFFE
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x99e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1e0b6
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x9d30
movq -0x58(%rbp), %rdx
leaq 0x9e50b(%rip), %rsi     # 0xbc57d
leaq -0x38(%rbp), %rdi
callq 0x9a30
jmp 0x1e07d
leaq -0x38(%rbp), %rdi
callq 0x1db90
jmp 0x1e088
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1e0ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9480
leaq -0x39(%rbp), %rdi
callq 0x97e0
jmp 0x1e0dd
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x9610
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 0x9d20
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.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 0x1e1b1
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1e1b1
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 0x1e020
movq %rax, -0x20(%rbp)
jmp 0x1e1bc
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 0x1e1ed
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 0x1e1fa
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: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::CZString::~CZString()
Value::CZString::~CZString() {
  if (cstr_ && storage_.policy_ == duplicate) {
    releaseStringValue(const_cast<char*>(cstr_),
                       storage_.length_ + 1u); // +1 for null terminating
                                               // character for sake of
                                               // completeness but not actually
                                               // necessary
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x1e2c1
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x1e2c1
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl 0x8(%rax), %esi
shrl $0x2, %esi
incl %esi
callq 0x1de80
jmp 0x1e2bf
jmp 0x1e2c1
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x15730
nop
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::CZString::operator=(Json::Value::CZString&&)
Value::CZString& Value::CZString::operator=(CZString&& other) {
  cstr_ = other.cstr_;
  index_ = other.index_;
  other.cstr_ = nullptr;
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq $0x0, (%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.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 0x1e3b9
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 0x1e499
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 0x25600
movq %rax, %rcx
movq -0x68(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x24(%rbp)
cmpq $0x0, (%rax)
je 0x1e3fc
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1e458
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x9d30
movq -0x70(%rbp), %rdx
leaq 0x9dab3(%rip), %rsi     # 0xbbec7
leaq -0x48(%rbp), %rdi
callq 0x9a30
jmp 0x1e41f
leaq -0x48(%rbp), %rdi
callq 0x1ddc0
jmp 0x1e42a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1e44d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9480
leaq -0x49(%rbp), %rdi
callq 0x97e0
jmp 0x1e4a4
movq -0x68(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x9310
movl %eax, -0x60(%rbp)
cmpl $0x0, -0x60(%rbp)
jge 0x1e47f
movb $0x1, -0x1(%rbp)
jmp 0x1e499
cmpl $0x0, -0x60(%rbp)
jle 0x1e48b
movb $0x0, -0x1(%rbp)
jmp 0x1e499
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 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.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_;
  if (this_len != other_len)
    return false;
  JSON_ASSERT(this->cstr_ && other.cstr_);
  int comp = memcmp(this->cstr_, other.cstr_, this_len);
  return comp == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, (%rax)
jne 0x1e4e9
movq -0x60(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1e5ab
movq -0x60(%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)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x1e514
movb $0x0, -0x1(%rbp)
jmp 0x1e5ab
movq -0x60(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1e528
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1e584
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x9d30
movq -0x68(%rbp), %rdx
leaq 0x9d987(%rip), %rsi     # 0xbbec7
leaq -0x40(%rbp), %rdi
callq 0x9a30
jmp 0x1e54b
leaq -0x40(%rbp), %rdi
callq 0x1ddc0
jmp 0x1e556
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1e579
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9480
leaq -0x41(%rbp), %rdi
callq 0x97e0
jmp 0x1e5b6
movq -0x60(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x9310
movl %eax, -0x58(%rbp)
cmpl $0x0, -0x58(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x9d20
nop
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::Value(Json::ValueType)
Value::Value(ValueType type) {
  static char const emptyString[] = "";
  initBasic(type);
  switch (type) {
  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 0x1e6a0
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x1e66d
movq -0x18(%rbp), %rax
leaq 0x9d69f(%rip), %rcx     # 0xbbc98
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x1e68c
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0x1e68c
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x1e68c
movq -0x20(%rbp), %rax
leaq 0x9d802(%rip), %rcx     # 0xbbe2e
movq %rcx, (%rax)
jmp 0x1e68c
movl $0x30, %edi
callq 0x9780
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x93d0
movq -0x28(%rbp), %rdi
callq 0x25640
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1e68c
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0x1e68c
leaq 0x9d89f(%rip), %rdi     # 0xbbf13
leaq 0x9d89e(%rip), %rsi     # 0xbbf19
movl $0x181, %edx            # imm = 0x181
leaq 0x9d8ab(%rip), %rcx     # 0xbbf32
callq 0x94e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::initBasic(Json::ValueType, bool)
void Value::initBasic(ValueType type, bool allocated) {
  type_ = type;
  allocated_ = allocated;
  comments_ = 0;
  start_ = 0;
  limit_ = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movw %cx, %dx
movw 0x8(%rax), %cx
andw $0xff, %dx
andw $0xff00, %cx            # imm = 0xFF00
orw %dx, %cx
movw %cx, 0x8(%rax)
movb -0xd(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
movw %cx, %dx
movw 0x8(%rax), %cx
andw $0x1, %dx
shlw $0x8, %dx
andw $0xfeff, %cx            # imm = 0xFEFF
orw %dx, %cx
movw %cx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
popq %rbp
retq
nop
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::Value(char const*)
Value::Value(const char* value) {
  initBasic(stringValue, true);
  JSON_ASSERT_MESSAGE(value != NULL, "Null Value Passed to Value Constructor");
  value_.string_ = duplicateAndPrefixStringValue(
      value, static_cast<unsigned>(strlen(value)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
movl $0x4, %esi
movl $0x1, %edx
callq 0x1e6a0
cmpq $0x0, -0x10(%rbp)
jne 0x1e913
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x9a00
movq -0x1c8(%rbp), %rdi
leaq 0x9d6a7(%rip), %rsi     # 0xbbf50
callq 0x9760
jmp 0x1e8b0
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x9790
jmp 0x1e8c5
leaq -0x1b8(%rbp), %rdi
callq 0x1ddc0
jmp 0x1e8d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x1e905
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x9480
leaq -0x188(%rbp), %rdi
callq 0x91d0
jmp 0x1e94b
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x92e0
movq -0x1d0(%rbp), %rdi
movl %eax, %esi
callq 0x1e960
movq %rax, %rcx
movq -0x1c0(%rbp), %rax
movq %rcx, (%rax)
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x9d20
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::duplicateAndPrefixStringValue(char const*, unsigned int)
static inline char* duplicateAndPrefixStringValue(const char* value,
                                                  unsigned int length) {
  // Avoid an integer overflow in the call to malloc below by limiting length
  // to a sane value.
  JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) -
                                    sizeof(unsigned) - 1U,
                      "in Json::Value::duplicateAndPrefixStringValue(): "
                      "length too big for prefixing");
  unsigned actualLength = length + static_cast<unsigned>(sizeof(unsigned)) + 1U;
  char* newString = static_cast<char*>(malloc(actualLength));
  if (newString == 0) {
    throwRuntimeError("in Json::Value::duplicateAndPrefixStringValue(): "
                      "Failed to allocate string value buffer");
  }
  *reinterpret_cast<unsigned*>(newString) = length;
  memcpy(newString + sizeof(unsigned), value, length);
  newString[actualLength - 1U] =
      0; // to avoid buffer over-run accidents by users later
  return newString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0x7ffffffa, %rax       # imm = 0x7FFFFFFA
jbe 0x1ea0f
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x9a00
movq -0x1f8(%rbp), %rdi
leaq 0x9dc2a(%rip), %rsi     # 0xbc5cc
callq 0x9760
jmp 0x1e9a9
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x9790
jmp 0x1e9be
leaq -0x1b8(%rbp), %rdi
callq 0x1ddc0
jmp 0x1e9cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x1e9fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x9480
leaq -0x188(%rbp), %rdi
callq 0x91d0
jmp 0x1eb04
movl -0xc(%rbp), %eax
addl $0x4, %eax
addl $0x1, %eax
movl %eax, -0x1bc(%rbp)
movl -0x1bc(%rbp), %eax
movl %eax, %edi
callq 0x99e0
movq %rax, -0x1c8(%rbp)
cmpq $0x0, -0x1c8(%rbp)
jne 0x1eab9
leaq -0x1e9(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x9d30
movq -0x200(%rbp), %rdx
leaq 0x9dbbd(%rip), %rsi     # 0xbc61a
leaq -0x1e8(%rbp), %rdi
callq 0x9a30
jmp 0x1ea6b
leaq -0x1e8(%rbp), %rdi
callq 0x1db90
jmp 0x1ea79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x1eaab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x9480
leaq -0x1e9(%rbp), %rdi
callq 0x97e0
jmp 0x1eb04
movl -0xc(%rbp), %ecx
movq -0x1c8(%rbp), %rax
movl %ecx, (%rax)
movq -0x1c8(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
callq 0x9610
movq -0x1c8(%rbp), %rax
movl -0x1bc(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq -0x1c8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x9d20
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::dupPayload(Json::Value const&)
void Value::dupPayload(const Value& other) {
  type_ = other.type_;
  allocated_ = false;
  switch (type_) {
  case nullValue:
  case intValue:
  case uintValue:
  case realValue:
  case booleanValue:
    value_ = other.value_;
    break;
  case stringValue:
    if (other.value_.string_ && other.allocated_) {
      unsigned len;
      char const* str;
      decodePrefixedString(other.allocated_, other.value_.string_, &len, &str);
      value_.string_ = duplicateAndPrefixStringValue(str, len);
      allocated_ = true;
    } else {
      value_.string_ = other.value_.string_;
    }
    break;
  case arrayValue:
  case objectValue:
    value_.map_ = new ObjectValues(*other.value_.map_);
    break;
  default:
    JSON_ASSERT_UNREACHABLE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movb 0x8(%rcx), %cl
movb %cl, 0x8(%rax)
movb 0x9(%rax), %cl
andb $-0x2, %cl
movb %cl, 0x9(%rax)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movl %ecx, -0x30(%rbp)
subw $0x4, %ax
jb 0x1ecf5
jmp 0x1eccd
movl -0x30(%rbp), %eax
subl $0x4, %eax
je 0x1ed08
jmp 0x1ecd7
movl -0x30(%rbp), %eax
subl $0x5, %eax
je 0x1ecf5
jmp 0x1ece1
movl -0x30(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0x1ed97
jmp 0x1eddd
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
jmp 0x1edfc
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1ed87
movq -0x10(%rbp), %rax
movw 0x8(%rax), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x1ed87
movq -0x10(%rbp), %rax
movw 0x8(%rax), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
setne %al
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
movzbl %al, %edi
andl $0x1, %edi
leaq -0x14(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x1f770
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1e960
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movw 0x8(%rax), %cx
andw $0xfeff, %cx            # imm = 0xFEFF
orw $0x100, %cx             # imm = 0x100
movw %cx, 0x8(%rax)
jmp 0x1ed95
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
jmp 0x1edfc
movl $0x30, %edi
callq 0x9780
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x25a40
jmp 0x1edb9
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x1edfc
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x9700
jmp 0x1ee02
leaq 0x9d12f(%rip), %rdi     # 0xbbf13
leaq 0x9d12e(%rip), %rsi     # 0xbbf19
movl $0x411, %edx            # imm = 0x411
leaq 0x9d600(%rip), %rcx     # 0xbc3f7
callq 0x94e0
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x9d20
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.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 0x1ef66
movl $0x20, %edi
callq 0x9040
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 0x1de20
jmp 0x1ee75
movq -0x40(%rbp), %rcx
movq -0x58(%rbp), %rax
addq $0x8, %rax
cmpq %rcx, %rax
movq %rax, -0x38(%rbp)
jne 0x1ee66
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x1ef64
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 0x1ef54
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 0x92e0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x1dea0
jmp 0x1ef54
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 0x1ef49
movq -0x70(%rbp), %rdi
addq $-0x8, %rdi
movq %rdi, -0x78(%rbp)
callq 0x1de40
movq -0x48(%rbp), %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x70(%rbp)
jne 0x1ef27
movq -0x50(%rbp), %rdi
callq 0x99a0
jmp 0x1ef97
jmp 0x1ef56
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1ee9d
jmp 0x1ef72
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 0x9d20
// File: DoubleString[P]RtConverter/src/Json/json_value.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 0x1f137
jmp 0x1f116
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x1f139
jmp 0x1f120
movl -0xc(%rbp), %eax
subl $0x5, %eax
je 0x1f137
jmp 0x1f12a
movl -0xc(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0x1f15f
jmp 0x1f184
jmp 0x1f1a3
movq -0x18(%rbp), %rax
movw 0x8(%rax), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x1f15d
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x227a0
jmp 0x1f1a3
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1f182
movq -0x20(%rbp), %rdi
callq 0x25a70
movq -0x20(%rbp), %rdi
callq 0x9700
jmp 0x1f1a3
leaq 0x9cd88(%rip), %rdi     # 0xbbf13
leaq 0x9cd87(%rip), %rsi     # 0xbbf19
movl $0x426, %edx            # imm = 0x426
leaq 0x9d285(%rip), %rcx     # 0xbc423
callq 0x94e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::swapPayload(Json::Value&)
void Value::swapPayload(Value& other) {
  ValueType temp = type_;
  type_ = other.type_;
  other.type_ = temp;
  std::swap(value_, other.value_);
  int temp2 = allocated_;
  allocated_ = other.allocated_;
  other.allocated_ = temp2 & 0x1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movw 0x8(%rdi), %ax
andw $0xff, %ax
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
movw %ax, %cx
movw 0x8(%rdi), %ax
andw $0xff, %cx
andw $0xff00, %ax            # imm = 0xFF00
orw %cx, %ax
movw %ax, 0x8(%rdi)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movw %cx, %dx
movw 0x8(%rax), %cx
andw $0xff, %dx
andw $0xff00, %cx            # imm = 0xFF00
orw %dx, %cx
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rsi
callq 0x25680
movq -0x20(%rbp), %rax
movw 0x8(%rax), %cx
shrw $0x8, %cx
andw $0x1, %cx
movzwl %cx, %ecx
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movw 0x8(%rcx), %cx
shrw $0x8, %cx
andw $0x1, %cx
movzwl %cx, %ecx
movw %cx, %dx
movw 0x8(%rax), %cx
andw $0x1, %dx
shlw $0x8, %dx
andw $0xfeff, %cx            # imm = 0xFEFF
orw %dx, %cx
movw %cx, 0x8(%rax)
movl -0x18(%rbp), %ecx
andl $0x1, %ecx
movq -0x10(%rbp), %rax
movw %cx, %dx
movw 0x8(%rax), %cx
andw $0x1, %dx
shlw $0x8, %dx
andw $0xfeff, %cx            # imm = 0xFEFF
orw %dx, %cx
movw %cx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::decodePrefixedString(bool, char const*, unsigned int*, char const**)
inline static void decodePrefixedString(bool isPrefixed,
                                        char const* prefixed,
                                        unsigned* length,
                                        char const** value) {
  if (!isPrefixed) {
    *length = static_cast<unsigned>(strlen(prefixed));
    *value = prefixed;
  } else {
    *length = *reinterpret_cast<unsigned const*>(prefixed);
    *value = prefixed + sizeof(unsigned);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
testb $0x1, -0x1(%rbp)
jne 0x1f7b0
movq -0x10(%rbp), %rdi
callq 0x92e0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1f7cb
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
addq $0x4, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::asCString() const
const char* Value::asCString() const {
  JSON_ASSERT_MESSAGE(type_ == stringValue,
                      "in Json::Value::asCString(): requires stringValue");
  if (value_.string_ == 0)
    return 0;
  unsigned this_len;
  char const* this_str;
  decodePrefixedString(this->allocated_, this->value_.string_, &this_len,
                       &this_str);
  return this_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x4, %eax
je 0x1fbf9
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x9a00
movq -0x1d8(%rbp), %rdi
leaq 0x9c44b(%rip), %rsi     # 0xbbfda
callq 0x9760
jmp 0x1fb96
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x9790
jmp 0x1fbab
leaq -0x1b8(%rbp), %rdi
callq 0x1ddc0
jmp 0x1fbb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x1fbeb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x9480
leaq -0x188(%rbp), %rdi
callq 0x91d0
jmp 0x1fc60
movq -0x1d0(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1fc10
movq $0x0, -0x8(%rbp)
jmp 0x1fc53
movq -0x1d0(%rbp), %rcx
movw 0x8(%rcx), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
setne %al
movq (%rcx), %rsi
movzbl %al, %edi
andl $0x1, %edi
leaq -0x1bc(%rbp), %rdx
leaq -0x1c8(%rbp), %rcx
callq 0x1f770
movq -0x1c8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::getString(char const**, char const**) const
bool Value::getString(char const** begin, char const** end) const {
  if (type_ != stringValue)
    return false;
  if (value_.string_ == 0)
    return false;
  unsigned length;
  decodePrefixedString(this->allocated_, this->value_.string_, &length, begin);
  *end = *begin + length;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x4, %eax
je 0x1fca2
movb $0x0, -0x1(%rbp)
jmp 0x1fcf9
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1fcb2
movb $0x0, -0x1(%rbp)
jmp 0x1fcf9
movq -0x30(%rbp), %rcx
movw 0x8(%rcx), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
setne %al
movq (%rcx), %rsi
movq -0x18(%rbp), %rcx
movzbl %al, %edi
andl $0x1, %edi
leaq -0x24(%rbp), %rdx
callq 0x1f770
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movl -0x24(%rbp), %eax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.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 0x203ad
jmp 0x20396
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x203da
jmp 0x203a0
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x203ef
jmp 0x2043b
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $-0x80000000, (%rcx)    # imm = 0x80000000
movb %al, -0x21(%rbp)
jl 0x203d0
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 0x20441
movq -0x20(%rbp), %rax
cmpq $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
setbe %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x20441
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
xorl %eax, %eax
movsd 0x9ba2f(%rip), %xmm1    # 0xbbe30
ucomisd %xmm1, %xmm0
movb %al, -0x22(%rbp)
jb 0x20431
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movsd 0x9ba20(%rip), %xmm0    # 0xbbe38
ucomisd (%rcx), %xmm0
movb %al, -0x22(%rbp)
jb 0x20431
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
callq 0x24150
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x20441
jmp 0x2043d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.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 0x2081d
jmp 0x20806
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x20848
jmp 0x20810
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x2085e
jmp 0x208a5
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x21(%rbp)
jl 0x2083e
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 0x208ab
movq -0x20(%rbp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, (%rax)
setbe %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x208ab
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x22(%rbp)
jb 0x2089b
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movsd 0x9b5be(%rip), %xmm0    # 0xbbe40
ucomisd (%rcx), %xmm0
movb %al, -0x22(%rbp)
jb 0x2089b
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
callq 0x24150
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x208ab
jmp 0x208a7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::asDouble() const
double Value::asDouble() const {
  switch (type_) {
  case intValue:
    return static_cast<double>(value_.int_);
  case uintValue:
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
    return static_cast<double>(value_.uint_);
#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
    return integerToDouble(value_.uint_);
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
  case realValue:
    return value_.real_;
  case nullValue:
    return 0.0;
  case booleanValue:
    return value_.bool_ ? 1.0 : 0.0;
  default:
    break;
  }
  JSON_FAIL_MESSAGE("Value is not convertible to double.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movq %rcx, -0x1c0(%rbp)
subw $0x5, %ax
ja 0x21212
movq -0x1c0(%rbp), %rax
leaq 0x9ac20(%rip), %rcx     # 0xbbd70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x1c8(%rbp), %rax
cvtsi2sdq (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2129f
movq -0x1c8(%rbp), %rax
movq (%rax), %xmm0
movaps 0x9acef(%rip), %xmm1    # 0xbbe70
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x9acf3(%rip), %xmm1    # 0xbbe80
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2129f
movq -0x1c8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2129f
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2129f
movq -0x1c8(%rbp), %rax
movb (%rax), %al
movsd 0x9ac87(%rip), %xmm0    # 0xbbe60
xorps %xmm1, %xmm1
movsd %xmm1, -0x1d8(%rbp)
testb $0x1, %al
movsd %xmm0, -0x1d0(%rbp)
jne 0x21200
movsd -0x1d8(%rbp), %xmm0
movsd %xmm0, -0x1d0(%rbp)
movsd -0x1d0(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2129f
jmp 0x21214
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0x9a00
movq -0x1e0(%rbp), %rdi
leaq 0x9afa0(%rip), %rsi     # 0xbc1d5
callq 0x9760
jmp 0x2123c
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x9790
jmp 0x21251
leaq -0x1b8(%rbp), %rdi
callq 0x1ddc0
jmp 0x2125f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x21291
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x9480
leaq -0x188(%rbp), %rdi
callq 0x91d0
jmp 0x212ad
movsd -0x8(%rbp), %xmm0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::operator[](unsigned int) const
const Value& Value::operator[](ArrayIndex index) const {
  JSON_ASSERT_MESSAGE(
      type_ == nullValue || type_ == arrayValue,
      "in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
  if (type_ == nullValue)
    return nullSingleton();
  CZString key(index);
  ObjectValues::const_iterator it = value_.map_->find(key);
  if (it == value_.map_->end())
    return nullSingleton();
  return (*it).second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x200(%rbp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x2257a
movq -0x200(%rbp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x6, %eax
je 0x2257a
leaq -0x190(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0x9a00
movq -0x208(%rbp), %rdi
leaq 0x99e63(%rip), %rsi     # 0xbc370
callq 0x9760
jmp 0x22514
leaq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x9790
jmp 0x22529
leaq -0x1c0(%rbp), %rdi
callq 0x1ddc0
jmp 0x22537
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x22569
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x9480
leaq -0x190(%rbp), %rdi
callq 0x91d0
jmp 0x226b3
movq -0x200(%rbp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x2259f
callq 0x1d3c0
movq %rax, -0x8(%rbp)
jmp 0x226a6
movl -0x14(%rbp), %esi
leaq -0x1d0(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x1e0f0
movq -0x200(%rbp), %rax
movq -0x218(%rbp), %rsi
movq (%rax), %rdi
callq 0x259e0
movq %rax, -0x210(%rbp)
jmp 0x225d4
movq -0x210(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x1d8(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x25810
movq -0x200(%rbp), %rax
movq (%rax), %rdi
callq 0x257e0
movq %rax, -0x1f0(%rbp)
leaq -0x1e8(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x25810
leaq -0x1d8(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x25a10
testb $0x1, %al
jne 0x22637
jmp 0x2267c
callq 0x1d3c0
movq %rax, -0x220(%rbp)
jmp 0x22645
movq -0x220(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x1f4(%rbp)
jmp 0x2269a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x1e280
jmp 0x226b3
leaq -0x1d8(%rbp), %rdi
callq 0x25860
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x1f4(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x1e280
movq -0x8(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x9d20
nop
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::find(char const*, char const*) const
Value const* Value::find(char const* begin, char const* end) const {
  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
                      "in Json::Value::find(key, end, found): requires "
                      "objectValue or nullValue");
  if (type_ == nullValue)
    return NULL;
  CZString actualKey(begin, static_cast<unsigned>(end - begin),
                     CZString::noDuplication);
  ObjectValues::const_iterator it = value_.map_->find(actualKey);
  if (it == value_.map_->end())
    return NULL;
  return &(*it).second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x208(%rbp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x2303f
movq -0x208(%rbp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x7, %eax
je 0x2303f
leaq -0x198(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x9a00
movq -0x210(%rbp), %rdi
leaq 0x994ee(%rip), %rsi     # 0xbc4c0
callq 0x9760
jmp 0x22fd9
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x9790
jmp 0x22fee
leaq -0x1c8(%rbp), %rdi
callq 0x1ddc0
jmp 0x22ffc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x2302e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x9480
leaq -0x198(%rbp), %rdi
callq 0x91d0
jmp 0x23170
movq -0x208(%rbp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x23063
movq $0x0, -0x8(%rbp)
jmp 0x23163
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
movl %esi, %eax
subl %eax, %edx
leaq -0x1d8(%rbp), %rdi
movq %rdi, -0x220(%rbp)
xorl %ecx, %ecx
callq 0x1e110
movq -0x208(%rbp), %rax
movq -0x220(%rbp), %rsi
movq (%rax), %rdi
callq 0x259e0
movq %rax, -0x218(%rbp)
jmp 0x230a2
movq -0x218(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x1e0(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x25810
movq -0x208(%rbp), %rax
movq (%rax), %rdi
callq 0x257e0
movq %rax, -0x1f8(%rbp)
leaq -0x1f0(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0x25810
leaq -0x1e0(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x25a10
testb $0x1, %al
jne 0x23105
jmp 0x23139
movq $0x0, -0x8(%rbp)
movl $0x1, -0x1fc(%rbp)
jmp 0x23157
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x1e280
jmp 0x23170
leaq -0x1e0(%rbp), %rdi
callq 0x25860
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x1fc(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x1e280
movq -0x8(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x9d20
nopl (%rax)