LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x81dfc
movq (%r15), %r14
movl 0x8(%r15), %esi
testq %r14, %r14
je 0x81916
movl %esi, %ebp
andl $0x3, %ebp
je 0x81939
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 0x82159
movq %rax, (%rbx)
jmp 0x8195a
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 0x8195a
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)
testq %r14, %r14
je 0x81973
movl 0x10(%rsp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x81973
movq %r14, %rdi
callq 0x11720
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %ebp
jne 0x81991
movq %r14, %rdi
callq 0x11720
movq %rbx, %rdi
callq 0x11a70
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x81a11
movl 0x28(%rax), %edx
shrl $0x2, %edx
addq %rsi, %rdx
jmp 0x81a15
xorl %edx, %edx
xorl %esi, %esi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
testq %rsi, %rsi
je 0x81a2b
movq %rbx, %rdi
callq 0x1ab58
jmp 0x81a37
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x81c8d
callq 0x11720
movq $0x0, (%rbx)
testq %r14, %r14
je 0x81ce7
movzbl (%r14), %eax
testl %eax, %eax
je 0x81ca3
cmpl $0x2f, %eax
jne 0x81d3e
movl $0x7ffffffe, %r12d      # imm = 0x7FFFFFFE
cmpq %r12, %r15
cmovbq %r15, %r12
leaq 0x1(%r12), %rdi
callq 0x117e0
testq %rax, %rax
je 0x81d12
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 0x3f7bd(%rip), %rsi     # 0xc14b4
leaq 0x3f7c8(%rip), %rdx     # 0xc14c6
leaq 0x20(%rsp), %rdi
callq 0x1ab58
leaq 0x20(%rsp), %rdi
callq 0x81bd3
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3fdc6(%rip), %rsi     # 0xc1ae8
leaq 0x3fe0d(%rip), %rdx     # 0xc1b36
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x1ab58
movq %rbx, %rdi
callq 0x79c0a
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3f775(%rip), %rsi     # 0xc14c7
movl $0x38, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x11990
movq %rsp, %rdi
callq 0x81bd3
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x81d99
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x81d99
jmp 0x81d96
movq %rax, %rbx
movq 0x84200(%rip), %rsi     # 0x105fa0
leaq 0x20(%rsp), %rdi
callq 0x112f0
leaq 0x90(%rsp), %rdi
callq 0x111f0
jmp 0x81dda
jmp 0x81dc0
movq %rax, %rbx
jmp 0x81dda
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x81dda
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x11a70
// File: /workspace/github_cpp_makefile_star2_O1/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), %r15d
testb $0x3, %r15b
je 0x81e4c
movq (%r14), %r12
testq %r12, %r12
je 0x81e4c
shrl $0x2, %r15d
leaq 0x1(%r15), %rdi
callq 0x117e0
testq %rax, %rax
je 0x81e8a
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x114b0
movb $0x0, (%r13,%r15)
jmp 0x81e4f
movq (%r14), %r13
movq %r13, (%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 0x3fc4e(%rip), %rsi     # 0xc1ae8
leaq 0x3fc95(%rip), %rdx     # 0xc1b36
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1ab58
movq %rbx, %rdi
callq 0x79c0a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x81ecd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x115c0
movq %rbx, %rdi
callq 0x11a70
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x81f79
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 0x81f7f
sete %cl
cmpl %ebp, %ebx
setb %al
andb %cl, %al
jmp 0x81f7f
cmpl 0x8(%rsi), %ebx
setb %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x81fb4
shrl $0x2, %edx
movl 0x8(%rsi), %eax
shrl $0x2, %eax
cmpl %eax, %edx
jne 0x81fbb
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_O1/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 0x82038
pushq %rbx
movq %rdi, %rbx
movl %esi, %eax
leaq 0x3ed6b(%rip), %rcx     # 0xc0d5c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x0, (%rbx)
jmp 0x82037
movl $0x30, %edi
callq 0x115b0
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, (%rbx)
jmp 0x82037
movb $0x0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x821b6
movl %esi, %r14d
movq %rdi, %rbx
leal 0x5(%r14), %edi
callq 0x117e0
testq %rax, %rax
je 0x821ec
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(%r12,%r15)
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 0x3f96d(%rip), %rsi     # 0xc1b37
movl $0x4d, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x11990
movq %rsp, %rdi
callq 0x81bd3
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3f989(%rip), %rsi     # 0xc1b85
leaq 0x3f9d9(%rip), %rdx     # 0xc1bdc
leaq 0x20(%rsp), %rdi
callq 0x1ab58
leaq 0x20(%rsp), %rdi
callq 0x79c0a
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8225d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x8225d
jmp 0x8225a
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x8227b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x8227b
movq %rax, %rbx
jmp 0x8227b
movq %rax, %rbx
movq 0x83d3c(%rip), %rsi     # 0x105fa0
leaq 0x20(%rsp), %rdi
callq 0x112f0
leaq 0x90(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a70
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x823d3
movl $0x2f, %edx
btl %ecx, %edx
jae 0x82381
movq (%rbx), %rax
movq %rax, (%r14)
jmp 0x823d3
movl $0xc0, %edx
btl %ecx, %edx
jae 0x823a8
movl $0x30, %edi
callq 0x115b0
movq %rax, %r15
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x8aa32
movq %r15, (%r14)
jmp 0x823d3
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x823b6
testb $0x1, 0x9(%rbx)
jne 0x823c0
movq %rdi, (%r14)
movw %ax, 0x8(%r14)
jmp 0x823d3
movl (%rdi), %esi
addq $0x4, %rdi
callq 0x82159
movq %rax, (%r14)
orb $0x1, 0x9(%r14)
cmpq $0x0, 0x10(%rbx)
je 0x82439
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 0x8242f
movq 0x10(%r14), %r12
addq %r13, %r12
movq %r15, %rdi
callq 0x11260
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x81c62
addq $0x8, %r13
cmpq $0x18, %r13
jne 0x82405
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 0x11a70
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7a718
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_O1/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 0x82536
movq (%rbx), %r14
testq %r14, %r14
je 0x82549
movq %r14, %rdi
callq 0x8acf0
movl $0x30, %esi
movq %r14, %rdi
callq 0x115c0
jmp 0x82549
cmpl $0x4, %ecx
jne 0x82549
btl $0x8, %eax
jae 0x82549
movq (%rbx), %rdi
callq 0x11720
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x82590
movq -0x8(%rbx), %r14
addq $-0x8, %rbx
testq %r14, %r14
je 0x8257b
leaq (,%r14,8), %r15
movq (%rbx,%r15), %rdi
testq %rdi, %rdi
je 0x82575
callq 0x11720
addq $-0x8, %r15
jne 0x82567
leaq 0x8(,%r14,8), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x11ba0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x82663
movzbl %al, %ecx
decl %ecx
cmpl $0x6, %ecx
ja 0x82620
leaq 0x3e77f(%rip), %rdx     # 0xc0d7c
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 0x8266f
shrl $0x1f, %eax
jmp 0x82666
movb (%rdi), %al
cmpb (%rsi), %al
jmp 0x82663
xorl %eax, %eax
jmp 0x82666
movsd (%rsi), %xmm0
ucomisd (%rdi), %xmm0
seta %al
jmp 0x82666
movq (%rdi), %rbx
testq %rbx, %rbx
sete %cl
movq (%rsi), %r14
testq %r14, %r14
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x8268f
testq %r14, %r14
setne %al
jmp 0x82666
movq (%rdi), %rax
cmpq (%rsi), %rax
setl %al
jmp 0x82666
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 0x8c163
btl $0x8, %eax
jb 0x826a2
movq %rbx, %rdi
callq 0x11260
movq %rax, %r15
jmp 0x826a9
movl (%rbx), %r15d
addq $0x4, %rbx
btl $0x8, %ebp
jb 0x826bc
movq %r14, %rdi
callq 0x11260
movq %rax, %r12
jmp 0x826c3
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 0x82666
sete %cl
cmpl %r12d, %r15d
setb %al
andb %cl, %al
jmp 0x82666
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8273f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x7, %al
ja 0x82732
movzwl %ax, %ecx
movzbl %cl, %ecx
leaq 0x3e648(%rip), %rdx     # 0xc0d98
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rdi), %rax
cmpq (%rsi), %rax
jmp 0x8281a
movq (%rdi), %rax
movq 0x28(%rax), %rdx
movq (%rsi), %rcx
cmpq 0x28(%rcx), %rdx
jne 0x82732
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 0x8c25e
movq (%rdi), %rbx
testq %rbx, %rbx
sete %cl
movq (%rsi), %r14
testq %r14, %r14
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x827d0
cmpq %r14, %rbx
jmp 0x8281a
movb $0x1, %al
jmp 0x82734
movsd (%rsi), %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x82734
movb (%rdi), %al
cmpb (%rsi), %al
jmp 0x8281a
btl $0x8, %eax
jb 0x827e3
movq %rbx, %rdi
callq 0x11260
movq %rax, %r15
jmp 0x827ea
movl (%rbx), %r15d
addq $0x4, %rbx
btl $0x8, %ebp
jb 0x827fa
movq %r14, %rdi
callq 0x11260
jmp 0x82801
movl (%r14), %eax
addq $0x4, %r14
cmpl %eax, %r15d
jne 0x82732
movl %r15d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x115e0
testl %eax, %eax
sete %al
jmp 0x82734
// File: /workspace/github_cpp_makefile_star2_O1/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 0x82858
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 0x3ec94(%rip), %rsi     # 0xc1500
movl $0x31, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x828b7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x828b7
jmp 0x828b4
movq %rax, %rbx
movq 0x836e2(%rip), %rsi     # 0x105fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a70
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x82929
movq %rdx, %rbx
movq %rsi, %r14
btl $0x8, %eax
jb 0x82917
movq %r15, %rdi
callq 0x11260
jmp 0x8291e
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_O1/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 0x82992
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 0x82963
jmp 0x82a15
movq %rsi, %rcx
testq %rsi, %rsi
js 0x829d8
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 0x829ac
jmp 0x82a1d
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 0x829eb
movb $0x2d, -0x2(%rsi)
addq $-0x2, %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x89890
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x82a50
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x89890
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x82acf
cmpl $0x2, %eax
je 0x82ac4
cmpl $0x1, %eax
jne 0x82b0c
movq (%rdi), %rax
movslq %eax, %rcx
cmpq %rax, %rcx
jmp 0x82acb
movq (%rdi), %rax
shrq $0x1f, %rax
sete %al
retq
movsd (%rdi), %xmm0
xorl %eax, %eax
ucomisd 0x3e5a3(%rip), %xmm0    # 0xc1080
jb 0x82ace
movsd 0x3e5a1(%rip), %xmm1    # 0xc1088
ucomisd %xmm0, %xmm1
jb 0x82ace
pushq %rax
movq %rsp, %rdi
callq 0x11a80
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_O1/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 0x82c32
movq %rdi, %rbx
leaq 0x3e288(%rip), %rcx     # 0xc0db8
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rbx, %rdi
callq 0x82cca
testb %al, %al
jne 0x82b90
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3ea78(%rip), %rsi     # 0xc15d1
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
movzbl (%rbx), %eax
jmp 0x82bb5
movq %rbx, %rdi
callq 0x82cca
testb %al, %al
je 0x82bbe
movl (%rbx), %eax
jmp 0x82bb5
movsd (%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x82bf8
movsd 0x3e4e6(%rip), %xmm1    # 0xc1090
ucomisd %xmm0, %xmm1
jb 0x82bf8
cvttsd2si %xmm0, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3ea1c(%rip), %rsi     # 0xc15ee
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3ea00(%rip), %rsi     # 0xc160c
movl $0x18, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3e9df(%rip), %rsi     # 0xc1625
movl $0x21, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
jmp 0x82c76
jmp 0x82ca0
jmp 0x82c76
jmp 0x82ca0
jmp 0x82c76
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x82ca3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x82ca3
jmp 0x82ca0
jmp 0x82ca0
jmp 0x82ca0
jmp 0x82ca0
jmp 0x82ca0
movq %rax, %rbx
movq 0x832f6(%rip), %rsi     # 0x105fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a70
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x82ce5
cmpl $0x2, %eax
je 0x82cdd
cmpl $0x1, %eax
jne 0x82d22
cmpl $0x0, 0x4(%rdi)
sete %al
retq
movsd (%rdi), %xmm0
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x82ce4
movsd 0x3e393(%rip), %xmm1    # 0xc1090
ucomisd %xmm0, %xmm1
jb 0x82ce4
pushq %rax
movq %rsp, %rdi
callq 0x11a80
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_O1/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 0x82e05
movq %rdi, %rbx
leaq 0x3e08a(%rip), %rcx     # 0xc0dd0
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rbx, %rdi
callq 0x82e96
testb %al, %al
je 0x82d91
movq (%rbx), %rax
jmp 0x82d88
movzbl (%rbx), %eax
jmp 0x82d88
movsd (%rbx), %xmm0
movapd 0x3a81f(%rip), %xmm1    # 0xbd590
andpd %xmm0, %xmm1
movsd 0x3da73(%rip), %xmm2    # 0xc07f0
ucomisd %xmm1, %xmm2
jb 0x82dcb
cvttsd2si %xmm0, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3e8a2(%rip), %rsi     # 0xc1647
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3e887(%rip), %rsi     # 0xc1666
movl $0x19, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3e867(%rip), %rsi     # 0xc1680
movl $0x22, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
jmp 0x82e47
jmp 0x82e6d
jmp 0x82e47
jmp 0x82e6d
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x82e70
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x82e70
jmp 0x82e6d
jmp 0x82e6d
jmp 0x82e6d
movq %rax, %rbx
movq 0x83129(%rip), %rsi     # 0x105fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a70
// File: /workspace/github_cpp_makefile_star2_O1/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 0x82eee
cmpl $0x3, %eax
je 0x82eb1
cmpl $0x2, %eax
jne 0x82ef1
cmpq $0x0, (%rdi)
setns %al
retq
movsd (%rdi), %xmm0
xorl %eax, %eax
ucomisd 0x3e1d9(%rip), %xmm0    # 0xc1098
jb 0x82eb0
movsd 0x3d927(%rip), %xmm1    # 0xc07f0
ucomisd %xmm0, %xmm1
jbe 0x82eb0
pushq %rax
movq %rsp, %rdi
callq 0x11a80
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
addq $0x8, %rsp
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x82feb
movq %rdi, %rbx
leaq 0x3ded4(%rip), %rcx     # 0xc0de8
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rbx, %rdi
callq 0x8307c
testb %al, %al
je 0x82f77
movq (%rbx), %rax
jmp 0x82f6e
movzbl (%rbx), %eax
jmp 0x82f6e
movsd (%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x82fb1
movsd 0x3e157(%rip), %xmm1    # 0xc10a0
ucomisd %xmm0, %xmm1
jb 0x82fb1
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x3d88d(%rip), %xmm0    # 0xc07f0
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 0x3e718(%rip), %rsi     # 0xc16a3
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3e6fd(%rip), %rsi     # 0xc16c2
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3e6de(%rip), %rsi     # 0xc16dd
movl $0x23, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
jmp 0x8302d
jmp 0x83053
jmp 0x8302d
jmp 0x83053
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83056
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x83056
jmp 0x83053
jmp 0x83053
jmp 0x83053
movq %rax, %rbx
movq 0x82f43(%rip), %rsi     # 0x105fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a70
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8309a
cmpl $0x2, %eax
je 0x83097
cmpl $0x1, %eax
jne 0x830d7
cmpq $0x0, (%rdi)
setns %al
retq
movb $0x1, %al
retq
movsd (%rdi), %xmm0
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x83096
movsd 0x3dfee(%rip), %xmm1    # 0xc10a0
ucomisd %xmm0, %xmm1
jbe 0x83096
pushq %rax
movq %rsp, %rdi
callq 0x11a80
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x83152
leaq 0x3dd01(%rip), %rcx     # 0xc0e00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2sdq (%rdi), %xmm0
jmp 0x83149
cmpb $0x0, (%rdi)
jne 0x83141
xorpd %xmm0, %xmm0
jmp 0x83149
movsd (%rdi), %xmm1
unpcklps 0x3df3b(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3df43(%rip), %xmm1    # 0xc1070
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
jmp 0x83149
movsd (%rdi), %xmm0
jmp 0x83149
movsd 0x39edf(%rip), %xmm0    # 0xbd028
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3e59b(%rip), %rsi     # 0xc1701
movl $0x23, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x831b1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x831b1
jmp 0x831ae
movq %rax, %rbx
movq 0x82de8(%rip), %rsi     # 0x105fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a70
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x83248
leaq 0x3dc27(%rip), %rcx     # 0xc0e18
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2ssq (%rdi), %xmm0
jmp 0x8323f
cmpb $0x0, (%rdi)
jne 0x83220
xorps %xmm0, %xmm0
jmp 0x8323f
movq (%rdi), %rax
testq %rax, %rax
js 0x8322a
cvtsi2ss %rax, %xmm0
jmp 0x8323f
cvtsd2ss (%rdi), %xmm0
jmp 0x8323f
movss 0x3ae7c(%rip), %xmm0    # 0xbe0a4
jmp 0x8323f
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 0x3e4c9(%rip), %rsi     # 0xc1725
movl $0x22, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x832a7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x832a7
jmp 0x832a4
movq %rax, %rbx
movq 0x82cf2(%rip), %rsi     # 0x105fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a70
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::clear()
void Value::clear() {
  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue ||
                          type_ == objectValue,
                      "in Json::Value::clear(): requires complex value");
  start_ = 0;
  limit_ = 0;
  switch (type_) {
  case arrayValue:
  case objectValue:
    value_.map_->clear();
    break;
  default:
    break;
  }
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzwl 0x8(%rdi), %eax
movzbl %al, %ecx
leal -0x6(%rcx), %edx
cmpl $0x2, %edx
jb 0x83533
testl %ecx, %ecx
jne 0x8355e
andl $0xfe, %eax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
cmpw $0x6, %ax
jne 0x83555
movq (%rdi), %rdi
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
jmp 0x8c2d6
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3e1f8(%rip), %rsi     # 0xc176a
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x835bd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x835bd
jmp 0x835ba
movq %rax, %rbx
movq 0x829dc(%rip), %rsi     # 0x105fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a70
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::operator[](unsigned int) const
const Value& Value::operator[](ArrayIndex index) const {
  JSON_ASSERT_MESSAGE(
      type_ == nullValue || type_ == arrayValue,
      "in Json::Value::operator[](ArrayIndex)const: requires arrayValue");
  if (type_ == nullValue)
    return nullRef;
  CZString key(index);
  ObjectValues::const_iterator it = value_.map_->find(key);
  if (it == value_.map_->end())
    return nullRef;
  return (*it).second;
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
testl %eax, %eax
je 0x83b12
cmpl $0x6, %eax
jne 0x83b25
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq $0x0, (%rax)
movl %esi, 0x8(%rax)
movq (%rdi), %rdi
movq %rax, %rsi
callq 0x8c73c
movq (%rbx), %rcx
addq $0x8, %rcx
leaq 0x30(%rax), %rdx
cmpq %rcx, %rax
leaq 0x3d44f(%rip), %rbx     # 0xc0f40
cmovneq %rdx, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x83b19
movl 0x30(%rsp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x83b19
callq 0x11720
jmp 0x83b19
leaq 0x3d427(%rip), %rbx     # 0xc0f40
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3dd0b(%rip), %rsi     # 0xc1844
movl $0x40, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83b84
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x83b84
jmp 0x83b81
movq %rax, %rbx
movq 0x82415(%rip), %rsi     # 0x105fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
jmp 0x83bc2
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x83bc2
movl 0x30(%rsp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x83bc2
callq 0x11720
movq %rbx, %rdi
callq 0x11a70
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::operator[](int) const
const Value& Value::operator[](int index) const {
  JSON_ASSERT_MESSAGE(
      index >= 0,
      "in Json::Value::operator[](int index) const: index cannot be negative");
  return (*this)[ArrayIndex(index)];
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
testl %esi, %esi
js 0x83be3
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
jmp 0x83aaa
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3dc8e(%rip), %rsi     # 0xc1885
movl $0x45, %edx
movq %rbx, %rdi
callq 0x116d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x11990
leaq 0x8(%rsp), %rdi
callq 0x81bd3
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83c42
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x115c0
jmp 0x83c42
jmp 0x83c3f
movq %rax, %rbx
movq 0x82357(%rip), %rsi     # 0x105fa0
leaq 0x28(%rsp), %rdi
callq 0x112f0
leaq 0x98(%rsp), %rdi
callq 0x111f0
movq %rbx, %rdi
callq 0x11a70