LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::operator[](char const*) const
const Value& Value::operator[](const char* key) const {
  Value const* found = find(key, key + strlen(key));
  if (!found)
    return nullSingleton();
  return *found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x92e0
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq %rax, %rdx
callq 0x22f60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x231db
callq 0x1d3c0
movq %rax, -0x8(%rbp)
jmp 0x231e3
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
Value const& Value::operator[](JSONCPP_STRING const& key) const {
  Value const* found = find(key.data(), key.data() + key.length());
  if (!found)
    return nullSingleton();
  return *found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x99b0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x99b0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9b00
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq %rax, %rdx
callq 0x22f60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x23255
callq 0x1d3c0
movq %rax, -0x8(%rbp)
jmp 0x2325d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::removeMember(char const*, char const*, Json::Value*)
bool Value::removeMember(const char* begin, const char* end, Value* removed) {
  if (type_ != objectValue) {
    return false;
  }
  CZString actualKey(begin, static_cast<unsigned>(end - begin),
                     CZString::noDuplication);
  ObjectValues::iterator it = value_.map_->find(actualKey);
  if (it == value_.map_->end())
    return false;
  if (removed)
#if JSON_HAS_RVALUE_REFERENCES
    *removed = std::move(it->second);
#else
    *removed = it->second;
#endif
  value_.map_->erase(it);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x7, %eax
je 0x2361f
movb $0x0, -0x1(%rbp)
jmp 0x23765
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
movl %esi, %eax
subl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
xorl %ecx, %ecx
callq 0x1e110
movq -0xa0(%rbp), %rax
movq -0xb0(%rbp), %rsi
movq (%rax), %rdi
callq 0x259e0
movq %rax, -0xa8(%rbp)
jmp 0x2365b
movq -0xa0(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq (%rax), %rdi
callq 0x257e0
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x254c0
testb $0x1, %al
jne 0x2368c
jmp 0x236ad
movb $0x0, -0x1(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0x2374f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2375a
cmpq $0x0, -0x28(%rbp)
je 0x2370c
leaq -0x40(%rbp), %rdi
callq 0x25410
movq %rax, %rsi
addq $0x10, %rsi
leaq -0x88(%rbp), %rdi
callq 0x1efa0
jmp 0x236d2
movq -0x28(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1f1b0
jmp 0x236e4
leaq -0x88(%rbp), %rdi
callq 0x1f050
jmp 0x2370c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1f050
jmp 0x2375a
movq -0xa0(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rsi
callq 0x25a90
movq %rax, -0xb8(%rbp)
jmp 0x23736
movq -0xb8(%rbp), %rax
movq %rax, -0x98(%rbp)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1e280
jmp 0x23765
leaq -0x38(%rbp), %rdi
callq 0x1e280
jmp 0x23773
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::removeMember(char const*)
void Value::removeMember(const char* key) {
  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
                      "in Json::Value::removeMember(): requires objectValue");
  if (type_ == nullValue)
    return;

  CZString actualKey(key, unsigned(strlen(key)), CZString::noDuplication);
  value_.map_->erase(actualKey);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x2391b
movq -0x1d0(%rbp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x7, %eax
je 0x2391b
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x9a00
movq -0x1d8(%rbp), %rdi
leaq 0x98c5b(%rip), %rsi     # 0xbc509
callq 0x9760
jmp 0x238b5
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x9790
jmp 0x238ca
leaq -0x1b8(%rbp), %rdi
callq 0x1ddc0
jmp 0x238d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x2390a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x9480
leaq -0x188(%rbp), %rdi
callq 0x91d0
jmp 0x239ad
movq -0x1d0(%rbp), %rax
movw 0x8(%rax), %ax
andw $0xff, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x23934
jmp 0x23986
movq -0x10(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x92e0
movq -0x1e8(%rbp), %rsi
movl %eax, %edx
leaq -0x1c8(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
xorl %ecx, %ecx
callq 0x1e110
movq -0x1d0(%rbp), %rax
movq -0x1e0(%rbp), %rsi
movq (%rax), %rdi
callq 0x258b0
jmp 0x2397a
leaq -0x1c8(%rbp), %rdi
callq 0x1e280
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x1e280
movq -0x190(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::isIntegral() const
bool Value::isIntegral() const {
  switch (type_) {
  case intValue:
  case uintValue:
    return true;
  case realValue:
#if defined(JSON_HAS_INT64)
    // 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_ >= double(minInt64) &&
           value_.real_ < maxUInt64AsDouble && IsIntegral(value_.real_);
#else
    return value_.real_ >= minInt && value_.real_ <= maxUInt &&
           IsIntegral(value_.real_);
#endif // JSON_HAS_INT64
  default:
    break;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzbl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
decl %eax
subl $0x2, %eax
jb 0x241be
jmp 0x241b4
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x241c4
jmp 0x24210
movb $0x1, -0x1(%rbp)
jmp 0x24216
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
xorl %eax, %eax
movsd 0x97c72(%rip), %xmm1    # 0xbbe48
ucomisd %xmm1, %xmm0
movb %al, -0x21(%rbp)
jb 0x24206
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movsd 0x97c6b(%rip), %xmm0    # 0xbbe58
ucomisd (%rcx), %xmm0
movb %al, -0x21(%rbp)
jbe 0x24206
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
callq 0x24150
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x24216
jmp 0x24212
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x24390
movl $0x20, %edi
callq 0x9040
movq %rax, -0x58(%rbp)
movq $0x3, (%rax)
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1de20
jmp 0x24325
movq -0x48(%rbp), %rcx
movq -0x60(%rbp), %rax
addq $0x8, %rax
cmpq %rcx, %rax
movq %rax, -0x40(%rbp)
jne 0x24316
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x24390
movq -0x50(%rbp), %rcx
movq %rax, %rsi
movq -0x60(%rbp), %rax
movq %rsi, -0x28(%rbp)
movl %edx, -0x2c(%rbp)
cmpq %rax, %rcx
movq %rax, -0x68(%rbp)
je 0x24385
movq -0x68(%rbp), %rdi
addq $-0x8, %rdi
movq %rdi, -0x70(%rbp)
callq 0x1de40
movq -0x50(%rbp), %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x68(%rbp)
jne 0x24363
movq -0x58(%rbp), %rdi
callq 0x99a0
jmp 0x243dd
cmpq $0x0, -0x18(%rbp)
jbe 0x243b8
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x243b8
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x1c(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1dea0
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x9d20
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::toStyledString[abi:cxx11]() const
JSONCPP_STRING Value::toStyledString() const {
  StreamWriterBuilder builder;

  JSONCPP_STRING out = this->hasComment(commentBefore) ? "\n" : "";
  out += Json::writeString(builder, *this);
  out += '\n';

  return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2fcc0
movq -0x98(%rbp), %rdi
movb $0x0, -0x41(%rbp)
xorl %esi, %esi
callq 0x24490
movb %al, %dl
leaq 0xa5560(%rip), %rcx     # 0xc9bf3
leaq 0x9866d(%rip), %rax     # 0xbcd07
testb %dl, %dl
cmovneq %rcx, %rax
movq %rax, -0x88(%rbp)
leaq -0x42(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x9d30
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
callq 0x9a30
jmp 0x246cd
leaq -0x42(%rbp), %rdi
callq 0x97e0
movq -0x98(%rbp), %rdx
leaq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x30e50
jmp 0x246ec
movq -0x90(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x9980
jmp 0x246fe
leaq -0x78(%rbp), %rdi
callq 0x9480
movq -0x90(%rbp), %rdi
movl $0xa, %esi
callq 0x9490
jmp 0x2471a
movb $0x1, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x2476e
jmp 0x24762
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x42(%rbp), %rdi
callq 0x97e0
jmp 0x24793
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x24787
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x9480
jmp 0x24787
movq -0x90(%rbp), %rdi
callq 0x9480
leaq -0x40(%rbp), %rdi
callq 0x30020
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x9480
leaq -0x40(%rbp), %rdi
callq 0x30020
movq -0x50(%rbp), %rdi
callq 0x9d20
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::end()
Value::iterator Value::end() {
  switch (type_) {
  case arrayValue:
  case objectValue:
    if (value_.map_)
      return iterator(value_.map_->end());
    break;
  default:
    break;
  }
  return iterator();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzbl 0x8(%rax), %eax
addl $-0x6, %eax
subl $0x1, %eax
ja 0x2496c
jmp 0x24941
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2496a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x257e0
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x1dad0
jmp 0x24977
jmp 0x2496e
jmp 0x2496e
movq -0x30(%rbp), %rdi
callq 0x1dab0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.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 JSONCPP_STRING& path,
           const PathArgument& a1,
           const PathArgument& a2,
           const PathArgument& a3,
           const PathArgument& a4,
           const PathArgument& a5) {
  InArgs in;
  in.reserve(5);
  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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
callq 0x25d90
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x25db0
movq -0x88(%rbp), %rdi
movl $0x5, %esi
callq 0x25dd0
jmp 0x24b84
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x25ed0
jmp 0x24b9b
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x25ed0
jmp 0x24bb2
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x25ed0
jmp 0x24bc9
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x25ed0
jmp 0x24be0
movq 0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x25ed0
jmp 0x24bf7
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x24c50
jmp 0x24c0d
leaq -0x48(%rbp), %rdi
callq 0x25f00
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x25f00
movq -0x98(%rbp), %rdi
callq 0x25f60
movq -0x50(%rbp), %rdi
callq 0x9d20
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Path::addPathInArg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Json::PathArgument const*, std::allocator<Json::PathArgument const*>> const&, __gnu_cxx::__normal_iterator<Json::PathArgument const* const*, std::vector<Json::PathArgument const*, std::allocator<Json::PathArgument const*>>>&, Json::PathArgument::Kind)
void Path::addPathInArg(const JSONCPP_STRING& /*path*/,
                        const InArgs& in,
                        InArgs::const_iterator& itInArg,
                        PathArgument::Kind kind) {
  if (itInArg == in.end()) {
    // Error: missing argument %d
  } else if ((*itInArg)->kind_ != kind) {
    // Error: bad argument type
  } else {
    args_.push_back(**itInArg++);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x26080
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x26040
testb $0x1, %al
jne 0x2504c
jmp 0x2504e
jmp 0x2508a
movq -0x20(%rbp), %rdi
callq 0x260b0
movq (%rax), %rax
movl 0x24(%rax), %eax
cmpl -0x24(%rbp), %eax
je 0x25064
jmp 0x25088
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x26140
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x260b0
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x260d0
jmp 0x2508a
addq $0x50, %rsp
popq %rbp
retq
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::valueToString[abi:cxx11](unsigned long)
JSONCPP_STRING valueToString(LargestUInt value) {
  UIntToStringBuffer buffer;
  char* current = buffer + sizeof(buffer);
  uintToString(value, current);
  assert(current >= buffer);
  return current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
addq $0x19, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2ad70
movq -0x38(%rbp), %rax
leaq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jb 0x2ae23
jmp 0x2ae42
leaq 0x91bb7(%rip), %rdi     # 0xbc9e1
leaq 0x91bc2(%rip), %rsi     # 0xbc9f3
movl $0x71, %edx
leaq 0x91bfc(%rip), %rcx     # 0xbca39
callq 0x94e0
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x9d30
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x9a30
jmp 0x2ae6a
leaq -0x39(%rbp), %rdi
callq 0x97e0
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x97e0
movq -0x48(%rbp), %rdi
callq 0x9d20
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::FastWriter::write[abi:cxx11](Json::Value const&)
JSONCPP_STRING FastWriter::write(const Value& root) {
  document_.clear();
  writeValue(root);
  if (!omitEndingLineFeed_)
    document_ += '\n';
  return document_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
callq 0x99d0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2bb10
movq -0x20(%rbp), %rax
testb $0x1, 0x2a(%rax)
jne 0x2bae9
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movl $0xa, %esi
callq 0x9490
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x92d0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::StyledWriter::write[abi:cxx11](Json::Value const&)
JSONCPP_STRING StyledWriter::write(const Value& root) {
  document_.clear();
  addChildValues_ = false;
  indentString_.clear();
  writeCommentBeforeValue(root);
  writeValue(root);
  writeCommentAfterValueOnSameLine(root);
  document_ += '\n';
  return document_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x20, %rdi
callq 0x99d0
movq -0x30(%rbp), %rdi
movb $0x0, 0x68(%rdi)
addq $0x40, %rdi
callq 0x99d0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c150
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c2f0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2ca40
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movl $0xa, %esi
callq 0x9490
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x20, %rsi
callq 0x92d0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::StyledWriter::writeCommentBeforeValue(Json::Value const&)
void StyledWriter::writeCommentBeforeValue(const Value& root) {
  if (!root.hasComment(commentBefore))
    return;

  document_ += '\n';
  writeIndent();
  const JSONCPP_STRING& comment = root.getComment(commentBefore);
  JSONCPP_STRING::const_iterator iter = comment.begin();
  while (iter != comment.end()) {
    document_ += *iter;
    if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
      writeIndent();
    ++iter;
  }

  // Comments are stripped of trailing newlines, so add one here
  document_ += '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x24490
testb $0x1, %al
jne 0x2c17f
jmp 0x2c2d1
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
movl $0xa, %esi
callq 0x9490
movq -0x78(%rbp), %rdi
callq 0x2d2c0
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0x244d0
leaq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9730
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9e10
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x31620
testb $0x1, %al
jne 0x2c1e1
jmp 0x2c2b4
leaq -0x40(%rbp), %rdi
callq 0x31660
movq -0x78(%rbp), %rdi
movsbl (%rax), %esi
addq $0x20, %rdi
callq 0x9490
jmp 0x2c1fc
leaq -0x40(%rbp), %rdi
callq 0x31660
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x79(%rbp)
jne 0x2c279
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x31680
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9e10
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x31620
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x7a(%rbp)
jne 0x2c24c
jmp 0x2c273
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x31680
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x31660
movsbl (%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x7a(%rbp)
movb -0x7a(%rbp), %al
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x2c282
jmp 0x2c2a6
movq -0x78(%rbp), %rdi
callq 0x2d2c0
jmp 0x2c28d
jmp 0x2c2a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9480
jmp 0x2c2da
leaq -0x40(%rbp), %rdi
callq 0x316c0
jmp 0x2c1be
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
movl $0xa, %esi
callq 0x9490
jmp 0x2c2c8
leaq -0x38(%rbp), %rdi
callq 0x9480
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x9d20
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::StyledWriter::pushValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void StyledWriter::pushValue(const JSONCPP_STRING& value) {
  if (addChildValues_)
    childValues_.push_back(value);
  else
    document_ += value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x68(%rax)
je 0x2cbe1
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x315b0
jmp 0x2cbf2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rdi
callq 0x9980
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::StyledStreamWriter::write(std::ostream&, Json::Value const&)
void StyledStreamWriter::write(JSONCPP_OSTREAM& out, const Value& root) {
  document_ = &out;
  addChildValues_ = false;
  indentString_.clear();
  indented_ = true;
  writeCommentBeforeValue(root);
  if (!indented_)
    writeIndent();
  indented_ = true;
  writeValue(root);
  writeCommentAfterValueOnSameLine(root);
  *document_ << "\n";
  document_ = NULL; // Forget the stream, for safety.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x18(%rdi)
movb 0x68(%rdi), %al
andb $-0x2, %al
orb $0x0, %al
movb %al, 0x68(%rdi)
addq $0x20, %rdi
callq 0x99d0
movq -0x20(%rbp), %rdi
movb 0x68(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0x68(%rdi)
movq -0x18(%rbp), %rsi
callq 0x2d500
movq -0x20(%rbp), %rax
movb 0x68(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0x2d4b6
movq -0x20(%rbp), %rdi
callq 0x2d6b0
movq -0x20(%rbp), %rdi
movb 0x68(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0x68(%rdi)
movq -0x18(%rbp), %rsi
callq 0x2d6f0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2de40
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x9c70a(%rip), %rsi     # 0xc9bf3
callq 0x9760
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::StyledStreamWriter::writeCommentBeforeValue(Json::Value const&)
void StyledStreamWriter::writeCommentBeforeValue(const Value& root) {
  if (!root.hasComment(commentBefore))
    return;

  if (!indented_)
    writeIndent();
  const JSONCPP_STRING& comment = root.getComment(commentBefore);
  JSONCPP_STRING::const_iterator iter = comment.begin();
  while (iter != comment.end()) {
    *document_ << *iter;
    if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
      // writeIndent();  // would include newline
      *document_ << indentString_;
    ++iter;
  }
  indented_ = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x24490
testb $0x1, %al
jne 0x2d52f
jmp 0x2d69c
movq -0x78(%rbp), %rax
movb 0x68(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0x2d547
movq -0x78(%rbp), %rdi
callq 0x2d6b0
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0x244d0
leaq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9730
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9e10
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x31620
testb $0x1, %al
jne 0x2d58e
jmp 0x2d683
movq -0x78(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31660
movq -0x80(%rbp), %rdi
movsbl (%rax), %esi
callq 0x98a0
jmp 0x2d5b1
leaq -0x40(%rbp), %rdi
callq 0x31660
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x81(%rbp)
jne 0x2d63d
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x31680
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9e10
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x31620
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x82(%rbp)
jne 0x2d607
jmp 0x2d631
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x31680
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x31660
movsbl (%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x82(%rbp)
movb -0x82(%rbp), %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x2d649
jmp 0x2d675
movq -0x78(%rbp), %rsi
movq 0x18(%rsi), %rdi
addq $0x20, %rsi
callq 0x9690
jmp 0x2d65c
jmp 0x2d675
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9480
jmp 0x2d6a5
leaq -0x40(%rbp), %rdi
callq 0x316c0
jmp 0x2d56b
movq -0x78(%rbp), %rax
movb 0x68(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x68(%rax)
leaq -0x38(%rbp), %rdi
callq 0x9480
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x9d20
nop
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::StyledStreamWriter::writeWithIndent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void StyledStreamWriter::writeWithIndent(const JSONCPP_STRING& value) {
  if (!indented_)
    writeIndent();
  *document_ << value;
  indented_ = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0x68(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0x2e3dc
movq -0x18(%rbp), %rdi
callq 0x2d6b0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x9690
movq -0x18(%rbp), %rax
movb 0x68(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0x68(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::BuiltStyledStreamWriter::write(Json::Value const&, std::ostream*)
int BuiltStyledStreamWriter::write(Value const& root, JSONCPP_OSTREAM* sout) {
  sout_ = sout;
  addChildValues_ = false;
  indented_ = true;
  indentString_.clear();
  writeCommentBeforeValue(root);
  if (!indented_)
    writeIndent();
  indented_ = true;
  writeValue(root);
  writeCommentAfterValueOnSameLine(root);
  *sout_ << endingLineFeedSymbol_;
  sout_ = NULL;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movb 0xd8(%rdi), %al
andb $-0x2, %al
orb $0x0, %al
movb %al, 0xd8(%rdi)
movb 0xd8(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0xd8(%rdi)
addq $0x28, %rdi
callq 0x99d0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2e9a0
movq -0x20(%rbp), %rax
movb 0xd8(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0x2e945
movq -0x20(%rbp), %rdi
callq 0x2eb70
movq -0x20(%rbp), %rdi
movb 0xd8(%rdi), %al
andb $-0x3, %al
orb $0x2, %al
movb %al, 0xd8(%rdi)
movq -0x10(%rbp), %rsi
callq 0x2ebc0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2f2c0
movq -0x20(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0xb8, %rsi
callq 0x9690
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_writer.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 JSONCPP_STRING& comment = root.getComment(commentBefore);
  JSONCPP_STRING::const_iterator iter = comment.begin();
  while (iter != comment.end()) {
    *sout_ << *iter;
    if (*iter == '\n' && ((iter + 1) != comment.end() && *(iter + 1) == '/'))
      // writeIndent();  // would write extra newline
      *sout_ << indentString_;
    ++iter;
  }
  indented_ = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpl $0x0, 0x70(%rax)
jne 0x2e9c6
jmp 0x2eb50
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x24490
testb $0x1, %al
jne 0x2e9da
jmp 0x2eb50
movq -0x78(%rbp), %rax
movb 0xd8(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0x2e9f5
movq -0x78(%rbp), %rdi
callq 0x2eb70
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0x244d0
leaq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9730
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9e10
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x31620
testb $0x1, %al
jne 0x2ea3c
jmp 0x2eb31
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31660
movq -0x80(%rbp), %rdi
movsbl (%rax), %esi
callq 0x98a0
jmp 0x2ea5f
leaq -0x40(%rbp), %rdi
callq 0x31660
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x81(%rbp)
jne 0x2eaeb
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x31680
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9e10
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x31620
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x82(%rbp)
jne 0x2eab5
jmp 0x2eadf
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x31680
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x31660
movsbl (%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x82(%rbp)
movb -0x82(%rbp), %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x2eaf7
jmp 0x2eb23
movq -0x78(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0x28, %rsi
callq 0x9690
jmp 0x2eb0a
jmp 0x2eb23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9480
jmp 0x2eb59
leaq -0x40(%rbp), %rdi
callq 0x316c0
jmp 0x2ea19
movq -0x78(%rbp), %rax
movb 0xd8(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0xd8(%rax)
leaq -0x38(%rbp), %rdi
callq 0x9480
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x9d20
nopw %cs:(%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_writer.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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpl $0x0, 0x70(%rax)
jne 0x2f2e9
jmp 0x2f41d
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x24490
testb $0x1, %al
jne 0x2f300
jmp 0x2f39b
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movl $0x1, %edx
callq 0x244d0
movq -0x90(%rbp), %rdx
leaq 0x98e4a(%rip), %rsi     # 0xc8183
leaq -0x30(%rbp), %rdi
callq 0x14630
jmp 0x2f344
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9690
jmp 0x2f356
leaq -0x30(%rbp), %rdi
callq 0x9480
leaq -0x50(%rbp), %rdi
callq 0x9480
jmp 0x2f39b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2f38d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9480
leaq -0x50(%rbp), %rdi
callq 0x9480
jmp 0x2f426
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x24490
testb $0x1, %al
jne 0x2f3af
jmp 0x2f41d
movq -0x88(%rbp), %rdi
callq 0x2eb70
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl $0x2, %edx
callq 0x244d0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x9690
jmp 0x2f3fb
leaq -0x80(%rbp), %rdi
callq 0x9480
jmp 0x2f41d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9480
jmp 0x2f426
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x9d20
nop
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::BuiltStyledStreamWriter::pushValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void BuiltStyledStreamWriter::pushValue(JSONCPP_STRING const& value) {
  if (addChildValues_)
    childValues_.push_back(value);
  else
    *sout_ << value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0xd8(%rax), %al
andb $0x1, %al
testb $0x1, %al
je 0x2f467
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x315b0
jmp 0x2f478
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x9690
addq $0x20, %rsp
popq %rbp
retq
nop
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::BuiltStyledStreamWriter::writeWithIndent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void BuiltStyledStreamWriter::writeWithIndent(JSONCPP_STRING const& value) {
  if (!indented_)
    writeIndent();
  *sout_ << value;
  indented_ = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0xd8(%rax), %al
shrb %al
andb $0x1, %al
testb $0x1, %al
jne 0x2f96f
movq -0x18(%rbp), %rdi
callq 0x2eb70
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x9690
movq -0x18(%rbp), %rax
movb 0xd8(%rax), %cl
andb $-0x3, %cl
orb $0x0, %cl
movb %cl, 0xd8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::writeString[abi:cxx11](Json::StreamWriter::Factory const&, Json::Value const&)
JSONCPP_STRING writeString(StreamWriter::Factory const& factory,
                           Value const& root) {
  JSONCPP_OSTRINGSTREAM sout;
  StreamWriterPtr const writer(factory.newStreamWriter());
  writer->write(root, &sout);
  return sout.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x9a00
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x1b0(%rbp)
jmp 0x30e9a
movq -0x1b0(%rbp), %rsi
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x31730
movq -0x1c8(%rbp), %rdi
callq 0x31760
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x190(%rbp), %rdx
callq *%rax
jmp 0x30ed9
movq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x9790
jmp 0x30eee
leaq -0x198(%rbp), %rdi
callq 0x31780
leaq -0x190(%rbp), %rdi
callq 0x91d0
movq -0x1b8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x30f48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31780
leaq -0x190(%rbp), %rdi
callq 0x91d0
movq -0x1a0(%rbp), %rdi
callq 0x9d20
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::operator<<(std::ostream&, Json::Value const&)
JSONCPP_OSTREAM& operator<<(JSONCPP_OSTREAM& sout, Value const& root) {
  StreamWriterBuilder builder;
  StreamWriterPtr const writer(builder.newStreamWriter());
  writer->write(root, &sout);
  return sout;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2fcc0
movq -0x68(%rbp), %rdi
callq 0x30090
movq %rax, -0x60(%rbp)
jmp 0x30f8f
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x31730
movq -0x70(%rbp), %rdi
callq 0x31760
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0x30fbf
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31780
leaq -0x40(%rbp), %rdi
callq 0x30020
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x31009
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31780
leaq -0x40(%rbp), %rdi
callq 0x30020
movq -0x50(%rbp), %rdi
callq 0x9d20
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::isAnyCharRequiredQuoting(char const*, unsigned long)
static bool isAnyCharRequiredQuoting(char const* s, size_t n) {
  assert(s || !n);

  char const* const end = s + n;
  for (char const* cur = s; cur < end; ++cur) {
    if (*cur == '\\' || *cur == '\"' || *cur < ' ' ||
        static_cast<unsigned char>(*cur) < 0x80)
      return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
jne 0x31049
cmpq $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x31052
jmp 0x31054
jmp 0x31073
leaq 0x8bd51(%rip), %rdi     # 0xbcdac
leaq 0x8b991(%rip), %rsi     # 0xbc9f3
movl $0xb9, %edx
leaq 0x8bd46(%rip), %rcx     # 0xbcdb4
callq 0x94e0
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x310d9
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0x310c3
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x310c3
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jl 0x310c3
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0x310c9
movb $0x1, -0x1(%rbp)
jmp 0x310dd
jmp 0x310cb
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x31087
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::toHex16Bit[abi:cxx11](unsigned int)
static JSONCPP_STRING toHex16Bit(unsigned int x) {
  const unsigned int hi = (x >> 8) & 0xff;
  const unsigned int lo = x & 0xff;
  JSONCPP_STRING result(4, ' ');
  result[0] = hex2[2 * hi];
  result[1] = hex2[2 * hi + 1];
  result[2] = hex2[2 * lo];
  result[3] = hex2[2 * lo + 1];
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movzbl -0xb(%rbp), %eax
movl %eax, -0x10(%rbp)
movzbl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
leaq -0x16(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x9d30
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rcx
movl $0x4, %esi
movl $0x20, %edx
callq 0x9500
jmp 0x31345
leaq -0x16(%rbp), %rdi
callq 0x97e0
movq -0x38(%rbp), %rdi
movl -0x10(%rbp), %eax
addl %eax, %eax
leaq 0x8b482(%rip), %rcx     # 0xbc7e0
movb (%rax,%rcx), %al
movb %al, -0x49(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x9eb0
movq %rax, -0x48(%rbp)
jmp 0x31373
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rax
movb -0x49(%rbp), %cl
movb %cl, (%rax)
movl -0x10(%rbp), %eax
addl %eax, %eax
leaq 0x8b454(%rip), %rcx     # 0xbc7e0
movb 0x1(%rax,%rcx), %al
movb %al, -0x59(%rbp)
movl $0x1, %esi
callq 0x9eb0
movq %rax, -0x58(%rbp)
jmp 0x313a3
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rax
movb -0x59(%rbp), %cl
movb %cl, (%rax)
movl -0x14(%rbp), %eax
addl %eax, %eax
leaq 0x8b424(%rip), %rcx     # 0xbc7e0
movb (%rax,%rcx), %al
movb %al, -0x69(%rbp)
movl $0x2, %esi
callq 0x9eb0
movq %rax, -0x68(%rbp)
jmp 0x313d2
movq -0x38(%rbp), %rdi
movq -0x68(%rbp), %rax
movb -0x69(%rbp), %cl
movb %cl, (%rax)
movl -0x14(%rbp), %eax
addl %eax, %eax
leaq 0x8b3f5(%rip), %rcx     # 0xbc7e0
movb 0x1(%rax,%rcx), %al
movb %al, -0x79(%rbp)
movl $0x3, %esi
callq 0x9eb0
movq %rax, -0x78(%rbp)
jmp 0x31402
movq -0x78(%rbp), %rax
movb -0x79(%rbp), %cl
movb %cl, (%rax)
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x3144e
jmp 0x31445
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x16(%rbp), %rdi
callq 0x97e0
jmp 0x3145b
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9480
jmp 0x3145b
movq -0x38(%rbp), %rdi
callq 0x9480
movq -0x40(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x9d20
nopw %cs:(%rax,%rax)
nop
// File: DoubleString[P]RtConverter/src/Json/json_tool.h
// Function: _gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> Json::fixNumericLocale<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
Iter fixNumericLocale(Iter begin, Iter end) {
  for (; begin != end; ++begin) {
    if (*begin == ',') {
      *begin = '.';
    }
  }
  return begin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x31b60
testb $0x1, %al
jne 0x31a43
jmp 0x31a6d
leaq -0x10(%rbp), %rdi
callq 0x31a00
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x31a60
leaq -0x10(%rbp), %rdi
callq 0x31a00
movb $0x2e, (%rax)
jmp 0x31a62
leaq -0x10(%rbp), %rdi
callq 0x31ba0
jmp 0x31a30
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: DoubleString[P]RtConverter/src/Json/json_tool.h
// Function: _gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> Json::fixZerosInTheEnd<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
Iter fixZerosInTheEnd(Iter begin, Iter end) {
  for (; begin != end; --end) {
    if (*(end - 1) != '0') {
      return end;
    }
    // Don't delete the last zero before the decimal point.
    if (begin != (end - 1) && *(end - 2) == '.') {
      return end;
    }
  }
  return end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x31b60
testb $0x1, %al
jne 0x31aa6
jmp 0x31b4a
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x31bc0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x31a00
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0x31ad3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x31b52
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x31bc0
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x31b60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x31b00
jmp 0x31b27
leaq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x31bc0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a00
movsbl (%rax), %eax
cmpl $0x2e, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x31b30
jmp 0x31b3a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x31b52
jmp 0x31b3c
leaq -0x18(%rbp), %rdi
callq 0x31c00
jmp 0x31a90
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)