LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::OurReader::readStringSingleQuote()
bool OurReader::readStringSingleQuote() {
  Char c = 0;
  while (current_ != end_) {
    c = getNextChar();
    if (c == '\\')
      getNextChar();
    else if (c == '\'')
      break;
  }
  return c == '\'';
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movb $0x0, 0xf(%rsp)
movq (%rsp), %rcx
movq 0xd0(%rcx), %rax
cmpq 0xc8(%rcx), %rax
je 0xe720d
movq (%rsp), %rdi
callq 0xe70f0
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x5c, %eax
jne 0xe71fd
movq (%rsp), %rdi
callq 0xe70f0
jmp 0xe720b
movsbl 0xf(%rsp), %eax
cmpl $0x27, %eax
jne 0xe7209
jmp 0xe720d
jmp 0xe720b
jmp 0xe71c7
movsbl 0xf(%rsp), %eax
cmpl $0x27, %eax
sete %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::OurReader::getStructuredErrors() const
std::vector<OurReader::StructuredError> OurReader::getStructuredErrors() const {
  std::vector<OurReader::StructuredError> allErrors;
  for (Errors::const_iterator itError = errors_.begin();
       itError != errors_.end();
       ++itError) {
    const ErrorInfo& error = *itError;
    OurReader::StructuredError structured;
    structured.offset_start = error.token_.start_ - begin_;
    structured.offset_limit = error.token_.end_ - begin_;
    structured.message = error.message_;
    allErrors.push_back(structured);
  }
  return allErrors;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0xa7(%rsp)
callq 0xf9b00
movq 0x10(%rsp), %rsi
addq $0x50, %rsi
leaq 0x80(%rsp), %rdi
callq 0xf9a10
movq 0x10(%rsp), %rsi
addq $0x50, %rsi
leaq 0x60(%rsp), %rdi
callq 0xf9a70
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xf9a40
testb $0x1, %al
jne 0xe9311
jmp 0xe93c6
leaq 0x80(%rsp), %rdi
callq 0xf9aa0
movq %rax, 0x58(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xf9b10
movq 0x10(%rsp), %rcx
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq 0xc0(%rcx), %rdx
subq %rdx, %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq 0xc0(%rcx), %rcx
subq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rsi
addq $0x18, %rsi
leaq 0x38(%rsp), %rdi
callq 0x12080
jmp 0xe9377
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf9b30
jmp 0xe9387
leaq 0x28(%rsp), %rdi
callq 0xf9ba0
leaq 0x80(%rsp), %rdi
callq 0xf9ab0
jmp 0xe92e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xf9ba0
movq (%rsp), %rdi
callq 0xf9bc0
jmp 0xe93ee
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0xe93e1
movq (%rsp), %rdi
callq 0xf9bc0
movq 0x8(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x12c20
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::CharReaderBuilder::newCharReader() const
CharReader* CharReaderBuilder::newCharReader() const
{
  bool collectComments = settings_["collectComments"].asBool();
  OurFeatures features = OurFeatures::all();
  features.allowComments_ = settings_["allowComments"].asBool();
  features.strictRoot_ = settings_["strictRoot"].asBool();
  features.allowDroppedNullPlaceholders_ = settings_["allowDroppedNullPlaceholders"].asBool();
  features.allowNumericKeys_ = settings_["allowNumericKeys"].asBool();
  features.allowSingleQuotes_ = settings_["allowSingleQuotes"].asBool();
  features.stackLimit_ = settings_["stackLimit"].asInt();
  features.failIfExtra_ = settings_["failIfExtra"].asBool();
  features.rejectDupKeys_ = settings_["rejectDupKeys"].asBool();
  features.allowSpecialFloats_ = settings_["allowSpecialFloats"].asBool();
  return new OurCharReader(collectComments, features);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
movq %rdi, (%rsp)
leaq 0x8086d(%rip), %rsi     # 0x16a58a
callq 0xe9eb0
movq %rax, %rdi
callq 0xe9f30
movb %al, 0x3f(%rsp)
callq 0xe4c70
movq (%rsp), %rdi
movl %edx, 0x28(%rsp)
movq %rax, 0x20(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x80841(%rip), %rsi     # 0x16a59a
callq 0xe9eb0
movq %rax, %rdi
callq 0xe9f30
movq (%rsp), %rdi
movb %al, 0x30(%rsp)
leaq 0x80833(%rip), %rsi     # 0x16a5a8
callq 0xe9eb0
movq %rax, %rdi
callq 0xe9f30
movq (%rsp), %rdi
movb %al, 0x31(%rsp)
leaq 0x80822(%rip), %rsi     # 0x16a5b3
callq 0xe9eb0
movq %rax, %rdi
callq 0xe9f30
movq (%rsp), %rdi
movb %al, 0x32(%rsp)
leaq 0x80823(%rip), %rsi     # 0x16a5d0
callq 0xe9eb0
movq %rax, %rdi
callq 0xe9f30
movq (%rsp), %rdi
movb %al, 0x33(%rsp)
leaq 0x80818(%rip), %rsi     # 0x16a5e1
callq 0xe9eb0
movq %rax, %rdi
callq 0xe9f30
movq (%rsp), %rdi
movb %al, 0x34(%rsp)
leaq 0x8080e(%rip), %rsi     # 0x16a5f3
callq 0xe9eb0
movq %rax, %rdi
callq 0xea0a0
movq (%rsp), %rdi
movl %eax, 0x38(%rsp)
leaq 0x807fd(%rip), %rsi     # 0x16a5fe
callq 0xe9eb0
movq %rax, %rdi
callq 0xe9f30
movq (%rsp), %rdi
movb %al, 0x35(%rsp)
leaq 0x807ed(%rip), %rsi     # 0x16a60a
callq 0xe9eb0
movq %rax, %rdi
callq 0xe9f30
movq (%rsp), %rdi
movb %al, 0x36(%rsp)
leaq 0x807df(%rip), %rsi     # 0x16a618
callq 0xe9eb0
movq %rax, %rdi
callq 0xe9f30
movb %al, 0x37(%rsp)
movl $0x130, %edi            # imm = 0x130
callq 0x126d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movzbl 0x3f(%rsp), %esi
andl $0x1, %esi
leaq 0x30(%rsp), %rdx
callq 0xf9c40
jmp 0xe9e73
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x130, %esi            # imm = 0x130
callq 0x126e0
movq 0x18(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::asBool() const
bool Value::asBool() const {
  switch (type_) {
  case booleanValue:
    return value_.bool_;
  case nullValue:
    return false;
  case intValue:
    return value_.int_ ? true : false;
  case uintValue:
    return value_.uint_ ? true : false;
  case realValue:
    // This is kind of strange. Not recommended.
    return (value_.real_ != 0.0) ? true : false;
  default:
    break;
  }
  JSON_FAIL_MESSAGE("Value is not convertible to bool.");
}

// Assembly:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x1c8(%rsp)
movq 0x1c8(%rsp), %rax
movq %rax, 0x10(%rsp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movq %rcx, 0x18(%rsp)
subw $0x5, %ax
ja 0xe9ffb
movq 0x18(%rsp), %rax
leaq 0x7ffb6(%rip), %rcx     # 0x169f24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, 0x1d7(%rsp)
jmp 0xea07f
movb $0x0, 0x1d7(%rsp)
jmp 0xea07f
movq 0x10(%rsp), %rax
movq (%rax), %rcx
xorl %eax, %eax
negq %rcx
sbbl %eax, %eax
andb $0x1, %al
movb %al, 0x1d7(%rsp)
jmp 0xea07f
movq 0x10(%rsp), %rax
movq (%rax), %rcx
xorl %eax, %eax
negq %rcx
sbbl %eax, %eax
andb $0x1, %al
movb %al, 0x1d7(%rsp)
jmp 0xea07f
movq 0x10(%rsp), %rax
movsd (%rax), %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
setp %cl
setne %al
orb %cl, %al
negb %al
andb $0x1, %al
movb %al, 0x1d7(%rsp)
jmp 0xea07f
jmp 0xe9ffd
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x12980
movq 0x8(%rsp), %rdi
leaq 0x808f0(%rip), %rsi     # 0x16a908
callq 0x126b0
jmp 0xea01f
leaq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x12700
jmp 0xea030
leaq 0x20(%rsp), %rdi
callq 0xec480
jmp 0xea03c
leaq 0x20(%rsp), %rdi
callq 0x12430
callq 0x12380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xea073
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x12430
leaq 0x50(%rsp), %rdi
callq 0x121a0
jmp 0xea090
movb 0x1d7(%rsp), %al
andb $0x1, %al
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x48(%rsp), %rdi
callq 0x12c20
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::CharReaderBuilder::validate(Json::Value*) const
bool CharReaderBuilder::validate(Json::Value* invalid) const
{
  Json::Value my_invalid;
  if (!invalid) invalid = &my_invalid;  // so we do not need to test for NULL
  Json::Value& inv = *invalid;
  std::set<std::string> valid_keys;
  getValidReaderKeys(&valid_keys);
  Value::Members keys = settings_.getMemberNames();
  size_t n = keys.size();
  for (size_t i = 0; i < n; ++i) {
    std::string const& key = keys[i];
    if (valid_keys.find(key) == valid_keys.end()) {
      inv[key] = settings_[key];
    }
  }
  return 0u == inv.size();
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xe0(%rsp), %rdi
xorl %esi, %esi
callq 0xecc20
cmpq $0x0, 0x108(%rsp)
jne 0xea48e
leaq 0xe0(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0xd8(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xf9cc0
movq 0x20(%rsp), %rdi
callq 0xea6c0
jmp 0xea4bc
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
leaq 0x80(%rsp), %rdi
callq 0xeafb0
jmp 0xea4d4
leaq 0x80(%rsp), %rdi
callq 0xf9cd0
movq %rax, 0x78(%rsp)
movq $0x0, 0x70(%rsp)
movq 0x70(%rsp), %rax
cmpq 0x78(%rsp), %rax
jae 0xea62b
movq 0x70(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0xf9cf0
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0xf9d30
movq %rax, 0x18(%rsp)
jmp 0xea52f
movq 0x18(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0xf9d70
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xf9d10
testb $0x1, %al
jne 0xea563
jmp 0xea616
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
movq 0x68(%rsp), %rsi
callq 0xeb2b0
movq %rax, 0x10(%rsp)
jmp 0xea57d
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0xed200
jmp 0xea58e
movq 0xd8(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0xe3230
movq %rax, 0x8(%rsp)
jmp 0xea5a7
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe3700
jmp 0xea5b8
leaq 0x30(%rsp), %rdi
callq 0xed680
jmp 0xea616
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0xea68f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0xea682
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xed680
jmp 0xea682
jmp 0xea618
movq 0x70(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0xea4ef
movq 0xd8(%rsp), %rdi
callq 0xeb340
movl %eax, 0x4(%rsp)
jmp 0xea63e
movl 0x4(%rsp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
movb %al, 0x3(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xf9da0
leaq 0xa8(%rsp), %rdi
callq 0xf9e00
leaq 0xe0(%rsp), %rdi
callq 0xed680
movb 0x3(%rsp), %al
andb $0x1, %al
addq $0x118, %rsp            # imm = 0x118
retq
leaq 0x80(%rsp), %rdi
callq 0xf9da0
leaq 0xa8(%rsp), %rdi
callq 0xf9e00
leaq 0xe0(%rsp), %rdi
callq 0xed680
movq 0xa0(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::size() const
ArrayIndex Value::size() const {
  switch (type_) {
  case nullValue:
  case intValue:
  case uintValue:
  case realValue:
  case booleanValue:
  case stringValue:
    return 0;
  case arrayValue: // size of the array is highest index + 1
    if (!value_.map_->empty()) {
      ObjectValues::const_iterator itLast = value_.map_->end();
      --itLast;
      return (*itLast).first.index() + 1;
    }
    return 0;
  case objectValue:
    return ArrayIndex(value_.map_->size());
  }
  JSON_ASSERT_UNREACHABLE;
  return 0; // unreachable;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movl %ecx, 0x14(%rsp)
subw $0x6, %ax
jb 0xeb37c
jmp 0xeb366
movl 0x14(%rsp), %eax
subl $0x6, %eax
je 0xeb386
jmp 0xeb371
movl 0x14(%rsp), %eax
subl $0x7, %eax
je 0xeb3e7
jmp 0xeb3fa
movl $0x0, 0x34(%rsp)
jmp 0xeb402
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xfa280
testb $0x1, %al
jne 0xeb3dd
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xfa2a0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xfa2d0
leaq 0x20(%rsp), %rdi
callq 0xfa2f0
leaq 0x20(%rsp), %rdi
callq 0xfa320
movq %rax, %rdi
callq 0xebec0
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xeb402
movl $0x0, 0x34(%rsp)
jmp 0xeb402
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xfa1e0
movl %eax, 0x34(%rsp)
jmp 0xeb402
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.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, std::istream& sin,
    Value* root, std::string* errs)
{
  std::ostringstream ssin;
  ssin << sin.rdbuf();
  std::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:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x210(%rsp)
movq %rsi, 0x208(%rsp)
movq %rdx, 0x200(%rsp)
movq %rcx, 0x1f8(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x12980
movq 0x208(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x122c0
movq %rax, 0x30(%rsp)
jmp 0xeb8f2
movq 0x30(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x12140
jmp 0xeb906
leaq 0x50(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x12700
jmp 0xeb91a
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x123c0
movq 0x18(%rsp), %rdi
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x124d0
movq %rax, %rcx
movq 0x20(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x210(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, 0x28(%rsp)
jmp 0xeb96a
movq 0x28(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf9e10
movq 0x8(%rsp), %rdi
callq 0xf9e40
movq %rax, %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x200(%rsp), %rcx
movq 0x1f8(%rsp), %r8
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movb %al, 0x17(%rsp)
jmp 0xeb9b4
leaq 0x38(%rsp), %rdi
callq 0xf9e50
leaq 0x50(%rsp), %rdi
callq 0x12430
leaq 0x80(%rsp), %rdi
callq 0x121a0
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x218, %rsp            # imm = 0x218
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xeba25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xeba1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xf9e50
leaq 0x50(%rsp), %rdi
callq 0x12430
leaq 0x80(%rsp), %rdi
callq 0x121a0
movq 0x78(%rsp), %rdi
callq 0x12c20
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::operator>>(std::istream&, Json::Value&)
std::istream& operator>>(std::istream& sin, Value& root) {
  CharReaderBuilder b;
  std::string errs;
  bool ok = parseFromStream(b, sin, &root, &errs);
  if (!ok) {
    fprintf(stderr,
            "Error from reader: %s",
            errs.c_str());

    throwRuntimeError(errs);
  }
  return sin;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
leaq 0x68(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xe9790
leaq 0x48(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x129f0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0xa0(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0xeb8a0
movb %al, 0x33(%rsp)
jmp 0xeba9a
movb 0x33(%rsp), %al
andb $0x1, %al
movb %al, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0xebb11
movq 0xc551e(%rip), %rax     # 0x1b0fd0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x12280
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0x7eb53(%rip), %rsi     # 0x16a62b
xorl %eax, %eax
callq 0x12a30
movq 0x18(%rsp), %rdi
callq 0xe0b60
jmp 0xebaeb
jmp 0xebb11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x12430
leaq 0x68(%rsp), %rdi
callq 0xe9c90
jmp 0xebb3f
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x12430
leaq 0x68(%rsp), %rdi
callq 0xe9c90
movq 0x8(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x12c20
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::ValueIteratorBase::computeDistance(Json::ValueIteratorBase const&) const
ValueIteratorBase::difference_type
ValueIteratorBase::computeDistance(const SelfType& other) const {
#ifdef JSON_USE_CPPTL_SMALLMAP
  return other.current_ - current_;
#else
  // Iterator for null value are initialized using the default
  // constructor, which initialize current_ to the default
  // std::map::iterator. As begin() and end() are two instance
  // of the default std::map::iterator, they can not be compared.
  // To allow this, we handle this comparison specifically.
  if (isNull_ && other.isNull_) {
    return 0;
  }

  // Usage of std::distance is not portable (does not compile with Sun Studio 12
  // RogueWave STL,
  // which is the one used by default).
  // Using a portable hand-made version for non random iterator instead:
  //   return difference_type( std::distance( current_, other.current_ ) );
  difference_type myDistance = 0;
  for (Value::ObjectValues::iterator it = current_; it != other.current_;
       ++it) {
    ++myDistance;
  }
  return myDistance;
#endif
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x8(%rax)
je 0xebc13
movq 0x20(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0xebc13
movl $0x0, 0x34(%rsp)
jmp 0xebc5c
movq 0x8(%rsp), %rax
movl $0x0, 0x1c(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0xf9f50
testb $0x1, %al
jne 0xebc3d
jmp 0xebc54
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xf9ef0
jmp 0xebc28
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::ValueIteratorBase::key() const
Value ValueIteratorBase::key() const {
  const Value::CZString czstring = (*current_).first;
  if (czstring.data()) {
    if (czstring.isStaticString())
      return Value(StaticString(czstring.data()));
    return Value(czstring.data(), czstring.data() + czstring.length());
  }
  return Value(czstring.index());
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0xf9f90
movq %rax, %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xec8c0
movq 0x38(%rsp), %rdi
callq 0xebe70
movq %rax, 0x40(%rsp)
jmp 0xebd3e
movq 0x40(%rsp), %rax
cmpq $0x0, %rax
je 0xebe1f
leaq 0x68(%rsp), %rdi
callq 0xebe80
movb %al, 0x27(%rsp)
jmp 0xebd5d
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0xebd67
jmp 0xebdc4
leaq 0x68(%rsp), %rdi
callq 0xebe70
movq %rax, 0x18(%rsp)
jmp 0xebd78
movq 0x18(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0xf9fb0
jmp 0xebd89
movq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xed180
jmp 0xebd9a
movl $0x1, 0x4c(%rsp)
jmp 0xebe45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xec9f0
jmp 0xebe5c
leaq 0x68(%rsp), %rdi
callq 0xebe70
movq %rax, 0x10(%rsp)
jmp 0xebdd5
leaq 0x68(%rsp), %rdi
callq 0xebe70
movq %rax, 0x8(%rsp)
jmp 0xebde6
leaq 0x68(%rsp), %rdi
callq 0xebea0
movl %eax, 0x4(%rsp)
jmp 0xebdf6
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %eax
movl %eax, %eax
addq %rax, %rdx
callq 0xed0c0
jmp 0xebe15
movl $0x1, 0x4c(%rsp)
jmp 0xebe45
leaq 0x68(%rsp), %rdi
callq 0xebec0
movl %eax, (%rsp)
jmp 0xebe2e
movl (%rsp), %esi
movq 0x28(%rsp), %rdi
callq 0xecda0
jmp 0xebe3d
movl $0x1, 0x4c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xec9f0
movq 0x30(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::ValueIteratorBase::index() const
UInt ValueIteratorBase::index() const {
  const Value::CZString czstring = (*current_).first;
  if (!czstring.data())
    return czstring.index();
  return Value::UInt(-1);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0xf9f90
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xec8c0
movq 0x8(%rsp), %rdi
callq 0xebe70
movq %rax, 0x10(%rsp)
jmp 0xebf06
movq 0x10(%rsp), %rax
cmpq $0x0, %rax
jne 0xebf4d
leaq 0x28(%rsp), %rdi
callq 0xebec0
movl %eax, 0x4(%rsp)
jmp 0xebf21
movl 0x4(%rsp), %eax
movl %eax, 0x44(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0xebf5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xec9f0
jmp 0xebf70
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
movl $0x1, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xec9f0
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x12c20
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::ValueIteratorBase::name[abi:cxx11]() const
std::string ValueIteratorBase::name() const {
  char const* keey;
  char const* end;
  keey = memberName(&end);
  if (!keey) return std::string();
  return std::string(keey, end);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xec040
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0xebfc3
movq 0x20(%rsp), %rdi
callq 0x129f0
jmp 0xec027
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x12c30
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0xf9320
jmp 0xec001
leaq 0x47(%rsp), %rdi
callq 0x12760
jmp 0xec027
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x47(%rsp), %rdi
callq 0x12760
jmp 0xec031
movq 0x28(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x12c20
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::ValueIteratorBase::memberName(char const**) const
char const* ValueIteratorBase::memberName(char const** end) const {
  const char* cname = (*current_).first.data();
  if (!cname) {
    *end = NULL;
    return NULL;
  }
  *end = cname + (*current_).first.length();
  return cname;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xf9f90
movq %rax, %rdi
callq 0xebe70
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xec089
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0xec0c1
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xf9f90
movq %rax, %rdi
callq 0xebea0
movq 0x8(%rsp), %rcx
movl %eax, %eax
addq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::CommentInfo::setComment(char const*, unsigned long)
void Value::CommentInfo::setComment(const char* text, size_t len) {
  if (comment_) {
    releaseStringValue(comment_);
    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:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq %rdx, 0x1f0(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, (%rax)
je 0xec5ab
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0xec550
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
cmpq $0x0, 0x1f8(%rsp)
jne 0xec65b
leaq 0x1cf(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x12c30
movq 0x10(%rsp), %rdx
leaq 0x7e09c(%rip), %rsi     # 0x16a674
leaq 0x1d0(%rsp), %rdi
callq 0x22830
jmp 0xec5e7
leaq 0x1d0(%rsp), %rdi
callq 0xec480
jmp 0xec5f6
leaq 0x1d0(%rsp), %rdi
callq 0x12430
leaq 0x1cf(%rsp), %rdi
callq 0x12760
jmp 0xec65b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1c0(%rsp)
movl %eax, 0x1bc(%rsp)
jmp 0xec649
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1c0(%rsp)
movl %eax, 0x1bc(%rsp)
leaq 0x1d0(%rsp), %rdi
callq 0x12430
leaq 0x1cf(%rsp), %rdi
callq 0x12760
jmp 0xec739
movq 0x1f8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xec711
movq 0x1f8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0xec711
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x12980
movq 0x8(%rsp), %rdi
leaq 0x7dfe9(%rip), %rsi     # 0x16a687
callq 0x126b0
jmp 0xec6a5
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x12700
jmp 0xec6b6
leaq 0x20(%rsp), %rdi
callq 0xec480
jmp 0xec6c2
leaq 0x20(%rsp), %rdi
callq 0x12430
callq 0x12380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1c0(%rsp)
movl %eax, 0x1bc(%rsp)
jmp 0xec705
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1c0(%rsp)
movl %eax, 0x1bc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x12430
leaq 0x40(%rsp), %rdi
callq 0x121a0
jmp 0xec739
movq 0x1f8(%rsp), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xec750
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
addq $0x208, %rsp            # imm = 0x208
retq
movq 0x1c0(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.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 >= (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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
cmpq $0x7fffffff, 0x48(%rsp) # imm = 0x7FFFFFFF
jb 0xec772
movq $0x7ffffffe, 0x48(%rsp) # imm = 0x7FFFFFFE
movq 0x48(%rsp), %rdi
addq $0x1, %rdi
callq 0x12960
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0xec808
leaq 0x1f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x12c30
movq (%rsp), %rdx
leaq 0x7e502(%rip), %rsi     # 0x16aca8
leaq 0x20(%rsp), %rdi
callq 0x22830
jmp 0xec7b2
leaq 0x20(%rsp), %rdi
callq 0xe0b60
jmp 0xec7be
leaq 0x20(%rsp), %rdi
callq 0x12430
leaq 0x1f(%rsp), %rdi
callq 0x12760
jmp 0xec808
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0xec7fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x12430
leaq 0x1f(%rsp), %rdi
callq 0x12760
jmp 0xec834
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x12590
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x40(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x12c20
nop
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.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_));
  storage_.length_ = other.storage_.length_;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xec916
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0xec916
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
shrl $0x2, %eax
movl %eax, %eax
movl %eax, %esi
callq 0xec750
movq %rax, 0x8(%rsp)
jmp 0xec923
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0xec959
movq 0x18(%rsp), %rax
movl 0x8(%rax), %edx
andl $0x3, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, 0x4(%rsp)
jmp 0xec968
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x3, %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %edx
movl 0x8(%rax), %ecx
andl $0x3, %edx
andl $-0x4, %ecx
orl %edx, %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %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 $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.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(this_len, other_len);
  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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
jne 0xecaec
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0xecb6e
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
shrl $0x2, %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
shrl $0x2, %eax
movl %eax, 0x18(%rsp)
leaq 0x1c(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xfa080
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl (%rcx), %ecx
movl %ecx, 0x14(%rsp)
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movl 0x14(%rsp), %eax
movl %eax, %edx
callq 0x122d0
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jge 0xecb4f
movb $0x1, 0x37(%rsp)
jmp 0xecb6e
cmpl $0x0, 0x10(%rsp)
jle 0xecb5d
movb $0x0, 0x37(%rsp)
jmp 0xecb6e
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
setb %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.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;
  int comp = memcmp(this->cstr_, other.cstr_, this_len);
  return comp == 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
jne 0xecbb9
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0xecc15
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
shrl $0x2, %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
shrl $0x2, %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
je 0xecbe8
movb $0x0, 0x37(%rsp)
jmp 0xecc15
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movl 0x1c(%rsp), %eax
movl %eax, %edx
callq 0x122d0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
sete %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::Value(Json::ValueType)
Value::Value(ValueType vtype) {
  initBasic(vtype);
  switch (vtype) {
  case nullValue:
    value_.int_ = 0;
    break;
  case intValue:
  case uintValue:
    value_.int_ = 0;
    break;
  case realValue:
    value_.real_ = 0.0;
    break;
  case stringValue:
    value_.string_ = 0;
    break;
  case arrayValue:
  case objectValue:
    value_.map_ = new ObjectValues();
    break;
  case booleanValue:
    value_.bool_ = false;
    break;
  default:
    JSON_ASSERT_UNREACHABLE;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x1c(%rsp), %esi
xorl %edx, %edx
callq 0xeccf0
movl 0x1c(%rsp), %eax
movq %rax, 0x10(%rsp)
subq $0x7, %rax
ja 0xecce0
movq 0x10(%rsp), %rax
leaq 0x7d2f3(%rip), %rcx     # 0x169f54
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
jmp 0xecce2
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
jmp 0xecce2
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0xecce2
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
jmp 0xecce2
movl $0x30, %edi
callq 0x126d0
movq %rax, %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x12370
movq (%rsp), %rdi
callq 0xfa0c0
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0xecce2
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
jmp 0xecce2
jmp 0xecce2
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::initBasic(Json::ValueType, bool)
void Value::initBasic(ValueType vtype, bool allocated) {
  type_ = vtype;
  allocated_ = allocated;
  comments_ = 0;
  start_ = 0;
  limit_ = 0;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
andb $0x1, %al
movb %al, -0xd(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %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(%rsp), %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)
retq
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.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 <= (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:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x200(%rsp)
movl %esi, 0x1fc(%rsp)
movl 0x1fc(%rsp), %eax
cmpq $0x7ffffffa, %rax       # imm = 0x7FFFFFFA
jbe 0xecfb7
leaq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x12980
movq 0x10(%rsp), %rdi
leaq 0x7ddb0(%rip), %rsi     # 0x16acf7
callq 0x126b0
jmp 0xecf4e
leaq 0x50(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x12700
jmp 0xecf62
leaq 0x50(%rsp), %rdi
callq 0xec480
jmp 0xecf6e
leaq 0x50(%rsp), %rdi
callq 0x12430
callq 0x12380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xecfa5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x12430
leaq 0x80(%rsp), %rdi
callq 0x121a0
jmp 0xed0a9
movl 0x1fc(%rsp), %eax
addl $0x4, %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, %edi
callq 0x12960
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0xed05d
leaq 0x1f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x12c30
movq 0x8(%rsp), %rdx
leaq 0x7dd4a(%rip), %rsi     # 0x16ad45
leaq 0x20(%rsp), %rdi
callq 0x22830
jmp 0xed007
leaq 0x20(%rsp), %rdi
callq 0xe0b60
jmp 0xed013
leaq 0x20(%rsp), %rdi
callq 0x12430
leaq 0x1f(%rsp), %rdi
callq 0x12760
jmp 0xed05d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xed051
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x12430
leaq 0x1f(%rsp), %rdi
callq 0x12760
jmp 0xed0a9
movl 0x1fc(%rsp), %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
movq 0x40(%rsp), %rdi
addq $0x4, %rdi
movq 0x200(%rsp), %rsi
movl 0x1fc(%rsp), %eax
movl %eax, %edx
callq 0x12590
movq 0x40(%rsp), %rax
movl 0x4c(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq 0x40(%rsp), %rax
addq $0x208, %rsp            # imm = 0x208
retq
movq 0x78(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.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:
subq $0x28, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
testb $0x1, 0x27(%rsp)
jne 0xed5a5
movq 0x18(%rsp), %rdi
callq 0x122b0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0xed5c4
movq 0x18(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rcx
addq $0x4, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::swap(Json::Value&)
void Value::swap(Value& other) {
  swapPayload(other);
  std::swap(comments_, other.comments_);
  std::swap(start_, other.start_);
  std::swap(limit_, other.limit_);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0xe1a10
movq (%rsp), %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
callq 0xfa160
movq (%rsp), %rdi
addq $0x18, %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
callq 0xfa1a0
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
callq 0xfa1a0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::~Value()
Value::~Value() {
  switch (type_) {
  case nullValue:
  case intValue:
  case uintValue:
  case realValue:
  case booleanValue:
    break;
  case stringValue:
    if (allocated_)
      releaseStringValue(value_.string_);
    break;
  case arrayValue:
  case objectValue:
    delete value_.map_;
    break;
  default:
    JSON_ASSERT_UNREACHABLE;
  }

  if (comments_)
    delete[] comments_;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movzbl 0x8(%rax), %eax
movzwl %ax, %ecx
movl %ecx, 0x3c(%rsp)
subw $0x4, %ax
jb 0xed6ca
jmp 0xed6a6
movl 0x3c(%rsp), %eax
subl $0x4, %eax
je 0xed6cc
jmp 0xed6b1
movl 0x3c(%rsp), %eax
subl $0x5, %eax
je 0xed6ca
jmp 0xed6bc
movl 0x3c(%rsp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0xed6f8
jmp 0xed726
jmp 0xed728
movq 0x30(%rsp), %rax
movw 0x8(%rax), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xed6f6
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0xec550
jmp 0xed6f4
jmp 0xed6f6
jmp 0xed728
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0xed724
movq 0x28(%rsp), %rdi
callq 0xfa110
movq 0x28(%rsp), %rdi
movl $0x30, %esi
callq 0x126e0
jmp 0xed728
jmp 0xed728
movq 0x30(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xed7b8
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0xed7b6
movq 0x20(%rsp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x8(%rsp)
movq -0x8(%rcx), %rdx
movq %rdx, 0x10(%rsp)
shlq $0x3, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, 0x18(%rsp)
je 0xed79f
movq 0x18(%rsp), %rdi
addq $-0x8, %rdi
movq %rdi, (%rsp)
callq 0xec510
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0xed77a
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
shlq $0x3, %rsi
addq $0x8, %rsi
callq 0x12d80
jmp 0xed7b8
addq $0x48, %rsp
retq
movq %rax, %rdi
callq 0x22300
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::compare(Json::Value const&) const
int Value::compare(const Value& other) const {
  if (*this < other)
    return -1;
  if (*this > other)
    return 1;
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
callq 0xed860
testb $0x1, %al
jne 0xed818
jmp 0xed822
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xed849
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xedaf0
testb $0x1, %al
jne 0xed837
jmp 0xed841
movl $0x1, 0x24(%rsp)
jmp 0xed849
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.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:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x1c8(%rsp)
movq 0x1c8(%rsp), %rax
movq %rax, 0x8(%rsp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x4, %eax
je 0xedeb0
leaq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x12980
movq (%rsp), %rdi
leaq 0x7c877(%rip), %rsi     # 0x16a6c0
callq 0x126b0
jmp 0xede50
leaq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x12700
jmp 0xede61
leaq 0x20(%rsp), %rdi
callq 0xec480
jmp 0xede6d
leaq 0x20(%rsp), %rdi
callq 0x12430
callq 0x12380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xedea4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x12430
leaq 0x50(%rsp), %rdi
callq 0x121a0
jmp 0xedf18
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xedec9
movq $0x0, 0x1d0(%rsp)
jmp 0xedf08
movq 0x8(%rsp), %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 0x1c(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0xed560
movq 0x10(%rsp), %rax
movq %rax, 0x1d0(%rsp)
movq 0x1d0(%rsp), %rax
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x48(%rsp), %rdi
callq 0x12c20
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::getString(char const**, char const**) const
bool Value::getString(char const** str, char const** cend) const {
  if (type_ != stringValue) return false;
  if (value_.string_ == 0) return false;
  unsigned length;
  decodePrefixedString(this->allocated_, this->value_.string_, &length, str);
  *cend = *str + length;
  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x4, %eax
je 0xedf64
movb $0x0, 0x37(%rsp)
jmp 0xedfc4
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xedf76
movb $0x0, 0x37(%rsp)
jmp 0xedfc4
movq 0x8(%rsp), %rcx
movw 0x8(%rcx), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
setne %al
movq (%rcx), %rsi
movq 0x20(%rsp), %rcx
movzbl %al, %edi
andl $0x1, %edi
leaq 0x14(%rsp), %rdx
callq 0xed560
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movl 0x14(%rsp), %eax
addq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::valueToString[abi:cxx11](long long)
std::string valueToString(LargestInt value) {
  UIntToStringBuffer buffer;
  char* current = buffer + sizeof(buffer);
  if (value == Value::minLargestInt) {
    uintToString(LargestUInt(Value::maxLargestInt) + 1, current);
    *--current = '-';
  } else if (value < 0) {
    uintToString(LargestUInt(-value), current);
    *--current = '-';
  } else {
    uintToString(LargestUInt(value), current);
  }
  assert(current >= buffer);
  return current;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x40(%rsp), %rax
addq $0x19, %rax
movq %rax, 0x38(%rsp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, 0x68(%rsp)
jne 0xee035
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
leaq 0x38(%rsp), %rsi
callq 0xf29c0
movq 0x38(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x38(%rsp)
movb $0x2d, -0x1(%rax)
jmp 0xee078
cmpq $0x0, 0x68(%rsp)
jge 0xee067
xorl %eax, %eax
movl %eax, %edi
subq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xf29c0
movq 0x38(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x38(%rsp)
movb $0x2d, -0x1(%rax)
jmp 0xee076
movq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xf29c0
jmp 0xee078
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x12c30
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x22830
jmp 0xee0a5
leaq 0x37(%rsp), %rdi
callq 0x12760
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x12760
movq 0x28(%rsp), %rdi
callq 0x12c20
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::valueToString[abi:cxx11](unsigned long long)
std::string valueToString(LargestUInt value) {
  UIntToStringBuffer buffer;
  char* current = buffer + sizeof(buffer);
  uintToString(value, current);
  assert(current >= buffer);
  return current;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x59(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xf29c0
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x12c30
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x22830
jmp 0xee142
leaq 0x37(%rsp), %rdi
callq 0x12760
movq (%rsp), %rax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x12760
movq 0x28(%rsp), %rdi
callq 0x12c20
nopw (%rax,%rax)