LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x73788
movq %rdi, %rbx
leaq 0x385ce(%rip), %rcx     # 0xabc64
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rbx, %rdi
callq 0x75152
testb %al, %al
jne 0x736f1
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x38dc0(%rip), %rsi     # 0xac47f
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
movzbl (%rbx), %eax
jmp 0x73715
movq %rbx, %rdi
callq 0x75152
testb %al, %al
je 0x7371e
movl (%rbx), %eax
jmp 0x73715
movsd (%rbx), %xmm0
ucomisd 0x3889f(%rip), %xmm0    # 0xabfa0
jb 0x73753
movsd 0x3889d(%rip), %xmm1    # 0xabfa8
ucomisd %xmm0, %xmm1
jb 0x73753
cvttsd2si %xmm0, %eax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x38d69(%rip), %rsi     # 0xac49b
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x38d51(%rip), %rsi     # 0xac4b8
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x38d34(%rip), %rsi     # 0xac4d0
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
jmp 0x737c7
jmp 0x737e0
jmp 0x737c7
jmp 0x737e0
jmp 0x737c7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
jmp 0x737e3
jmp 0x737e0
jmp 0x737e0
jmp 0x737e0
jmp 0x737e0
jmp 0x737e0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11180
movq %rbx, %rdi
callq 0x11a80
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x73c09
cmpl $0x7, %eax
jne 0x73c28
movq %rsi, %r14
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq (%rsi), %rax
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x7a1f0
movq (%r14), %r12
movq 0x18(%r12), %r14
addq $0x8, %r12
leaq 0x38(%rsp), %r13
leaq 0x28(%rsp), %r15
cmpq %r12, %r14
je 0x73c14
movq 0x20(%r14), %rsi
movl 0x28(%r14), %edx
shrl $0x2, %edx
movq %r13, 0x28(%rsp)
addq %rsi, %rdx
movq %r15, %rdi
callq 0x199fe
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7cd8e
movq %r15, %rdi
callq 0x11270
movq %r14, %rdi
callq 0x116c0
movq %rax, %r14
jmp 0x73bc9
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $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 0x11800
leaq 0x38ca7(%rip), %rsi     # 0xac8e3
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x11270
jmp 0x73c71
jmp 0x73c6e
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x11180
jmp 0x73c99
jmp 0x73c7f
movq %rax, %r14
jmp 0x73c91
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x11270
movq %rbx, %rdi
callq 0x7a0e6
movq %r14, %rdi
callq 0x11a80
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11800
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 0x119a0
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 0x8(%rsp), %rdi
callq 0x11270
leaq 0x28(%rsp), %rdi
callq 0x11180
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 0x74115
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
jmp 0x74126
jmp 0x74123
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11180
movq %rbx, %rdi
callq 0x11a80
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x72fdc
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x74054
testb %al, %al
je 0x74199
movq %rsp, %rdi
callq 0x11270
leaq 0x20(%rsp), %rdi
callq 0x733b8
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x82e20(%rip), %rax     # 0xf6fc0
movq (%rax), %rdi
movq %rsp, %rbx
movq (%rbx), %rdx
leaq 0x381db(%rip), %rsi     # 0xac38b
xorl %eax, %eax
callq 0x118a0
movq %rbx, %rdi
callq 0x6f0a2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x11270
leaq 0x20(%rsp), %rdi
callq 0x733b8
movq %rbx, %rdi
callq 0x11a80
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %rsi
addq $0x20, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x746f0
movq (%r14), %rsi
movl 0x8(%r14), %edx
testq %rsi, %rsi
je 0x742a5
testb $0x3, %dl
je 0x742c5
shrl $0x2, %edx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x74a90
jmp 0x742e3
movl $0xfffffe00, %eax       # imm = 0xFFFFFE00
andl 0x8(%rbx), %eax
orl $0x2, %eax
movw %ax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movq %rdx, (%rbx)
jmp 0x742e3
movl $0xfffffe00, %eax       # imm = 0xFFFFFE00
andl 0x8(%rbx), %eax
orl $0x4, %eax
movw %ax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movq %rsi, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0x74762
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x74762
movq %rbx, %rdi
callq 0x11a80
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7438c
movl 0x28(%rax), %edx
shrl $0x2, %edx
addq %rsi, %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x199fe
jmp 0x7439c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x7459e
callq 0x11710
andq $0x0, (%rbx)
testq %r15, %r15
je 0x745cb
movzbl (%r15), %eax
testl %eax, %eax
je 0x745b0
cmpl $0x2f, %eax
jne 0x745eb
movq %r15, %rdi
movq %r14, %rsi
callq 0x7465a
movq %rax, (%rbx)
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x37e02(%rip), %rsi     # 0xac3d4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x196d0
leaq 0x28(%rsp), %rdi
callq 0x74503
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x37de8(%rip), %rsi     # 0xac3e7
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
jmp 0x74634
jmp 0x74631
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11180
jmp 0x74652
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11270
jmp 0x74652
movq %rax, %rbx
movq %rbx, %rdi
callq 0x11a80
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movl $0x7ffffffe, %ebx       # imm = 0x7FFFFFFE
cmpq %rbx, %rsi
cmovbq %rsi, %rbx
leaq 0x1(%rbx), %rdi
callq 0x117e0
testq %rax, %rax
je 0x746a3
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x114b0
movb $0x0, (%r15,%rbx)
movq %r15, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3835b(%rip), %rsi     # 0xaca05
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x196d0
movq %rbx, %rdi
callq 0x6f0a2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x11270
movq %rbx, %rdi
callq 0x11a80
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
movq (%r14), %rax
testb $0x3, %sil
je 0x7471a
testq %rax, %rax
je 0x74718
shrl $0x2, %esi
movq %rax, %rdi
callq 0x7465a
jmp 0x7471a
xorl %eax, %eax
movq %rax, (%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 $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x747f1
shrl $0x2, %ebx
movl 0x8(%rsi), %ebp
shrl $0x2, %ebp
cmpl %ebx, %ebp
movl %ebx, %edx
cmovbl %ebp, %edx
movq (%rsi), %rsi
callq 0x11260
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
js 0x747f7
sete %cl
cmpl %ebp, %ebx
setb %al
andb %cl, %al
jmp 0x747f7
cmpl 0x8(%rsi), %ebx
setb %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7482c
shrl $0x2, %edx
movl 0x8(%rsi), %eax
shrl $0x2, %eax
cmpl %eax, %edx
jne 0x74833
pushq %rax
movq (%rsi), %rsi
callq 0x115f0
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_O2/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)
andq $0x0, 0x20(%rdi)
cmpl $0x7, %esi
ja 0x748a1
pushq %rbx
movq %rdi, %rbx
movl %esi, %eax
leaq 0x37416(%rip), %rcx     # 0xabc7c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
andq $0x0, (%rbx)
jmp 0x748a0
pushq $0x30
popq %rdi
callq 0x115c0
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movq %rax, (%rbx)
jmp 0x748a0
movb $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x74a09
movl %esi, %r14d
movq %rdi, %rbx
leal 0x5(%r14), %edi
callq 0x117e0
testq %rax, %rax
je 0x74a3a
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 0x11800
leaq 0x38037(%rip), %rsi     # 0xaca54
movq %rbx, %rdi
callq 0x115a0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x119a0
movq %rsp, %rdi
callq 0x74503
leaq 0x38061(%rip), %rsi     # 0xacaa2
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x196d0
leaq 0x20(%rsp), %rdi
callq 0x6f0a2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x11270
jmp 0x74a7e
jmp 0x74a7b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x11270
jmp 0x74a88
movq %rax, %rbx
jmp 0x74a88
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x11180
movq %rbx, %rdi
callq 0x11a80
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
movups 0x18(%rsi), %xmm0
movups %xmm0, 0x18(%rdi)
cmpb $0x7, %cl
ja 0x74bcc
pushq $0x2f
popq %rdx
btl %ecx, %edx
jae 0x74b7c
movq (%rbx), %rax
movq %rax, (%r14)
jmp 0x74bcc
movl $0xc0, %edx
btl %ecx, %edx
jae 0x74ba1
pushq $0x30
popq %rdi
callq 0x115c0
movq %rax, %r15
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x7abf8
movq %r15, (%r14)
jmp 0x74bcc
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x74baf
testb $0x1, 0x9(%rbx)
jne 0x74bb9
movq %rdi, (%r14)
movw %ax, 0x8(%r14)
jmp 0x74bcc
movl (%rdi), %esi
addq $0x4, %rdi
callq 0x749ac
movq %rax, (%r14)
orb $0x1, 0x9(%r14)
cmpq $0x0, 0x10(%rbx)
je 0x74c2f
pushq $0x20
popq %rdi
callq 0x11040
movq $0x3, (%rax)
leaq 0x8(%rax), %rcx
andq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rcx, 0x10(%r14)
xorl %r13d, %r13d
cmpq $0x18, %r13
je 0x74c2f
movq 0x10(%rbx), %rax
movq (%rax,%r13), %r15
testq %r15, %r15
je 0x74c29
movq 0x10(%r14), %r12
addq %r13, %r12
movq %r15, %rdi
callq 0x11250
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x74578
addq $0x8, %r13
jmp 0x74bf9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r15, %rdi
callq 0x115d0
movq %rbx, %rdi
callq 0x11a80
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6f810
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_O2/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 0x74ce4
movq (%rbx), %r14
testq %r14, %r14
je 0x74cd7
movq %r14, %rdi
callq 0x7aed2
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x115d0
jmp 0x74cf7
cmpl $0x4, %ecx
jne 0x74cf7
btl $0x8, %eax
jae 0x74cf7
movq (%rbx), %rdi
callq 0x11710
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x74d39
movq -0x8(%rbx), %r14
addq $-0x8, %rbx
testq %r14, %r14
je 0x74d24
leaq (,%r14,8), %r15
leaq (%rbx,%r15), %rdi
callq 0x74570
addq $-0x8, %r15
jne 0x74d15
leaq 0x8(,%r14,8), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x11bc0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x74d74
testb %al, %al
je 0x74d5e
pushq $-0x1
popq %rax
jmp 0x74d6c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74d74
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x74e0a
movzbl %al, %ecx
decl %ecx
cmpl $0x6, %ecx
ja 0x74dc7
leaq 0x36ef7(%rip), %rdx     # 0xabc9c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rdi), %rdi
movl 0x28(%rdi), %eax
movq (%rsi), %rsi
subl 0x28(%rsi), %eax
je 0x74e16
shrl $0x1f, %eax
jmp 0x74e0d
movb (%rdi), %al
cmpb (%rsi), %al
jmp 0x74e0a
xorl %eax, %eax
jmp 0x74e0d
movsd (%rsi), %xmm0
ucomisd (%rdi), %xmm0
seta %al
jmp 0x74e0d
movq (%rdi), %rbx
testq %rbx, %rbx
sete %cl
movq (%rsi), %r14
testq %r14, %r14
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x74e23
testq %r14, %r14
setne %al
jmp 0x74e0d
movq (%rdi), %rax
cmpq (%rsi), %rax
setl %al
jmp 0x74e0d
movq (%rdi), %rax
cmpq (%rsi), %rax
setb %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7c4de
btl $0x8, %eax
jb 0x74e36
movq %rbx, %rdi
callq 0x11250
movq %rax, %r15
jmp 0x74e3d
movl (%rbx), %r15d
addq $0x4, %rbx
btl $0x8, %ebp
jb 0x74e50
movq %r14, %rdi
callq 0x11250
movq %rax, %r12
jmp 0x74e57
movl (%r14), %r12d
addq $0x4, %r14
cmpl %r15d, %r12d
movl %r15d, %edx
cmovbl %r12d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11260
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
js 0x74e0d
sete %cl
cmpl %r12d, %r15d
setb %al
andb %cl, %al
jmp 0x74e0d
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x74ed1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x7, %al
ja 0x74ec4
movzwl %ax, %ecx
movzbl %cl, %ecx
leaq 0x36dd6(%rip), %rdx     # 0xabcb8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0x74f9d
movq (%rdi), %rdi
movq 0x28(%rdi), %rax
movq (%rsi), %rsi
cmpq 0x28(%rsi), %rax
jne 0x74ec4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7c5c9
movq (%rdi), %rbx
testq %rbx, %rbx
sete %cl
movq (%rsi), %r14
testq %r14, %r14
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x74f53
cmpq %r14, %rbx
jmp 0x74f9d
movb $0x1, %al
jmp 0x74ec6
movsd (%rsi), %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x74ec6
movb (%rdi), %al
cmpb (%rsi), %al
jmp 0x74f9d
btl $0x8, %eax
jb 0x74f66
movq %rbx, %rdi
callq 0x11250
movq %rax, %r15
jmp 0x74f6d
movl (%rbx), %r15d
addq $0x4, %rbx
btl $0x8, %ebp
jb 0x74f7d
movq %r14, %rdi
callq 0x11250
jmp 0x74f84
movl (%r14), %eax
addq $0x4, %r14
cmpl %eax, %r15d
jne 0x74ec4
movl %r15d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x115f0
testl %eax, %eax
sete %al
jmp 0x74ec6
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x74fdc
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 0x11800
leaq 0x37430(%rip), %rsi     # 0xac420
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
jmp 0x75025
jmp 0x75022
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11180
movq %rbx, %rdi
callq 0x11a80
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75083
movq %rdx, %rbx
movq %rsi, %r14
btl $0x8, %eax
jb 0x75071
movq %r15, %rdi
callq 0x11250
jmp 0x75078
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_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x29(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rsi, %rdi
negq %rdi
jno 0x750b8
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
jmp 0x750d2
testq %rsi, %rsi
js 0x750d2
leaq 0x8(%rsp), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x76de6
movq (%r14), %rsi
jmp 0x750e9
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x76de6
movq (%r14), %rsi
movb $0x2d, -0x1(%rsi)
decq %rsi
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x196d0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x29(%rsp), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rsi, %rdi
movq %r14, %rsi
callq 0x76de6
movq (%r14), %rsi
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x196d0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7517b
cmpl $0x2, %eax
je 0x75170
cmpl $0x1, %eax
jne 0x7519e
movq (%rdi), %rax
movslq %eax, %rcx
cmpq %rax, %rcx
jmp 0x75177
movq (%rdi), %rax
shrq $0x1f, %rax
sete %al
retq
movsd (%rdi), %xmm0
xorl %eax, %eax
ucomisd 0x36e17(%rip), %xmm0    # 0xabfa0
jb 0x7517a
movsd 0x36e15(%rip), %xmm1    # 0xabfa8
ucomisd %xmm0, %xmm1
jb 0x7517a
jmp 0x76690
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x752b5
movq %rdi, %rbx
leaq 0x36b16(%rip), %rcx     # 0xabcd8
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rbx, %rdi
callq 0x75322
testb %al, %al
jne 0x7521d
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x37306(%rip), %rsi     # 0xac4f1
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
movzbl (%rbx), %eax
jmp 0x75242
movq %rbx, %rdi
callq 0x75322
testb %al, %al
je 0x7524b
movl (%rbx), %eax
jmp 0x75242
movsd (%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x75280
movsd 0x36d79(%rip), %xmm1    # 0xabfb0
ucomisd %xmm0, %xmm1
jb 0x75280
cvttsd2si %xmm0, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x372af(%rip), %rsi     # 0xac50e
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x37298(%rip), %rsi     # 0xac52c
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3727c(%rip), %rsi     # 0xac545
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
jmp 0x752f4
jmp 0x7530d
jmp 0x752f4
jmp 0x7530d
jmp 0x752f4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
jmp 0x75310
jmp 0x7530d
jmp 0x7530d
jmp 0x7530d
jmp 0x7530d
jmp 0x7530d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11180
movq %rbx, %rdi
callq 0x11a80
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7533d
cmpl $0x2, %eax
je 0x75335
cmpl $0x1, %eax
jne 0x75360
cmpl $0x0, 0x4(%rdi)
sete %al
retq
movsd (%rdi), %xmm0
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x7533c
movsd 0x36c5b(%rip), %xmm1    # 0xabfb0
ucomisd %xmm0, %xmm1
jb 0x7533c
jmp 0x76690
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75439
movq %rdi, %rbx
leaq 0x3696c(%rip), %rcx     # 0xabcf0
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rbx, %rdi
callq 0x754a0
testb %al, %al
je 0x753cf
movq (%rbx), %rax
jmp 0x753c6
movzbl (%rbx), %eax
jmp 0x753c6
movsd (%rbx), %xmm0
movapd 0x33161(%rip), %xmm1    # 0xa8510
andpd %xmm0, %xmm1
movsd 0x36355(%rip), %xmm2    # 0xab710
ucomisd %xmm1, %xmm2
jb 0x75404
cvttsd2si %xmm0, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x37184(%rip), %rsi     # 0xac567
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3716e(%rip), %rsi     # 0xac586
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x37153(%rip), %rsi     # 0xac5a0
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
jmp 0x75476
jmp 0x7548b
jmp 0x75476
jmp 0x7548b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
jmp 0x7548e
jmp 0x7548b
jmp 0x7548b
jmp 0x7548b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11180
movq %rbx, %rdi
callq 0x11a80
// File: /workspace/github_cpp_makefile_star2_O2/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 0x754de
cmpl $0x3, %eax
je 0x754bb
cmpl $0x2, %eax
jne 0x754e1
cmpq $0x0, (%rdi)
setns %al
retq
movsd (%rdi), %xmm0
xorl %eax, %eax
ucomisd 0x36aef(%rip), %xmm0    # 0xabfb8
jb 0x754ba
movsd 0x3623d(%rip), %xmm1    # 0xab710
ucomisd %xmm0, %xmm1
jbe 0x754ba
jmp 0x76690
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::asUInt64() const
Value::UInt64 Value::asUInt64() const {
  switch (type_) {
  case intValue:
    JSON_ASSERT_MESSAGE(isUInt64(), "LargestInt out of UInt64 range");
    return UInt64(value_.int_);
  case uintValue:
    return UInt64(value_.uint_);
  case realValue:
    JSON_ASSERT_MESSAGE(InRange(value_.real_, 0, maxUInt64),
                        "double out of UInt64 range");
    return UInt64(value_.real_);
  case nullValue:
    return 0;
  case booleanValue:
    return value_.bool_ ? 1 : 0;
  default:
    break;
  }
  JSON_FAIL_MESSAGE("Value is not convertible to UInt64.");
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
cmpq $0x5, %rax
ja 0x755d1
movq %rdi, %rbx
leaq 0x36804(%rip), %rcx     # 0xabd08
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rbx, %rdi
callq 0x75638
testb %al, %al
je 0x75567
movq (%rbx), %rax
jmp 0x7555e
movzbl (%rbx), %eax
jmp 0x7555e
movsd (%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x7559c
movsd 0x36a87(%rip), %xmm1    # 0xabfc0
ucomisd %xmm0, %xmm1
jb 0x7559c
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x361bd(%rip), %xmm0    # 0xab710
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x37048(%rip), %rsi     # 0xac5c3
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x37032(%rip), %rsi     # 0xac5e2
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x37018(%rip), %rsi     # 0xac5fd
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
jmp 0x7560e
jmp 0x75623
jmp 0x7560e
jmp 0x75623
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
jmp 0x75626
jmp 0x75623
jmp 0x75623
jmp 0x75623
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11180
movq %rbx, %rdi
callq 0x11a80
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::isUInt64() const
bool Value::isUInt64() const {
#if defined(JSON_HAS_INT64)
  switch (type_) {
  case intValue:
    return value_.int_ >= 0;
  case uintValue:
    return true;
  case realValue:
    // Note that maxUInt64 (= 2^64 - 1) is not exactly representable as a
    // double, so double(maxUInt64) will be rounded up to 2^64. Therefore we
    // require the value to be strictly less than the limit.
    return value_.real_ >= 0 && value_.real_ < maxUInt64AsDouble &&
           IsIntegral(value_.real_);
  default:
    break;
  }
#endif // JSON_HAS_INT64
  return false;
}

// Assembly:
movzbl 0x8(%rdi), %eax
cmpl $0x3, %eax
je 0x75656
cmpl $0x2, %eax
je 0x75653
cmpl $0x1, %eax
jne 0x75679
cmpq $0x0, (%rdi)
setns %al
retq
movb $0x1, %al
retq
movsd (%rdi), %xmm0
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x75652
movsd 0x36952(%rip), %xmm1    # 0xabfc0
ucomisd %xmm0, %xmm1
jbe 0x75652
jmp 0x76690
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::asDouble() const
double Value::asDouble() const {
  switch (type_) {
  case intValue:
    return static_cast<double>(value_.int_);
  case uintValue:
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
    return static_cast<double>(value_.uint_);
#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
    return integerToDouble(value_.uint_);
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
  case realValue:
    return value_.real_;
  case nullValue:
    return 0.0;
  case booleanValue:
    return value_.bool_ ? 1.0 : 0.0;
  default:
    break;
  }
  JSON_FAIL_MESSAGE("Value is not convertible to double.");
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
cmpq $0x5, %rax
ja 0x756f4
leaq 0x3667f(%rip), %rcx     # 0xabd20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2sdq (%rdi), %xmm0
jmp 0x756eb
cmpb $0x0, (%rdi)
jne 0x756e3
xorpd %xmm0, %xmm0
jmp 0x756eb
movsd (%rdi), %xmm1
unpcklps 0x368b9(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x368c1(%rip), %xmm1    # 0xabf90
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
jmp 0x756eb
movsd (%rdi), %xmm0
jmp 0x756eb
movsd 0x3293d(%rip), %xmm0    # 0xa8028
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x36f19(%rip), %rsi     # 0xac621
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
jmp 0x7573d
jmp 0x7573a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11180
movq %rbx, %rdi
callq 0x11a80
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::asFloat() const
float Value::asFloat() const {
  switch (type_) {
  case intValue:
    return static_cast<float>(value_.int_);
  case uintValue:
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
    return static_cast<float>(value_.uint_);
#else  // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
    // This can fail (silently?) if the value is bigger than MAX_FLOAT.
    return static_cast<float>(integerToDouble(value_.uint_));
#endif // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
  case realValue:
    return static_cast<float>(value_.real_);
  case nullValue:
    return 0.0;
  case booleanValue:
    return value_.bool_ ? 1.0f : 0.0f;
  default:
    break;
  }
  JSON_FAIL_MESSAGE("Value is not convertible to float.");
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
cmpq $0x5, %rax
ja 0x757c0
leaq 0x365cf(%rip), %rcx     # 0xabd38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2ssq (%rdi), %xmm0
jmp 0x757b7
cmpb $0x0, (%rdi)
jne 0x75798
xorps %xmm0, %xmm0
jmp 0x757b7
movq (%rdi), %rax
testq %rax, %rax
js 0x757a2
cvtsi2ss %rax, %xmm0
jmp 0x757b7
cvtsd2ss (%rdi), %xmm0
jmp 0x757b7
movss 0x33884(%rip), %xmm0    # 0xa9024
jmp 0x757b7
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x36e71(%rip), %rsi     # 0xac645
movq %rbx, %rdi
callq 0x115a0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
jmp 0x75809
jmp 0x75806
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11180
movq %rbx, %rdi
callq 0x11a80
nop