LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpb $0x7, %al
ja 0x75a84
movzbl %al, %ecx
movl $0xc1, %edx
btl %ecx, %edx
jae 0x75a84
andl $0xfe, %eax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
cmpw $0x6, %ax
jne 0x75a7b
movq (%rdi), %rdi
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
jmp 0x7c66e
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x36bf2(%rip), %rsi     # 0xac68a
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 0x75acd
jmp 0x75aca
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::resize(unsigned int)
void Value::resize(ArrayIndex newSize) {
  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == arrayValue,
                      "in Json::Value::resize(): requires arrayValue");
  if (type_ == nullValue)
    *this = Value(arrayValue);
  ArrayIndex oldSize = size();
  if (newSize == 0)
    clear();
  else if (newSize > oldSize)
    (*this)[newSize - 1];
  else {
    for (ArrayIndex index = newSize; index < oldSize; ++index) {
      value_.map_->erase(index);
    }
    assert(size() == newSize);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movl %esi, %ebx
movq %rdi, %r14
movzbl 0x8(%rdi), %eax
testl %eax, %eax
je 0x75b34
cmpl $0x6, %eax
je 0x75b57
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x36ba7(%rip), %rsi     # 0xac6ba
movq %rbx, %rdi
callq 0x115a0
leaq 0x58(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
leaq 0x28(%rsp), %r15
pushq $0x6
popq %rsi
movq %r15, %rdi
callq 0x74836
movq %r14, %rdi
movq %r15, %rsi
callq 0x74c68
movq %r15, %rdi
callq 0x74cb0
movq %r14, %rdi
callq 0x73cc6
testl %ebx, %ebx
je 0x75b82
movl %eax, %ebp
cmpl %ebx, %eax
jae 0x75b97
decl %ebx
movq %r14, %rdi
movl %ebx, %esi
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x75c04
movq %r14, %rdi
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x75a3c
leaq 0x50(%rsp), %r15
cmpl %ebx, %ebp
je 0x75bc1
movq (%r14), %rdi
andq $0x0, 0x50(%rsp)
movl %ebx, 0x58(%rsp)
movq %r15, %rsi
callq 0x7c69c
movq %r15, %rdi
callq 0x74762
incl %ebx
jmp 0x75b9c
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
jmp 0x75be3
jmp 0x75be0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x11180
jmp 0x75bfc
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x74762
movq %rbx, %rdi
callq 0x11a80
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::operator[](unsigned int)
Value& Value::operator[](ArrayIndex index) {
  JSON_ASSERT_MESSAGE(
      type_ == nullValue || type_ == arrayValue,
      "in Json::Value::operator[](ArrayIndex): requires arrayValue");
  if (type_ == nullValue)
    *this = Value(arrayValue);
  CZString key(index);
  ObjectValues::iterator it = value_.map_->lower_bound(key);
  if (it != value_.map_->end() && (*it).first == key)
    return (*it).second;

  ObjectValues::value_type defaultValue(key, nullRef);
  it = value_.map_->insert(it, defaultValue);
  return (*it).second;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movl %esi, %ebp
movq %rdi, %rbx
movzbl 0x8(%rdi), %eax
testl %eax, %eax
je 0x75c52
cmpl $0x6, %eax
je 0x75c75
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x36ab3(%rip), %rsi     # 0xac6e8
movq %rbx, %rdi
callq 0x115a0
leaq 0x50(%rsp), %rsi
movq %rsp, %rdi
callq 0x119a0
movq %rsp, %rdi
callq 0x74503
leaq 0x20(%rsp), %r14
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0x74836
movq %rbx, %rdi
movq %r14, %rsi
callq 0x74c68
movq %r14, %rdi
callq 0x74cb0
movq %rsp, %rsi
andq $0x0, (%rsi)
movl %ebp, 0x8(%rsi)
movq (%rbx), %rdi
callq 0x7c870
movq %rax, %r14
movq (%rbx), %rax
addq $0x8, %rax
cmpq %rax, %r14
je 0x75ca9
movq %r14, %rdi
addq $0x20, %rdi
movq %rsp, %rsi
callq 0x747fe
testb %al, %al
jne 0x75cda
leaq 0x361b0(%rip), %rdx     # 0xabe60
leaq 0x48(%rsp), %rdi
movq %rsp, %rsi
callq 0x7a13e
movq (%rbx), %rdi
leaq 0x48(%rsp), %rdx
movq %r14, %rsi
callq 0x7c880
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x7a174
addq $0x30, %r14
movq %rsp, %rdi
callq 0x74762
movq %r14, %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x11270
jmp 0x75d07
jmp 0x75d04
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x11180
jmp 0x75d2f
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x7a174
jmp 0x75d27
jmp 0x75d24
movq %rax, %rbx
movq %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::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 0x75d8c
cmpl $0x6, %eax
jne 0x75d9f
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
andq $0x0, (%rax)
movl %esi, 0x8(%rax)
movq (%rdi), %rdi
movq %rax, %rsi
callq 0x7cb4a
movq (%rbx), %rcx
addq $0x8, %rcx
leaq 0x30(%rax), %rdx
cmpq %rcx, %rax
leaq 0x360e4(%rip), %rbx     # 0xabe60
cmovneq %rdx, %rbx
leaq 0x28(%rsp), %rdi
callq 0x74762
jmp 0x75d93
leaq 0x360cd(%rip), %rbx     # 0xabe60
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x369b1(%rip), %rsi     # 0xac764
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 0x75de8
jmp 0x75de5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11180
jmp 0x75e01
movq %rax, %rbx
leaq 0x28(%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::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 0x75e23
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
jmp 0x75d38
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3696e(%rip), %rsi     # 0xac7a5
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 0x75e6c
jmp 0x75e69
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::resolveReference(char const*)
Value& Value::resolveReference(const char* key) {
  JSON_ASSERT_MESSAGE(
      type_ == nullValue || type_ == objectValue,
      "in Json::Value::resolveReference(): requires objectValue");
  if (type_ == nullValue)
    *this = Value(objectValue);
  CZString actualKey(
      key, static_cast<unsigned>(strlen(key)), CZString::noDuplication); // NOTE!
  ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
  if (it != value_.map_->end() && (*it).first == actualKey)
    return (*it).second;

  ObjectValues::value_type defaultValue(actualKey, nullRef);
  it = value_.map_->insert(it, defaultValue);
  Value& value = (*it).second;
  return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x8(%rdi), %eax
testl %eax, %eax
je 0x75ece
cmpl $0x7, %eax
je 0x75ef1
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3693a(%rip), %rsi     # 0xac7eb
movq %rbx, %rdi
callq 0x115a0
leaq 0x50(%rsp), %rsi
movq %rsp, %rdi
callq 0x119a0
movq %rsp, %rdi
callq 0x74503
leaq 0x20(%rsp), %r15
pushq $0x7
popq %rsi
movq %r15, %rdi
callq 0x74836
movq %rbx, %rdi
movq %r15, %rsi
callq 0x74c68
movq %r15, %rdi
callq 0x74cb0
movq %r14, %rdi
callq 0x11250
movq %rsp, %rsi
movq %r14, (%rsi)
shll $0x2, %eax
movl %eax, 0x8(%rsi)
movq (%rbx), %rdi
callq 0x7c870
movq %rax, %r14
movq (%rbx), %rax
addq $0x8, %rax
cmpq %rax, %r14
je 0x75f2f
movq %r14, %rdi
addq $0x20, %rdi
movq %rsp, %rsi
callq 0x747fe
testb %al, %al
jne 0x75f60
leaq 0x35f2a(%rip), %rdx     # 0xabe60
leaq 0x48(%rsp), %rdi
movq %rsp, %rsi
callq 0x7a13e
movq (%rbx), %rdi
leaq 0x48(%rsp), %rdx
movq %r14, %rsi
callq 0x7c880
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x7a174
addq $0x30, %r14
movq %rsp, %rdi
callq 0x74762
movq %r14, %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x11270
jmp 0x75f8e
jmp 0x75f8b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x11180
jmp 0x75fb6
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x7a174
jmp 0x75fae
jmp 0x75fab
movq %rax, %rbx
movq %rsp, %rdi
callq 0x74762
movq %rbx, %rdi
callq 0x11a80
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::resolveReference(char const*, char const*)
Value& Value::resolveReference(char const* key, char const* cend)
{
  JSON_ASSERT_MESSAGE(
      type_ == nullValue || type_ == objectValue,
      "in Json::Value::resolveReference(key, end): requires objectValue");
  if (type_ == nullValue)
    *this = Value(objectValue);
  CZString actualKey(
      key, static_cast<unsigned>(cend-key), CZString::duplicateOnCopy);
  ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
  if (it != value_.map_->end() && (*it).first == actualKey)
    return (*it).second;

  ObjectValues::value_type defaultValue(actualKey, nullRef);
  it = value_.map_->insert(it, defaultValue);
  Value& value = (*it).second;
  return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movzbl 0x8(%rdi), %eax
testl %eax, %eax
je 0x76017
cmpl $0x7, %eax
je 0x7603a
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x3682e(%rip), %rsi     # 0xac824
movq %rbx, %rdi
callq 0x115a0
leaq 0x58(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x119a0
leaq 0x8(%rsp), %rdi
callq 0x74503
leaq 0x28(%rsp), %r12
pushq $0x7
popq %rsi
movq %r12, %rdi
callq 0x74836
movq %rbx, %rdi
movq %r12, %rsi
callq 0x74c68
movq %r12, %rdi
callq 0x74cb0
subl %r15d, %r14d
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
leal 0x2(,%r14,4), %eax
movl %eax, 0x8(%rsi)
movq (%rbx), %rdi
callq 0x7c870
movq %rax, %r14
movq (%rbx), %rax
addq $0x8, %rax
cmpq %rax, %r14
je 0x7607c
movq %r14, %rdi
addq $0x20, %rdi
leaq 0x8(%rsp), %rsi
callq 0x747fe
testb %al, %al
jne 0x760af
leaq 0x35ddd(%rip), %rdx     # 0xabe60
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7a13e
movq (%rbx), %rdi
leaq 0x50(%rsp), %rdx
movq %r14, %rsi
callq 0x7c880
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x7a174
addq $0x30, %r14
leaq 0x8(%rsp), %rdi
callq 0x74762
movq %r14, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
jmp 0x760e3
jmp 0x760e0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x11180
jmp 0x7610d
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x7a174
jmp 0x76103
jmp 0x76100
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::Value::find(char const*, char const*) const
Value const* Value::find(char const* key, char const* cend) const
{
  JSON_ASSERT_MESSAGE(
      type_ == nullValue || type_ == objectValue,
      "in Json::Value::find(key, end, found): requires objectValue or nullValue");
  if (type_ == nullValue) return NULL;
  CZString actualKey(key, static_cast<unsigned>(cend-key), CZString::noDuplication);
  ObjectValues::const_iterator it = value_.map_->find(actualKey);
  if (it == value_.map_->end()) return NULL;
  return &(*it).second;
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
testl %eax, %eax
je 0x761b1
cmpl $0x7, %eax
jne 0x761bf
movq %rdi, %rbx
subl %esi, %edx
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
shll $0x2, %edx
movl %edx, 0x8(%rax)
movq (%rdi), %rdi
movq %rax, %rsi
callq 0x7cb4a
movq (%rbx), %rcx
addq $0x8, %rcx
leaq 0x30(%rax), %rdx
xorl %ebx, %ebx
cmpq %rcx, %rax
cmovneq %rdx, %rbx
leaq 0x28(%rsp), %rdi
callq 0x74762
jmp 0x761b3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x36692(%rip), %rsi     # 0xac865
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 0x76208
jmp 0x76205
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x11180
jmp 0x76221
movq %rax, %rbx
leaq 0x28(%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::Value::removeMember(char const*, char const*, Json::Value*)
bool Value::removeMember(const char* key, const char* cend, Value* removed)
{
  if (type_ != objectValue) {
    return false;
  }
  CZString actualKey(key, static_cast<unsigned>(cend-key), CZString::noDuplication);
  ObjectValues::iterator it = value_.map_->find(actualKey);
  if (it == value_.map_->end())
    return false;
  *removed = it->second;
  value_.map_->erase(it);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
cmpb $0x7, 0x8(%rdi)
jne 0x763a5
movq %rcx, %r14
movq %rdi, %rbx
subl %esi, %edx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
shll $0x2, %edx
movl %edx, 0x8(%rax)
movq (%rdi), %rdi
movq %rax, %rsi
callq 0x7cb4a
movq %rax, %r15
movq (%rbx), %rax
addq $0x8, %rax
cmpq %rax, %r15
setne %bpl
je 0x76399
leaq 0x30(%r15), %rsi
leaq 0x18(%rsp), %rdi
callq 0x74b36
leaq 0x18(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x74c68
movq %r12, %rdi
callq 0x74cb0
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x7cb88
leaq 0x8(%rsp), %rdi
callq 0x74762
jmp 0x763a7
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
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::Value::removeMember(char const*)
Value Value::removeMember(const char* key)
{
  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
                      "in Json::Value::removeMember(): requires objectValue");
  if (type_ == nullValue)
    return nullRef;

  Value removed;  // null
  removeMember(key, key + strlen(key), &removed);
  return removed; // still null if removeMember() did nothing
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
movzbl 0x8(%rsi), %eax
testl %eax, %eax
je 0x76464
cmpl $0x7, %eax
jne 0x76483
movq %rdx, %r14
movq %rsi, %r15
andw $0xfe00, 0x8(%rbx)      # imm = 0xFE00
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
andq $0x0, (%rbx)
movq %rdx, %rdi
callq 0x11250
leaq (%rax,%r14), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x76322
jmp 0x76473
leaq 0x359f5(%rip), %rsi     # 0xabe60
movq %rbx, %rdi
callq 0x74b36
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x11800
leaq 0x36417(%rip), %rsi     # 0xac8ae
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 0x764cc
jmp 0x764c9
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x11180
jmp 0x764e3
movq %rax, %r14
movq %rbx, %rdi
callq 0x74cb0
movq %r14, %rdi
callq 0x11a80
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::removeIndex(unsigned int, Json::Value*)
bool Value::removeIndex(ArrayIndex index, Value* removed) {
  if (type_ != arrayValue) {
    return false;
  }
  CZString key(index);
  ObjectValues::iterator it = value_.map_->find(key);
  if (it == value_.map_->end()) {
    return false;
  }
  *removed = it->second;
  ArrayIndex oldSize = size();
  // shift left all items left, into the place of the "removed"
  for (ArrayIndex i = index; i < (oldSize - 1); ++i){
    CZString keey(i);
    (*value_.map_)[keey] = (*this)[i + 1];
  }
  // erase the last one ("leftover")
  CZString keyLast(oldSize - 1);
  ObjectValues::iterator itLast = value_.map_->find(keyLast);
  value_.map_->erase(itLast);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpb $0x6, 0x8(%rdi)
jne 0x765d4
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
leaq 0x18(%rsp), %rsi
andq $0x0, (%rsi)
movl %ebp, 0x8(%rsi)
movq (%rdi), %rdi
callq 0x7cb4a
movq (%r14), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
setne %bl
je 0x76602
addq $0x30, %rax
leaq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0x74b36
leaq 0x50(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x74c68
movq %r12, %rdi
callq 0x74cb0
movq %r14, %rdi
callq 0x73cc6
movl %eax, %r15d
decl %r15d
leaq 0x28(%rsp), %r12
leaq 0x8(%rsp), %r13
cmpl %r15d, %ebp
jae 0x765d8
andq $0x0, 0x8(%rsp)
movl %ebp, 0x10(%rsp)
incl %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x75c04
movq %r12, %rdi
movq %rax, %rsi
callq 0x74b36
movq (%r14), %rdi
movq %r13, %rsi
callq 0x7a18a
movq %rax, %rdi
movq %r12, %rsi
callq 0x74c68
movq %r12, %rdi
callq 0x74cb0
movq %r13, %rdi
callq 0x74762
jmp 0x76586
xorl %ebx, %ebx
jmp 0x7660c
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movl %r15d, 0x8(%rsi)
movq (%r14), %rdi
callq 0x7cb4a
movq (%r14), %rdi
movq %rax, %rsi
callq 0x7cb88
leaq 0x8(%rsp), %rdi
callq 0x74762
leaq 0x18(%rsp), %rdi
callq 0x74762
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x76633
movq %rax, %rbx
jmp 0x76640
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x74cb0
jmp 0x76636
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x74762
leaq 0x18(%rsp), %rdi
callq 0x74762
movq %rbx, %rdi
callq 0x11a80
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Value::setComment(char const*, unsigned long, Json::CommentPlacement)
void Value::setComment(const char* comment, size_t len, CommentPlacement placement) {
  if (!comments_)
    comments_ = new CommentInfo[numberOfCommentPlacement];
  if ((len > 0) && (comment[len-1] == '\n')) {
    // Always discard trailing newline, to aid indentation.
    len -= 1;
  }
  comments_[placement].setComment(comment, len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
jne 0x7671a
movq %rdi, %r15
pushq $0x20
popq %rdi
callq 0x11040
movq $0x3, (%rax)
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
movq %rcx, 0x10(%r15)
testq %r14, %r14
je 0x7672f
leaq -0x1(%r14), %rdx
cmpb $0xa, -0x1(%rbx,%r14)
cmovneq %r14, %rdx
jmp 0x76731
xorl %edx, %edx
movl %ebp, %eax
leaq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x74578
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StyledWriter::write[abi:cxx11](Json::Value const&)
std::string StyledWriter::write(const Value& root) {
  document_ = "";
  addChildValues_ = false;
  indentString_ = "";
  writeCommentBeforeValue(root);
  writeValue(root);
  writeCommentAfterValueOnSameLine(root);
  document_ += "\n";
  return document_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x20(%rsi), %r14
leaq 0x32cf9(%rip), %r13     # 0xa9564
movq %r14, %rdi
movq %r13, %rsi
callq 0x11b80
movb $0x0, 0x68(%r12)
leaq 0x40(%r12), %rdi
movq %r13, %rsi
callq 0x11b80
movq %r12, %rdi
movq %r15, %rsi
callq 0x7784e
movq %r12, %rdi
movq %r15, %rsi
callq 0x7792e
movq %r12, %rdi
movq %r15, %rsi
callq 0x77c2e
leaq 0x38201(%rip), %rsi     # 0xaeab2
movq %r14, %rdi
callq 0x11b70
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11850
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Path::Path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Json::PathArgument const&, Json::PathArgument const&, Json::PathArgument const&, Json::PathArgument const&, Json::PathArgument const&)
Path::Path(const std::string& path,
           const PathArgument& a1,
           const PathArgument& a2,
           const PathArgument& a3,
           const PathArgument& a4,
           const PathArgument& a5) {
  InArgs in;
  in.push_back(&a1);
  in.push_back(&a2);
  in.push_back(&a3);
  in.push_back(&a4);
  in.push_back(&a5);
  makePath(path, in);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x10(%rsp), %rdi
andq $0x0, 0x10(%rdi)
movq %rsi, %r14
movaps %xmm0, (%rdi)
leaq 0x8(%rsp), %rsi
movq %rdx, (%rsi)
callq 0x7cf5e
leaq 0x8(%rsp), %rsi
movq %r13, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7cf5e
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7cf5e
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7cf5e
movq 0x60(%rsp), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7cf5e
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x76aec
leaq 0x10(%rsp), %rdi
callq 0x7cf2a
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x76ace
jmp 0x76ace
jmp 0x76ace
jmp 0x76ace
jmp 0x76ace
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7cf2a
movq %rbx, %rdi
callq 0x7a2b2
movq %r14, %rdi
callq 0x11a80
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Path::resolve(Json::Value const&) const
const Value& Path::resolve(const Value& root) const {
  const Value* node = &root;
  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
    const PathArgument& arg = *it;
    if (arg.kind_ == PathArgument::kindIndex) {
      if (!node->isArray() || !node->isValidIndex(arg.index_)) {
        // Error: unable to resolve path (array value expected at position...
      }
      node = &((*node)[arg.index_]);
    } else if (arg.kind_ == PathArgument::kindKey) {
      if (!node->isObject()) {
        // Error: unable to resolve path (object value expected at position...)
      }
      node = &((*node)[arg.key_]);
      if (node == &Value::nullRef) {
        // Error: unable to resolve path (object has no member named '' at
        // position...)
      }
    }
  }
  return *node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rbx), %r14
je 0x76cf8
movl 0x24(%r14), %ecx
cmpl $0x2, %ecx
je 0x76ce7
cmpl $0x1, %ecx
jne 0x76cf2
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x75d38
jmp 0x76cf2
movq %rax, %rdi
movq %r14, %rsi
callq 0x73ca2
addq $0x28, %r14
jmp 0x76cc5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Path::resolve(Json::Value const&, Json::Value const&) const
Value Path::resolve(const Value& root, const Value& defaultValue) const {
  const Value* node = &root;
  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
    const PathArgument& arg = *it;
    if (arg.kind_ == PathArgument::kindIndex) {
      if (!node->isArray() || !node->isValidIndex(arg.index_))
        return defaultValue;
      node = &((*node)[arg.index_]);
    } else if (arg.kind_ == PathArgument::kindKey) {
      if (!node->isObject())
        return defaultValue;
      node = &((*node)[arg.key_]);
      if (node == &Value::nullRef)
        return defaultValue;
    }
  }
  return *node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %r13
leaq 0x3513e(%rip), %r15     # 0xabe60
cmpq 0x8(%r12), %r13
je 0x76d81
movl 0x24(%r13), %eax
cmpl $0x2, %eax
je 0x76d5d
cmpl $0x1, %eax
jne 0x76d77
cmpb $0x6, 0x8(%r14)
jne 0x76d7d
movl 0x20(%r13), %ebp
movq %r14, %rdi
callq 0x73cc6
cmpl %ebp, %eax
jbe 0x76d7d
movq %r14, %rdi
movl %ebp, %esi
callq 0x75d38
movq %rax, %r14
jmp 0x76d77
cmpb $0x7, 0x8(%r14)
jne 0x76d7d
movq %r14, %rdi
movq %r13, %rsi
callq 0x73ca2
movq %rax, %r14
cmpq %r15, %rax
je 0x76d7d
addq $0x28, %r13
jmp 0x76d22
movq (%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x74b36
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::Path::make(Json::Value&) const
Value& Path::make(Value& root) const {
  Value* node = &root;
  for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
    const PathArgument& arg = *it;
    if (arg.kind_ == PathArgument::kindIndex) {
      if (!node->isArray()) {
        // Error: node is not an array at position ...
      }
      node = &((*node)[arg.index_]);
    } else if (arg.kind_ == PathArgument::kindKey) {
      if (!node->isObject()) {
        // Error: node is not an object at position...
      }
      node = &((*node)[arg.key_]);
    }
  }
  return *node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rbx), %r14
je 0x76dde
movl 0x24(%r14), %ecx
cmpl $0x2, %ecx
je 0x76dcd
cmpl $0x1, %ecx
jne 0x76dd8
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x75c04
jmp 0x76dd8
movq %rax, %rdi
movq %r14, %rsi
callq 0x70276
addq $0x28, %r14
jmp 0x76dab
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::uintToString(unsigned long long, char*&)
static inline void uintToString(LargestUInt value, char*& current) {
  *--current = 0;
  do {
    *--current = static_cast<signed char>(value % 10U + static_cast<unsigned>('0'));
    value /= 10;
  } while (value != 0);
}

// Assembly:
movq (%rsi), %rax
leaq -0x1(%rax), %rcx
movq %rcx, (%rsi)
movb $0x0, -0x1(%rax)
pushq $0xa
popq %rcx
movq %rdi, %rax
xorl %edx, %edx
divq %rcx
orb $0x30, %dl
movq (%rsi), %r8
leaq -0x1(%r8), %r9
movq %r9, (%rsi)
movb %dl, -0x1(%r8)
cmpq $0x9, %rdi
movq %rax, %rdi
ja 0x76df7
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::valueToString[abi:cxx11](double, bool, unsigned int)
std::string valueToString(double value, bool useSpecialFloats, unsigned int precision) {
  // Allocate a buffer that is more than large enough to store the 16 digits of
  // precision requested below.
  char buffer[32];
  int len = -1;

  char formatString[16];
  snprintf(formatString, sizeof(formatString), "%%.%dg", precision);

  // Print into the buffer. We need not request the alternative representation
  // that always has a decimal point because JSON doesn't distingish the
  // concepts of reals and integers.
  if (isfinite(value)) {
    len = snprintf(buffer, sizeof(buffer), formatString, value);
  } else {
    // IEEE standard states that NaN values will not compare to themselves
    if (value != value) {
      len = snprintf(buffer, sizeof(buffer), useSpecialFloats ? "NaN" : "null");
    } else if (value < 0) {
      len = snprintf(buffer, sizeof(buffer), useSpecialFloats ? "-Infinity" : "-1e+9999");
    } else {
      len = snprintf(buffer, sizeof(buffer), useSpecialFloats ? "Infinity" : "1e+9999");
    }
    // For those, we do not need to call fixNumLoc, but it is fast.
  }
  assert(len >= 0);
  fixNumericLocale(buffer, buffer + len);
  return buffer;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ecx
movl %esi, %ebp
movq %rdi, %rbx
movq %xmm0, 0x8(%rsp)
movq %xmm0, %r14
leaq 0x35ac3(%rip), %rdx     # 0xac91f
leaq 0x30(%rsp), %rdi
pushq $0x10
popq %rsi
xorl %eax, %eax
callq 0x119b0
btrq $0x3f, %r14
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rax, %r14
jle 0x76ea9
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm1
jp 0x76f27
pxor %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x76ec5
leaq 0x35a8f(%rip), %rax     # 0xac92f
leaq 0x35a92(%rip), %rdx     # 0xac939
jmp 0x76ed3
leaq 0x10(%rsp), %rdi
pushq $0x20
popq %rsi
leaq 0x30(%rsp), %rdx
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x119b0
jmp 0x76ee9
leaq 0x35a64(%rip), %rax     # 0xac930
leaq 0x35a67(%rip), %rdx     # 0xac93a
testb %bpl, %bpl
cmovneq %rax, %rdx
leaq 0x10(%rsp), %rdi
pushq $0x20
popq %rsi
xorl %eax, %eax
callq 0x119b0
cltq
addq %rsp, %rax
addq $0x10, %rax
leaq 0x10(%rsp), %rcx
cmpq %rax, %rcx
jae 0x76f09
cmpb $0x2c, (%rcx)
jne 0x76f04
movb $0x2e, (%rcx)
incq %rcx
jmp 0x76ef7
leaq 0x10(%rsp), %rsi
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x196d0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x359f8(%rip), %rax     # 0xac926
leaq 0x359f5(%rip), %rdx     # 0xac92a
jmp 0x76ed3
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::FastWriter::write[abi:cxx11](Json::Value const&)
std::string FastWriter::write(const Value& root) {
  document_ = "";
  writeValue(root);
  if (!omitEndingLineFeed_)
    document_ += "\n";
  return document_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsi), %r14
leaq 0x32318(%rip), %rsi     # 0xa9564
movq %r14, %rdi
callq 0x11b80
movq %r12, %rdi
movq %r15, %rsi
callq 0x77290
cmpb $0x0, 0x2a(%r12)
jne 0x77276
leaq 0x37844(%rip), %rsi     # 0xaeab2
movq %r14, %rdi
callq 0x11b70
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11850
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StyledWriter::pushValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void StyledWriter::pushValue(const std::string& value) {
  if (addChildValues_)
    childValues_.push_back(value);
  else
    document_ += value;
}

// Assembly:
cmpb $0x1, 0x68(%rdi)
jne 0x77d2d
addq $0x8, %rdi
jmp 0x7a308
addq $0x20, %rdi
jmp 0x11bd0
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StyledWriter::isMultineArray(Json::Value const&)
bool StyledWriter::isMultineArray(const Value& value) {
  ArrayIndex const size = value.size();
  bool isMultiLine = size * 3 >= rightMargin_;
  childValues_.clear();
  for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
    const Value& childValue = value[index];
    isMultiLine = ((childValue.isArray() || childValue.isObject()) &&
                        childValue.size() > 0);
  }
  if (!isMultiLine) // check if line length > max line length
  {
    childValues_.reserve(size);
    addChildValues_ = true;
    ArrayIndex lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]'
    for (ArrayIndex index = 0; index < size; ++index) {
      if (hasCommentForValue(value[index])) {
        isMultiLine = true;
      }
      writeValue(value[index]);
      lineLength += static_cast<ArrayIndex>(childValues_[index].length());
    }
    addChildValues_ = false;
    isMultiLine = isMultiLine || lineLength >= rightMargin_;
  }
  return isMultiLine;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x73cc6
movl %eax, %r15d
leal (%r15,%r15,2), %eax
cmpl 0x60(%rbx), %eax
setae %r13b
leaq 0x8(%rbx), %rbp
movq %rbp, %rdi
callq 0x7a300
xorl %r12d, %r12d
cmpl %r15d, %r12d
jae 0x7805a
testb $0x1, %r13b
jne 0x7805a
movq %r14, %rdi
movl %r12d, %esi
callq 0x75d38
movzwl 0x8(%rax), %ecx
andl $0xfe, %ecx
cmpw $0x6, %cx
jne 0x78052
movq %rax, %rdi
callq 0x73cc6
testl %eax, %eax
setne %r13b
jmp 0x78055
xorl %r13d, %r13d
incl %r12d
jmp 0x7801c
movb $0x1, %r12b
testb $0x1, %r13b
jne 0x780d8
movl %r15d, %esi
movq %rbp, %rdi
movq %rsi, (%rsp)
callq 0x7a1f0
movb $0x1, 0x68(%rbx)
leal 0x2(,%r15,2), %ebp
pushq $0x8
popq %r13
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r15, (%rsp)
je 0x780cb
movq %r14, %rdi
movl %r15d, %esi
callq 0x75d38
movq %rax, %rsi
callq 0x7813e
orb %al, %r12b
movq %r14, %rdi
movl %r15d, %esi
callq 0x75d38
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7792e
movq 0x8(%rbx), %rax
addl (%rax,%r13), %ebp
incq %r15
addq $0x20, %r13
jmp 0x78088
movb $0x0, 0x68(%rbx)
cmpl 0x60(%rbx), %ebp
setae %al
orb %al, %r12b
andb $0x1, %r12b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StyledWriter::writeIndent()
void StyledWriter::writeIndent() {
  if (!document_.empty()) {
    char last = document_[document_.length() - 1];
    if (last == ' ') // already indented
      return;
    if (last != '\n') // Comments may add new-line
      document_ += '\n';
  }
  document_ += indentString_;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x78127
movq (%r14), %rcx
movzbl -0x1(%rcx,%rax), %eax
cmpl $0xa, %eax
je 0x78127
cmpl $0x20, %eax
jne 0x7811c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x114e0
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11bd0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::StyledStreamWriter::write(std::ostream&, Json::Value const&)
void StyledStreamWriter::write(std::ostream& out, const Value& root) {
  document_ = &out;
  addChildValues_ = false;
  indentString_ = "";
  indented_ = true;
  writeCommentBeforeValue(root);
  if (!indented_) writeIndent();
  indented_ = true;
  writeValue(root);
  writeCommentAfterValueOnSameLine(root);
  *document_ << "\n";
  document_ = NULL; // Forget the stream, for safety.
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, 0x18(%rdi)
andb $-0x2, 0x68(%rdi)
addq $0x20, %rdi
leaq 0x31387(%rip), %rsi     # 0xa9564
callq 0x11b80
orb $0x2, 0x68(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7823c
movb 0x68(%rbx), %al
testb $0x2, %al
jne 0x78203
movq %rbx, %rdi
callq 0x782fe
movb 0x68(%rbx), %al
orb $0x2, %al
movb %al, 0x68(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7831e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x78624
movq 0x18(%rbx), %rdi
leaq 0x36889(%rip), %rsi     # 0xaeab2
callq 0x115a0
andq $0x0, 0x18(%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::StyledStreamWriter::writeCommentAfterValueOnSameLine(Json::Value const&)
void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root) {
  if (root.hasComment(commentAfterOnSameLine))
    *document_ << ' ' << root.getComment(commentAfterOnSameLine);

  if (root.hasComment(commentAfter)) {
    writeIndent();
    *document_ << root.getComment(commentAfter);
  }
  indented_ = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x786c4
movq %rsi, %r14
cmpq $0x0, 0x8(%rax)
je 0x78689
movq 0x18(%rbx), %rdi
pushq $0x20
popq %rsi
callq 0x116e0
movq %rax, %r15
leaq 0x8(%rsp), %r12
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x7678c
movq %r15, %rdi
movq %r12, %rsi
callq 0x11520
leaq 0x8(%rsp), %rdi
callq 0x11270
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x786c4
cmpq $0x0, 0x10(%rax)
je 0x786c4
movq %rbx, %rdi
callq 0x782fe
movq 0x18(%rbx), %r15
leaq 0x8(%rsp), %r12
pushq $0x2
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x7678c
movq %r15, %rdi
movq %r12, %rsi
callq 0x11520
leaq 0x8(%rsp), %rdi
callq 0x11270
andb $-0x3, 0x68(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x786d6
movq %rax, %rbx
leaq 0x8(%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::BuiltStyledStreamWriter::write(Json::Value const&, std::ostream*)
int BuiltStyledStreamWriter::write(Value const& root, std::ostream* sout)
{
  sout_ = sout;
  addChildValues_ = false;
  indented_ = true;
  indentString_ = "";
  writeCommentBeforeValue(root);
  if (!indented_) writeIndent();
  indented_ = true;
  writeValue(root);
  writeCommentAfterValueOnSameLine(root);
  *sout_ << endingLineFeedSymbol_;
  sout_ = NULL;
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x8(%rdi)
movb 0xd8(%rdi), %al
andb $-0x4, %al
orb $0x2, %al
movb %al, 0xd8(%rdi)
addq $0x28, %rdi
leaq 0x30985(%rip), %rsi     # 0xa9564
callq 0x11b80
movq %rbx, %rdi
movq %r14, %rsi
callq 0x78c44
movb 0xd8(%rbx), %al
testb $0x2, %al
jne 0x78c07
movq %rbx, %rdi
callq 0x78d16
movb 0xd8(%rbx), %al
orb $0x2, %al
movb %al, 0xd8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x78d3e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7904e
movq 0x8(%rbx), %rdi
leaq 0xb8(%rbx), %rsi
callq 0x11520
andq $0x0, 0x8(%rbx)
xorl %eax, %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::BuiltStyledStreamWriter::writeCommentBeforeValue(Json::Value const&)
void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
  if (cs_ == CommentStyle::None) return;
  if (!root.hasComment(commentBefore))
    return;

  if (!indented_) writeIndent();
  const std::string& comment = root.getComment(commentBefore);
  std::string::const_iterator iter = comment.begin();
  while (iter != comment.end()) {
    *sout_ << *iter;
    if (*iter == '\n' &&
       (iter != comment.end() && *(iter + 1) == '/'))
      // writeIndent();  // would write extra newline
      *sout_ << indentString_;
    ++iter;
  }
  indented_ = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpl $0x0, 0x70(%rdi)
je 0x78cf8
movq %rsi, %r14
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x78cf8
cmpq $0x0, (%rax)
je 0x78cf8
movq %rdi, %rbx
testb $0x2, 0xd8(%rdi)
jne 0x78c85
movq %rbx, %rdi
callq 0x78d16
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7678c
movq (%r15), %rax
leaq 0x28(%rbx), %r14
movq %rax, %r15
addq 0x8(%rsp), %rax
cmpq %rax, %r15
je 0x78ce9
movq 0x8(%rbx), %rdi
movsbl (%r15), %esi
callq 0x116e0
movq (%rsp), %rax
cmpb $0xa, (%r15)
jne 0x78ce4
movq 0x8(%rsp), %rcx
addq %rax, %rcx
cmpq %rcx, %r15
je 0x78ce4
cmpb $0x2f, 0x1(%r15)
jne 0x78ce4
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x11520
movq (%rsp), %rax
incq %r15
jmp 0x78c9f
andb $-0x3, 0xd8(%rbx)
movq %rsp, %rdi
callq 0x11270
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %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::BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(Json::Value const&)
void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(Value const& root) {
  if (cs_ == CommentStyle::None) return;
  if (root.hasComment(commentAfterOnSameLine))
    *sout_ << " " + root.getComment(commentAfterOnSameLine);

  if (root.hasComment(commentAfter)) {
    writeIndent();
    *sout_ << root.getComment(commentAfter);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x0, 0x70(%rdi)
je 0x7910d
movq %rsi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x7910d
movq %rdi, %r14
cmpq $0x0, 0x8(%rax)
je 0x790d2
movq 0x8(%r14), %r15
leaq 0x28(%rsp), %r12
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7678c
leaq 0x304f9(%rip), %rsi     # 0xa9594
leaq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0x79e4e
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x11520
leaq 0x8(%rsp), %rdi
callq 0x11270
leaq 0x28(%rsp), %rdi
callq 0x11270
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x7910d
cmpq $0x0, 0x10(%rax)
je 0x7910d
movq %r14, %rdi
callq 0x78d16
movq 0x8(%r14), %r14
leaq 0x8(%rsp), %r15
pushq $0x2
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7678c
movq %r14, %rdi
movq %r15, %rsi
callq 0x11520
leaq 0x8(%rsp), %rdi
callq 0x11270
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x7913a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
jmp 0x79135
movq %rax, %rbx
leaq 0x28(%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::StreamWriterBuilder::setDefaults(Json::Value*)
void StreamWriterBuilder::setDefaults(Json::Value* settings)
{
  //! [StreamWriterBuilderDefaults]
  (*settings)["commentStyle"] = "All";
  (*settings)["indentation"] = "\t";
  (*settings)["enableYAMLCompatibility"] = false;
  (*settings)["dropNullPlaceholders"] = false;
  (*settings)["useSpecialFloats"] = false;
  (*settings)["precision"] = 17;
  //! [StreamWriterBuilderDefaults]
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq 0x33429(%rip), %rsi     # 0xac9d7
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
callq 0x74968
leaq 0x333bd(%rip), %rsi     # 0xac982
movq %rbx, %rdi
callq 0x7402c
leaq 0xd0(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x74c68
movq %r14, %rdi
callq 0x74cb0
leaq 0x2ff74(%rip), %rsi     # 0xa9563
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
callq 0x74968
leaq 0x33370(%rip), %rsi     # 0xac976
movq %rbx, %rdi
callq 0x7402c
leaq 0xa8(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x74c68
movq %r14, %rdi
callq 0x74cb0
movw $0x5, 0x88(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rsp)
andq $0x0, 0xa0(%rsp)
movb $0x0, 0x80(%rsp)
leaq 0x33339(%rip), %rsi     # 0xac98f
movq %rbx, %rdi
callq 0x7402c
leaq 0x80(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x74c68
movq %r14, %rdi
callq 0x74cb0
movw $0x5, 0x60(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rsp)
andq $0x0, 0x78(%rsp)
movb $0x0, 0x58(%rsp)
leaq 0x3330d(%rip), %rsi     # 0xac9a7
movq %rbx, %rdi
callq 0x7402c
leaq 0x58(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x74c68
movq %r14, %rdi
callq 0x74cb0
movw $0x5, 0x38(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rsp)
andq $0x0, 0x50(%rsp)
movb $0x0, 0x30(%rsp)
leaq 0x332e1(%rip), %rsi     # 0xac9bc
movq %rbx, %rdi
callq 0x7402c
leaq 0x30(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x74c68
movq %r14, %rdi
callq 0x74cb0
movw $0x1, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
andq $0x0, 0x28(%rsp)
movq $0x11, 0x8(%rsp)
leaq 0x332ad(%rip), %rsi     # 0xac9cd
movq %rbx, %rdi
callq 0x7402c
leaq 0x8(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x74c68
movq %rbx, %rdi
callq 0x74cb0
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %r14
jmp 0x7977b
movq %rax, %rbx
leaq 0x30(%rsp), %r14
jmp 0x7977b
movq %rax, %rbx
leaq 0x58(%rsp), %r14
jmp 0x7977b
movq %rax, %rbx
leaq 0x80(%rsp), %r14
jmp 0x7977b
jmp 0x79778
movq %rax, %rbx
movq %r14, %rdi
callq 0x74cb0
movq %rbx, %rdi
callq 0x11a80
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::writeString[abi:cxx11](Json::StreamWriter::Factory const&, Json::Value const&)
std::string writeString(StreamWriter::Factory const& builder, Value const& root) {
  std::ostringstream sout;
  StreamWriterPtr const writer(builder.newStreamWriter());
  writer->write(root, &sout);
  return sout.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11800
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %r14
movq (%rax), %rax
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x119a0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x11180
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x79d84
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x8(%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::ostream&, Json::Value const&)
std::ostream& operator<<(std::ostream& sout, Value const& root) {
  StreamWriterBuilder builder;
  StreamWriterPtr const writer(builder.newStreamWriter());
  writer->write(root, &sout);
  return sout;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x7954e
movq %r14, %rdi
callq 0x797b6
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rsp, %rdi
callq 0x7978c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x79df9
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7978c
movq %rbx, %rdi
callq 0x11a80
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/RNBasics/json.cpp
// Function: Json::OurCharReader::parse(char const*, char const*, Json::Value*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool parse(
      char const* beginDoc, char const* endDoc,
      Value* root, std::string* errs) {
    bool ok = reader_.parse(beginDoc, endDoc, *root, collectComments_);
    if (errs) {
      *errs = reader_.getFormattedErrorMessages();
    }
    return ok;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rdi, %r14
movzbl 0x8(%rdi), %r8d
addq $0x10, %r14
movq %r14, %rdi
callq 0x70e92
movl %eax, %ebp
testq %rbx, %rbx
je 0x7a86b
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x72b88
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11740
movq %r15, %rdi
callq 0x11270
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_37.cc
// Function: main
int main(int argc, char const *argv[])
{
	int a = 1;
	long b = 2;
	// std::cout << std::max(a, b) << std::endl;
	std::cout << std::max<long>(a, b) << std::endl;

	// std::cout << std::max<int>(a, b) << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2e21(%rip), %rdi      # 0x3fd8
pushq $0x2
popq %rsi
callq 0x1050
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbp
retq