LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqu %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x60(%rsi), %r13
cmpq 0x80(%rsi), %r13
je 0x7dd73
movq %rsi, %r14
movq 0x70(%rsi), %r12
movq 0x78(%rsi), %r15
leaq 0x20(%rsp), %rbp
movq %rbp, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movdqu 0x8(%r13), %xmm0
movq 0xc0(%r14), %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
psubq %xmm1, %xmm0
movdqa %xmm0, (%rsp)
leaq 0x18(%r13), %rsi
leaq 0x10(%rsp), %rdi
callq 0x11300
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x87ab0
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7dd4e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x115c0
addq $0x40, %r13
cmpq %r12, %r13
jne 0x7dd66
movq 0x8(%r15), %r13
addq $0x8, %r15
leaq 0x200(%r13), %r12
cmpq 0x80(%r14), %r13
jne 0x7dcee
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7dd9f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x87af4
movq %r14, %rdi
callq 0x11a60
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
cmpq $0x5, %rax
ja 0x7e905
leaq 0x4046b(%rip), %rcx     # 0xbed3c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, (%rdi)
setne %al
jmp 0x7e8fc
movb (%rdi), %al
jmp 0x7e8fc
xorpd %xmm0, %xmm0
cmpneqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x7e8fc
xorl %eax, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x40e3f(%rip), %rsi     # 0xbf758
movl $0x21, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7e964
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x7e964
jmp 0x7e961
movq %rax, %rbx
movq 0x85635(%rip), %rsi     # 0x103fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::asInt() const
Value::Int Value::asInt() const {
  switch (type_) {
  case intValue:
    JSON_ASSERT_MESSAGE(isInt(), "LargestInt out of Int range");
    return Int(value_.int_);
  case uintValue:
    JSON_ASSERT_MESSAGE(isInt(), "LargestUInt out of Int range");
    return Int(value_.uint_);
  case realValue:
    JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt, maxInt),
                        "double out of Int range");
    return Int(value_.real_);
  case nullValue:
    return 0;
  case booleanValue:
    return value_.bool_ ? 1 : 0;
  default:
    break;
  }
  JSON_FAIL_MESSAGE("Value is not convertible to Int.");
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
cmpq $0x5, %rax
ja 0x7eaab
movq %rdi, %rbx
leaq 0x403aa(%rip), %rcx     # 0xbed54
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rbx, %rdi
callq 0x80cdc
testb %al, %al
jne 0x7ea0a
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x40b9c(%rip), %rsi     # 0xbf56f
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
movzbl (%rbx), %eax
jmp 0x7ea2e
movq %rbx, %rdi
callq 0x80cdc
testb %al, %al
je 0x7ea37
movl (%rbx), %eax
jmp 0x7ea2e
movsd (%rbx), %xmm0
ucomisd 0x40676(%rip), %xmm0    # 0xbf090
jb 0x7ea71
movsd 0x40674(%rip), %xmm1    # 0xbf098
ucomisd %xmm0, %xmm1
jb 0x7ea71
cvttsd2si %xmm0, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x40b40(%rip), %rsi     # 0xbf58b
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x40b23(%rip), %rsi     # 0xbf5a8
movl $0x17, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x40b01(%rip), %rsi     # 0xbf5c0
movl $0x20, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
jmp 0x7eaef
jmp 0x7eb19
jmp 0x7eaef
jmp 0x7eb19
jmp 0x7eaef
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7eb1c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x7eb1c
jmp 0x7eb19
jmp 0x7eb19
jmp 0x7eb19
jmp 0x7eb19
jmp 0x7eb19
movq %rax, %rbx
movq 0x8547d(%rip), %rsi     # 0x103fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::getMemberNames[abi:cxx11]() const
Value::Members Value::getMemberNames() const {
  JSON_ASSERT_MESSAGE(
      type_ == nullValue || type_ == objectValue,
      "in Json::Value::getMemberNames(), value must be objectValue");
  if (type_ == nullValue)
    return Value::Members();
  Members members;
  members.reserve(value_.map_->size());
  ObjectValues::const_iterator it = value_.map_->begin();
  ObjectValues::const_iterator itEnd = value_.map_->end();
  for (; it != itEnd; ++it) {
    members.push_back(std::string((*it).first.data(),
                                  (*it).first.length()));
  }
  return members;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movzbl 0x8(%rsi), %eax
testl %eax, %eax
je 0x7f176
cmpl $0x7, %eax
jne 0x7f198
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%rsi), %rax
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x87cb2
movq (%r14), %r12
movq 0x18(%r12), %r14
addq $0x8, %r12
cmpq %r12, %r14
je 0x7f184
leaq 0x38(%rsp), %r13
leaq 0x28(%rsp), %r15
movq 0x20(%r14), %rsi
movl 0x28(%r14), %edx
shrl $0x2, %edx
movq %r13, 0x28(%rsp)
addq %rsi, %rdx
movq %r15, %rdi
callq 0x1a88c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8a6ee
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x7f164
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %r14, %rdi
callq 0x116d0
movq %rax, %r14
cmpq %r12, %rax
jne 0x7f127
jmp 0x7f184
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x40827(%rip), %rsi     # 0xbf9d3
movl $0x3b, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f1f7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x7f1f7
jmp 0x7f1f4
movq %rax, %r14
movq 0x84da2(%rip), %rsi     # 0x103fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
jmp 0x7f240
jmp 0x7f219
movq %rax, %r14
jmp 0x7f238
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x7f238
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x87b52
movq %r14, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x117f0
movq (%r12), %rax
movq -0x18(%rax), %rax
movq 0xe8(%r12,%rax), %rsi
movq %r13, %rdi
callq 0x11120
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
movq 0x8(%rsp), %r12
movq 0x10(%rsp), %r13
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %rax, %r15
addq %r12, %r13
movq (%rax), %rax
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq *0x10(%rax)
movl %eax, %ebx
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f8e6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
movq 0x846b3(%rip), %rsi     # 0x103fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movl %ebx, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
jmp 0x7f928
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f94a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x7f94a
jmp 0x7f947
movq %rax, %rbx
movq 0x8464f(%rip), %rsi     # 0x103fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x7df9a
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7f842
testb %al, %al
je 0x7f9f8
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7f9d4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
leaq 0x83b25(%rip), %rax     # 0x103500
leaq 0x30(%rsp), %rdi
movq %rax, -0x8(%rdi)
callq 0x80736
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x845b9(%rip), %rax     # 0x103fb8
movq (%rax), %rdi
leaq 0x8(%rsp), %rbx
movq (%rbx), %rdx
leaq 0x3fa6a(%rip), %rsi     # 0xbf47b
xorl %eax, %eax
callq 0x11880
movq %rbx, %rdi
callq 0x789e4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7fa3a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
leaq 0x83abf(%rip), %rax     # 0x103500
leaq 0x30(%rsp), %rdi
movq %rax, -0x8(%rdi)
callq 0x80736
movq %rbx, %rdi
callq 0x11a60
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %rsi
addq $0x20, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x80032
movq (%r15), %r14
movl 0x8(%r15), %esi
testq %r14, %r14
je 0x7fb71
movl %esi, %ebp
andl $0x3, %ebp
je 0x7fb94
shrl $0x2, %esi
movl $0xfffffe00, %eax       # imm = 0xFFFFFE00
andl 0x8(%rbx), %eax
orl $0x104, %eax            # imm = 0x104
movw %ax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movq %r14, %rdi
callq 0x8038f
movq %rax, (%rbx)
cmpl $0x1, %ebp
jne 0x7fbb5
movq %r14, %rdi
callq 0x11710
jmp 0x7fbb5
movl $0xfffffe00, %eax       # imm = 0xFFFFFE00
andl 0x8(%rbx), %eax
orl $0x2, %eax
movw %ax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movq %rsi, (%rbx)
jmp 0x7fbb5
movl $0xfffffe00, %eax       # imm = 0xFFFFFE00
andl 0x8(%rbx), %eax
orl $0x4, %eax
movw %ax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %ebp
jne 0x7fbd3
movq %r14, %rdi
callq 0x11710
movq %rbx, %rdi
callq 0x11a60
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x7fc5c
movl 0x28(%rax), %edx
shrl $0x2, %edx
addq %rsi, %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x1a88c
jmp 0x7fc6f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x7fec3
callq 0x11710
movq $0x0, (%rbx)
testq %r14, %r14
je 0x7ff1d
movzbl (%r14), %eax
testl %eax, %eax
je 0x7fed9
cmpl $0x2f, %eax
jne 0x7ff74
movl $0x7ffffffe, %r12d      # imm = 0x7FFFFFFE
cmpq %r12, %r15
cmovbq %r15, %r12
leaq 0x1(%r12), %rdi
callq 0x117d0
testq %rax, %rax
je 0x7ff48
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x114b0
movb $0x0, (%r15,%r12)
movq %r15, (%rbx)
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3f597(%rip), %rsi     # 0xbf4c4
leaq 0x3f5a2(%rip), %rdx     # 0xbf4d6
leaq 0x20(%rsp), %rdi
callq 0x1a88c
leaq 0x20(%rsp), %rdi
callq 0x7fe09
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3fb9d(%rip), %rsi     # 0xbfaf5
leaq 0x3fbe4(%rip), %rdx     # 0xbfb43
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x1a88c
movq %rbx, %rdi
callq 0x789e4
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x3f54f(%rip), %rsi     # 0xbf4d7
movl $0x38, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x11980
movq %rsp, %rdi
callq 0x7fe09
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7ffcf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x7ffcf
jmp 0x7ffcc
movq %rax, %rbx
movq 0x83fca(%rip), %rsi     # 0x103fa0
leaq 0x20(%rsp), %rdi
callq 0x112f0
leaq 0x90(%rsp), %rdi
callq 0x111f0
jmp 0x80010
jmp 0x7fff6
movq %rax, %rbx
jmp 0x80010
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x80010
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %r12d
movq (%rsi), %r15
testb $0x3, %r12b
je 0x80089
testq %r15, %r15
je 0x80086
shrl $0x2, %r12d
leaq 0x1(%r12), %rdi
callq 0x117d0
testq %rax, %rax
je 0x800c4
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x114b0
movb $0x0, (%r13,%r12)
movq %r13, %r15
jmp 0x80089
xorl %r15d, %r15d
movq %r15, (%rbx)
movl 0x8(%r14), %eax
xorl %ecx, %ecx
andl $0x3, %eax
setne %cl
cmpq $0x0, (%r14)
cmovel %eax, %ecx
movl 0x8(%rbx), %eax
andl $-0x4, %eax
orl %ecx, %eax
movl %eax, 0x8(%rbx)
movl 0x8(%r14), %eax
andl $-0x4, %eax
orl %ecx, %eax
movl %eax, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3fa21(%rip), %rsi     # 0xbfaf5
leaq 0x3fa68(%rip), %rdx     # 0xbfb43
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1a88c
movq %rbx, %rdi
callq 0x789e4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x80107
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x11a60
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rax
movq (%rdi), %rdi
movl 0x8(%rax), %ebx
testq %rdi, %rdi
je 0x801b3
shrl $0x2, %ebx
movl 0x8(%rsi), %ebp
shrl $0x2, %ebp
cmpl %ebx, %ebp
movl %ebx, %edx
cmovbl %ebp, %edx
movq (%rsi), %rsi
callq 0x11270
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
js 0x801b9
sete %cl
cmpl %ebp, %ebx
setb %al
andb %cl, %al
jmp 0x801b9
cmpl 0x8(%rsi), %ebx
setb %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rdi, %rax
movq (%rdi), %rdi
movl 0x8(%rax), %edx
testq %rdi, %rdi
je 0x801ee
shrl $0x2, %edx
movl 0x8(%rsi), %eax
shrl $0x2, %eax
cmpl %eax, %edx
jne 0x801f5
pushq %rax
movq (%rsi), %rsi
callq 0x115e0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
cmpl 0x8(%rsi), %edx
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::Value(Json::ValueType)
void Value::initBasic(ValueType vtype, bool allocated) {
  type_ = vtype;
  allocated_ = allocated;
  comments_ = 0;
  start_ = 0;
  limit_ = 0;
}

// Assembly:
movzbl %sil, %eax
movl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
andl 0x8(%rdi), %ecx
orl %eax, %ecx
movw %cx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
cmpl $0x7, %esi
ja 0x8026e
pushq %rbx
movq %rdi, %rbx
movl %esi, %eax
leaq 0x3eb41(%rip), %rcx     # 0xbed6c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, (%rbx)
jmp 0x8026d
movl $0x30, %edi
callq 0x115b0
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, (%rbx)
jmp 0x8026d
movb $0x0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
cmpl $0x7ffffffb, %esi       # imm = 0x7FFFFFFB
jae 0x803ec
movl %esi, %r14d
movq %rdi, %rbx
leal 0x5(%r14), %edi
callq 0x117d0
testq %rax, %rax
je 0x80422
movq %rax, %r15
movl %r14d, %r12d
movl %r14d, (%rax)
movq %rax, %rdi
addq $0x4, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x114b0
movb $0x0, 0x4(%r15,%r12)
movq %r15, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x3f744(%rip), %rsi     # 0xbfb44
movl $0x4d, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x11980
movq %rsp, %rdi
callq 0x7fe09
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3f760(%rip), %rsi     # 0xbfb92
leaq 0x3f7b0(%rip), %rdx     # 0xbfbe9
leaq 0x20(%rsp), %rdi
callq 0x1a88c
leaq 0x20(%rsp), %rdi
callq 0x789e4
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x80493
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x80493
jmp 0x80490
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x804b1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x804b1
movq %rax, %rbx
jmp 0x804b1
movq %rax, %rbx
movq 0x83b06(%rip), %rsi     # 0x103fa0
leaq 0x20(%rsp), %rdi
callq 0x112f0
leaq 0x90(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a60
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::Value(Json::Value const&)
Value::Value(Value const& other)
    : type_(other.type_), allocated_(false)
      ,
      comments_(0), start_(other.start_), limit_(other.limit_)
{
  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_;
      allocated_ = false;
    }
    break;
  case arrayValue:
  case objectValue:
    value_.map_ = new ObjectValues(*other.value_.map_);
    break;
  default:
    JSON_ASSERT_UNREACHABLE;
  }
  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_));
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x8(%rsi), %eax
movzbl %al, %ecx
movl $0xfffffe00, %eax       # imm = 0xFFFFFE00
andl 0x8(%rdi), %eax
orl %ecx, %eax
movw %ax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x18(%rdi)
cmpb $0x7, %cl
ja 0x80609
movl $0x2f, %edx
btl %ecx, %edx
jae 0x805b7
movq (%rbx), %rax
movq %rax, (%r14)
jmp 0x80609
movl $0xc0, %edx
btl %ecx, %edx
jae 0x805de
movl $0x30, %edi
callq 0x115b0
movq %rax, %r15
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x88856
movq %r15, (%r14)
jmp 0x80609
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x805ec
testb $0x1, 0x9(%rbx)
jne 0x805f6
movq %rdi, (%r14)
movw %ax, 0x8(%r14)
jmp 0x80609
movl (%rdi), %esi
addq $0x4, %rdi
callq 0x8038f
movq %rax, (%r14)
orb $0x1, 0x9(%r14)
cmpq $0x0, 0x10(%rbx)
je 0x8066f
movl $0x20, %edi
callq 0x11040
movq $0x3, (%rax)
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movq %rcx, 0x10(%r14)
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
movq (%rax,%r13), %r15
testq %r15, %r15
je 0x80665
movq 0x10(%r14), %r12
addq %r13, %r12
movq %r15, %rdi
callq 0x11260
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7fe98
addq $0x8, %r13
cmpq $0x18, %r13
jne 0x8063b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x30, %esi
movq %r15, %rdi
callq 0x115c0
movq %rbx, %rdi
callq 0x11a60
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x79370
movq 0x10(%r14), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%r14)
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rax
movq 0x18(%rbx), %rcx
movq %rcx, 0x18(%r14)
movq %rax, 0x18(%rbx)
movq 0x20(%r14), %rax
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%r14)
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
movzbl %al, %ecx
leal -0x6(%rcx), %edx
cmpl $0x2, %edx
jae 0x8076c
movq (%rbx), %r14
testq %r14, %r14
je 0x8075d
movq %r14, %rdi
callq 0x88b14
movl $0x30, %esi
movq %r14, %rdi
callq 0x115c0
jmp 0x8077f
cmpl $0x4, %ecx
jne 0x8077f
btl $0x8, %eax
jae 0x8077f
movq (%rbx), %rdi
callq 0x11710
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x807c6
movq -0x8(%rbx), %r14
addq $-0x8, %rbx
testq %r14, %r14
je 0x807b1
leaq (,%r14,8), %r15
movq (%rbx,%r15), %rdi
testq %rdi, %rdi
je 0x807ab
callq 0x11710
addq $-0x8, %r15
jne 0x8079d
leaq 0x8(,%r14,8), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x11b90
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::operator<(Json::Value const&) const
bool Value::operator<(const Value& other) const {
  int typeDelta = type_ - other.type_;
  if (typeDelta)
    return typeDelta < 0 ? true : false;
  switch (type_) {
  case nullValue:
    return false;
  case intValue:
    return value_.int_ < other.value_.int_;
  case uintValue:
    return value_.uint_ < other.value_.uint_;
  case realValue:
    return value_.real_ < other.value_.real_;
  case booleanValue:
    return value_.bool_ < other.value_.bool_;
  case stringValue:
  {
    if ((value_.string_ == 0) || (other.value_.string_ == 0)) {
      if (other.value_.string_) return true;
      else return false;
    }
    unsigned this_len;
    unsigned other_len;
    char const* this_str;
    char const* other_str;
    decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
    decodePrefixedString(other.allocated_, other.value_.string_, &other_len, &other_str);
    unsigned min_len = std::min(this_len, other_len);
    int comp = memcmp(this_str, other_str, min_len);
    if (comp < 0) return true;
    if (comp > 0) return false;
    return (this_len < other_len);
  }
  case arrayValue:
  case objectValue: {
    int delta = int(value_.map_->size() - other.value_.map_->size());
    if (delta)
      return delta < 0;
    return (*value_.map_) < (*other.value_.map_);
  }
  default:
    JSON_ASSERT_UNREACHABLE;
  }
  return false; // unreachable
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movzwl 0x8(%rdi), %eax
movl $0xff, %ecx
movl %eax, %edx
andl %ecx, %edx
movzwl 0x8(%rsi), %ebp
andl %ebp, %ecx
cmpw %cx, %dx
jne 0x80899
movzbl %al, %ecx
decl %ecx
cmpl $0x6, %ecx
ja 0x80856
leaq 0x3e559(%rip), %rdx     # 0xbed8c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rdi), %r8
movl 0x28(%r8), %eax
movq (%rsi), %rcx
subl 0x28(%rcx), %eax
je 0x808a5
shrl $0x1f, %eax
jmp 0x8089c
movb (%rdi), %al
cmpb (%rsi), %al
jmp 0x80899
xorl %eax, %eax
jmp 0x8089c
movsd (%rsi), %xmm0
ucomisd (%rdi), %xmm0
seta %al
jmp 0x8089c
movq (%rdi), %rbx
testq %rbx, %rbx
sete %cl
movq (%rsi), %r14
testq %r14, %r14
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x808c5
testq %r14, %r14
setne %al
jmp 0x8089c
movq (%rdi), %rax
cmpq (%rsi), %rax
setl %al
jmp 0x8089c
movq (%rdi), %rax
cmpq (%rsi), %rax
setb %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r8), %rdi
addq $0x8, %r8
movq 0x18(%rcx), %rdx
addq $0x8, %rcx
movq %r8, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x89f6d
btl $0x8, %eax
jb 0x808d8
movq %rbx, %rdi
callq 0x11260
movq %rax, %r15
jmp 0x808df
movl (%rbx), %r15d
addq $0x4, %rbx
btl $0x8, %ebp
jb 0x808f2
movq %r14, %rdi
callq 0x11260
movq %rax, %r12
jmp 0x808f9
movl (%r14), %r12d
addq $0x4, %r14
cmpl %r15d, %r12d
movl %r15d, %edx
cmovbl %r12d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11270
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
js 0x8089c
sete %cl
cmpl %r12d, %r15d
setb %al
andb %cl, %al
jmp 0x8089c
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::operator==(Json::Value const&) const
bool Value::operator==(const Value& other) const {
  // if ( type_ != other.type_ )
  // GCC 2.95.3 says:
  // attempt to take address of bit-field structure member `Json::Value::type_'
  // Beats me, but a temp solves the problem.
  int temp = other.type_;
  if (type_ != temp)
    return false;
  switch (type_) {
  case nullValue:
    return true;
  case intValue:
    return value_.int_ == other.value_.int_;
  case uintValue:
    return value_.uint_ == other.value_.uint_;
  case realValue:
    return value_.real_ == other.value_.real_;
  case booleanValue:
    return value_.bool_ == other.value_.bool_;
  case stringValue:
  {
    if ((value_.string_ == 0) || (other.value_.string_ == 0)) {
      return (value_.string_ == other.value_.string_);
    }
    unsigned this_len;
    unsigned other_len;
    char const* this_str;
    char const* other_str;
    decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str);
    decodePrefixedString(other.allocated_, other.value_.string_, &other_len, &other_str);
    if (this_len != other_len) return false;
    int comp = memcmp(this_str, other_str, this_len);
    return comp == 0;
  }
  case arrayValue:
  case objectValue:
    return value_.map_->size() == other.value_.map_->size() &&
           (*value_.map_) == (*other.value_.map_);
  default:
    JSON_ASSERT_UNREACHABLE;
  }
  return false; // unreachable
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movzwl 0x8(%rsi), %ebp
movzwl 0x8(%rdi), %eax
movl %eax, %ecx
xorb %bpl, %cl
je 0x80975
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x7, %al
ja 0x80968
movzwl %ax, %ecx
movzbl %cl, %ecx
leaq 0x3e422(%rip), %rdx     # 0xbeda8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0x80a50
movq (%rdi), %rax
movq 0x28(%rax), %rdx
movq (%rsi), %rcx
cmpq 0x28(%rcx), %rdx
jne 0x80968
movq 0x18(%rax), %rdi
addq $0x8, %rax
movq 0x18(%rcx), %rdx
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8a068
movq (%rdi), %rbx
testq %rbx, %rbx
sete %cl
movq (%rsi), %r14
testq %r14, %r14
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x80a06
cmpq %r14, %rbx
jmp 0x80a50
movb $0x1, %al
jmp 0x8096a
movsd (%rsi), %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x8096a
movb (%rdi), %al
cmpb (%rsi), %al
jmp 0x80a50
btl $0x8, %eax
jb 0x80a19
movq %rbx, %rdi
callq 0x11260
movq %rax, %r15
jmp 0x80a20
movl (%rbx), %r15d
addq $0x4, %rbx
btl $0x8, %ebp
jb 0x80a30
movq %r14, %rdi
callq 0x11260
jmp 0x80a37
movl (%r14), %eax
addq $0x4, %r14
cmpl %eax, %r15d
jne 0x80968
movl %r15d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x115e0
testl %eax, %eax
sete %al
jmp 0x8096a
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzwl 0x8(%rdi), %eax
cmpb $0x4, %al
jne 0x80a8e
movq (%rdi), %rcx
shrl $0x6, %eax
andl $0x4, %eax
addq %rcx, %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x3ea6e(%rip), %rsi     # 0xbf510
movl $0x31, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x80aed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x80aed
jmp 0x80aea
movq %rax, %rbx
movq 0x834ac(%rip), %rsi     # 0x103fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a60
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movzwl 0x8(%rdi), %eax
cmpb $0x4, %al
sete %cl
movq (%rdi), %r15
testq %r15, %r15
setne %bpl
andb %cl, %bpl
cmpb $0x1, %bpl
jne 0x80b5f
movq %rdx, %rbx
movq %rsi, %r14
btl $0x8, %eax
jb 0x80b4d
movq %r15, %rdi
callq 0x11260
jmp 0x80b54
movl (%r15), %eax
addq $0x4, %r15
movq %r15, (%r14)
movl %eax, %eax
addq %r15, %rax
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
negq %rdi
jno 0x80bc8
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
leaq 0x29(%rsp), %rsi
movb $0x0, -0x1(%rsi)
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rdi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r8d
subl %eax, %r8d
orb $0x30, %r8b
movb %r8b, -0x2(%rsi)
decq %rsi
cmpq $0xa, %rcx
movq %rdx, %rcx
jae 0x80b99
jmp 0x80c4b
movq %rsi, %rcx
testq %rsi, %rsi
js 0x80c0e
leaq 0x28(%rsp), %rsi
movb $0x0, (%rsi)
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rdi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r8d
subl %eax, %r8d
orb $0x30, %r8b
movb %r8b, -0x1(%rsi)
decq %rsi
cmpq $0xa, %rcx
movq %rdx, %rcx
jae 0x80be2
jmp 0x80c53
leaq 0x29(%rsp), %rsi
movb $0x0, -0x1(%rsi)
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %rax
mulq %rcx
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %edi, %r8d
subl %eax, %r8d
orb $0x30, %r8b
movb %r8b, -0x2(%rsi)
decq %rsi
cmpq $0xa, %rdi
movq %rdx, %rdi
jae 0x80c21
movb $0x2d, -0x2(%rsi)
addq $-0x2, %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x8768c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x28(%rsp), %rsi
movb $0x0, (%rsi)
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rdi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r8d
subl %eax, %r8d
orb $0x30, %r8b
movb %r8b, -0x1(%rsi)
decq %rsi
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x80c86
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x8768c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::isInt() const
bool Value::isInt() const {
  switch (type_) {
  case intValue:
    return value_.int_ >= minInt && value_.int_ <= maxInt;
  case uintValue:
    return value_.uint_ <= UInt(maxInt);
  case realValue:
    return value_.real_ >= minInt && value_.real_ <= maxInt &&
           IsIntegral(value_.real_);
  default:
    break;
  }
  return false;
}

// Assembly:
movzbl 0x8(%rdi), %eax
cmpl $0x3, %eax
je 0x80d05
cmpl $0x2, %eax
je 0x80cfa
cmpl $0x1, %eax
jne 0x80d42
movq (%rdi), %rax
movslq %eax, %rcx
cmpq %rax, %rcx
jmp 0x80d01
movq (%rdi), %rax
shrq $0x1f, %rax
sete %al
retq
movsd (%rdi), %xmm0
xorl %eax, %eax
ucomisd 0x3e37d(%rip), %xmm0    # 0xbf090
jb 0x80d04
movsd 0x3e37b(%rip), %xmm1    # 0xbf098
ucomisd %xmm0, %xmm1
jb 0x80d04
pushq %rax
movq %rsp, %rdi
callq 0x11a70
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::asUInt() const
Value::UInt Value::asUInt() const {
  switch (type_) {
  case intValue:
    JSON_ASSERT_MESSAGE(isUInt(), "LargestInt out of UInt range");
    return UInt(value_.int_);
  case uintValue:
    JSON_ASSERT_MESSAGE(isUInt(), "LargestUInt out of UInt range");
    return UInt(value_.uint_);
  case realValue:
    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt),
                        "double out of UInt range");
    return UInt(value_.real_);
  case nullValue:
    return 0;
  case booleanValue:
    return value_.bool_ ? 1 : 0;
  default:
    break;
  }
  JSON_FAIL_MESSAGE("Value is not convertible to UInt.");
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
cmpq $0x5, %rax
ja 0x80e68
movq %rdi, %rbx
leaq 0x3e062(%rip), %rcx     # 0xbedc8
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rbx, %rdi
callq 0x80f00
testb %al, %al
jne 0x80dc6
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x3e852(%rip), %rsi     # 0xbf5e1
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
movzbl (%rbx), %eax
jmp 0x80deb
movq %rbx, %rdi
callq 0x80f00
testb %al, %al
je 0x80df4
movl (%rbx), %eax
jmp 0x80deb
movsd (%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x80e2e
movsd 0x3e2c0(%rip), %xmm1    # 0xbf0a0
ucomisd %xmm0, %xmm1
jb 0x80e2e
cvttsd2si %xmm0, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x3e7f6(%rip), %rsi     # 0xbf5fe
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x3e7da(%rip), %rsi     # 0xbf61c
movl $0x18, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x3e7b9(%rip), %rsi     # 0xbf635
movl $0x21, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
jmp 0x80eac
jmp 0x80ed6
jmp 0x80eac
jmp 0x80ed6
jmp 0x80eac
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x80ed9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x80ed9
jmp 0x80ed6
jmp 0x80ed6
jmp 0x80ed6
jmp 0x80ed6
jmp 0x80ed6
movq %rax, %rbx
movq 0x830c0(%rip), %rsi     # 0x103fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a60
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::isUInt() const
bool Value::isUInt() const {
  switch (type_) {
  case intValue:
    return value_.int_ >= 0 && LargestUInt(value_.int_) <= LargestUInt(maxUInt);
  case uintValue:
    return value_.uint_ <= maxUInt;
  case realValue:
    return value_.real_ >= 0 && value_.real_ <= maxUInt &&
           IsIntegral(value_.real_);
  default:
    break;
  }
  return false;
}

// Assembly:
movzbl 0x8(%rdi), %eax
cmpl $0x3, %eax
je 0x80f1b
cmpl $0x2, %eax
je 0x80f13
cmpl $0x1, %eax
jne 0x80f58
cmpl $0x0, 0x4(%rdi)
sete %al
retq
movsd (%rdi), %xmm0
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x80f1a
movsd 0x3e16d(%rip), %xmm1    # 0xbf0a0
ucomisd %xmm0, %xmm1
jb 0x80f1a
pushq %rax
movq %rsp, %rdi
callq 0x11a70
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::asInt64() const
Value::Int64 Value::asInt64() const {
  switch (type_) {
  case intValue:
    return Int64(value_.int_);
  case uintValue:
    JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
    return Int64(value_.uint_);
  case realValue:
    JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxInt64),
                        "double out of Int64 range");
    return Int64(value_.real_);
  case nullValue:
    return 0;
  case booleanValue:
    return value_.bool_ ? 1 : 0;
  default:
    break;
  }
  JSON_FAIL_MESSAGE("Value is not convertible to Int64.");
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
cmpq $0x5, %rax
ja 0x8103b
movq %rdi, %rbx
leaq 0x3de64(%rip), %rcx     # 0xbede0
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rbx, %rdi
callq 0x810cc
testb %al, %al
je 0x80fc7
movq (%rbx), %rax
jmp 0x80fbe
movzbl (%rbx), %eax
jmp 0x80fbe
movsd (%rbx), %xmm0
movapd 0x3a5e9(%rip), %xmm1    # 0xbb590
andpd %xmm0, %xmm1
movsd 0x3d84d(%rip), %xmm2    # 0xbe800
ucomisd %xmm1, %xmm2
jb 0x81001
cvttsd2si %xmm0, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x3e67c(%rip), %rsi     # 0xbf657
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x3e661(%rip), %rsi     # 0xbf676
movl $0x19, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x117f0
leaq 0x3e641(%rip), %rsi     # 0xbf690
movl $0x22, %edx
movq %rbx, %rdi
callq 0x116c0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11980
leaq 0x8(%rsp), %rdi
callq 0x7fe09
jmp 0x8107d
jmp 0x810a3
jmp 0x8107d
jmp 0x810a3
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x810a6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x810a6
jmp 0x810a3
jmp 0x810a3
jmp 0x810a3
movq %rax, %rbx
movq 0x82ef3(%rip), %rsi     # 0x103fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a60
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::isInt64() const
bool Value::isInt64() const {
#if defined(JSON_HAS_INT64)
  switch (type_) {
  case intValue:
    return true;
  case uintValue:
    return value_.uint_ <= UInt64(maxInt64);
  case realValue:
    // Note that maxInt64 (= 2^63 - 1) is not exactly representable as a
    // double, so double(maxInt64) will be rounded up to 2^63. Therefore we
    // require the value to be strictly less than the limit.
    return value_.real_ >= double(minInt64) &&
           value_.real_ < double(maxInt64) && IsIntegral(value_.real_);
  default:
    break;
  }
#endif // JSON_HAS_INT64
  return false;
}

// Assembly:
movzbl 0x8(%rdi), %eax
cmpl $0x1, %eax
je 0x81124
cmpl $0x3, %eax
je 0x810e7
cmpl $0x2, %eax
jne 0x81127
cmpq $0x0, (%rdi)
setns %al
retq
movsd (%rdi), %xmm0
xorl %eax, %eax
ucomisd 0x3dfb3(%rip), %xmm0    # 0xbf0a8
jb 0x810e6
movsd 0x3d701(%rip), %xmm1    # 0xbe800
ucomisd %xmm0, %xmm1
jbe 0x810e6
pushq %rax
movq %rsp, %rdi
callq 0x11a70
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
addq $0x8, %rsp
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq