LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpb $0x7, 0x8(%rdi)
jne 0x15883
movq %rcx, %r15
movq %rdi, %r14
subl %esi, %edx
leaq -0x38(%rbp), %rax
movq %rsi, (%rax)
shll $0x2, %edx
movl %edx, 0x8(%rax)
movq (%rdi), %rdi
movq %rax, %rsi
callq 0x1753a
movq %rax, %r12
movq (%r14), %rdi
leaq 0x8(%rdi), %rax
cmpq %rax, %r12
setne %bl
je 0x15868
testq %r15, %r15
je 0x15860
movq %r12, %rsi
addq $0x30, %rsi
leaq -0x60(%rbp), %r13
movq %r13, %rdi
callq 0x130ba
movzwl 0x8(%r15), %eax
movzwl 0x8(%r13), %ecx
movl $0xfe00, %edx           # imm = 0xFE00
movl %eax, %esi
andl %edx, %esi
andl %ecx, %edx
movq (%r15), %rdi
movq (%r13), %r8
movq %r8, (%r15)
movq %rdi, (%r13)
movl $0x1ff, %edi            # imm = 0x1FF
andl %edi, %ecx
orl %esi, %ecx
movw %cx, 0x8(%r15)
andl %edi, %eax
orl %edx, %eax
movw %ax, 0x8(%r13)
movq 0x10(%r15), %rax
movq 0x10(%r13), %rcx
movq %rcx, 0x10(%r15)
movq %rax, 0x10(%r13)
movq 0x18(%r15), %rax
movq 0x18(%r13), %rcx
movq %rcx, 0x18(%r15)
movq %rax, 0x18(%r13)
movq 0x20(%r15), %rax
movq 0x20(%r13), %rcx
movq %rcx, 0x20(%r15)
movq %rax, 0x20(%r13)
movq %r13, %rdi
callq 0x1315e
movq (%r14), %rdi
movq %r12, %rsi
callq 0x17226
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x15885
movl -0x30(%rbp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x15885
callq 0x87a0
jmp 0x15885
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x158b2
movl -0x30(%rbp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x158b2
callq 0x87a0
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movzbl 0x8(%rdi), %eax
testl %eax, %eax
je 0x1597a
cmpl $0x7, %eax
jne 0x15986
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8290
leaq -0x1a8(%rbp), %rsi
movq %r14, (%rsi)
shll $0x2, %eax
movl %eax, 0x8(%rsi)
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0x170f6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x171c2
movq -0x1a8(%rbp), %rdi
testq %rdi, %rdi
je 0x1597a
movl -0x1a0(%rbp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x1597a
callq 0x87a0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x1a8(%rbp), %rbx
movq %rbx, %rdi
callq 0x8860
leaq 0x5464d(%rip), %rsi     # 0x69fe9
movl $0x34, %edx
movq %rbx, %rdi
callq 0x8720
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x89f0
leaq -0x30(%rbp), %rdi
callq 0x125d5
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x159de
callq 0x85d0
jmp 0x159de
jmp 0x159db
movq %rax, %rbx
movq 0x785e3(%rip), %rsi     # 0x8dfc8
leaq -0x1a8(%rbp), %rdi
callq 0x8370
leaq -0x138(%rbp), %rdi
callq 0x8220
jmp 0x15a21
movq %rax, %rbx
movq -0x1a8(%rbp), %rdi
testq %rdi, %rdi
je 0x15a21
movl -0x1a0(%rbp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x15a21
callq 0x87a0
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movzbl 0x8(%rdi), %ecx
movb $0x1, %al
leal -0x1(%rcx), %edx
cmpl $0x2, %edx
jb 0x15f24
cmpl $0x3, %ecx
jne 0x15f25
movsd (%rdi), %xmm0
xorl %eax, %eax
ucomisd 0x53a23(%rip), %xmm0    # 0x69910
jb 0x15f24
movsd 0x53a21(%rip), %xmm1    # 0x69918
ucomisd %xmm0, %xmm1
jbe 0x15f24
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
callq 0x8b50
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %rbx
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
jne 0x15f93
movq %rdi, %r12
movl $0x20, %edi
callq 0x8040
movq $0x3, (%rax)
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movq %rcx, 0x10(%r12)
testq %r15, %r15
je 0x15fa8
leaq -0x1(%r15), %rdx
cmpb $0xa, -0x1(%rbx,%r15)
cmovneq %r15, %rdx
jmp 0x15faa
xorl %edx, %edx
movl %r14d, %eax
leaq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x12676
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x70(%rbp), %rdi
callq 0x1b31e
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x160dd
cmpq $0x0, (%rax)
leaq 0x5380c(%rip), %rax     # 0x698dc
leaq 0x60d41(%rip), %r15     # 0x76e18
cmoveq %rax, %r15
jmp 0x160e4
leaq 0x537f8(%rip), %r15     # 0x698dc
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq %r15, %rdi
callq 0x8290
leaq (%rax,%r15), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1100a
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %r14, %rdx
callq 0x1bd2a
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x81f0
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16134
callq 0x85d0
movq %rbx, %rdi
movl $0xa, %esi
callq 0x8530
leaq -0x70(%rbp), %rdi
callq 0x1b53a
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16173
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16176
callq 0x85d0
jmp 0x16176
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x16188
callq 0x85d0
jmp 0x16188
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x1b53a
movq %r14, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, -0x58(%rbp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq -0x50(%rbp), %rdi
movq %rax, 0x10(%rdi)
movaps %xmm0, (%rdi)
movl $0x5, %esi
callq 0x16ab0
movq %r14, -0x30(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x1635e
movq %r14, (%rsi)
movq -0x48(%rbp), %rsi
addq $0x8, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x1636f
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x17952
movq -0x48(%rbp), %rsi
movq %r13, -0x30(%rbp)
cmpq -0x40(%rbp), %rsi
je 0x1638a
movq %r13, (%rsi)
movq -0x48(%rbp), %rsi
addq $0x8, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x1639b
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x17952
movq -0x48(%rbp), %rsi
movq %r12, -0x30(%rbp)
cmpq -0x40(%rbp), %rsi
je 0x163b6
movq %r12, (%rsi)
movq -0x48(%rbp), %rsi
addq $0x8, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x163c7
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x17952
movq -0x48(%rbp), %rsi
movq %r15, -0x30(%rbp)
cmpq -0x40(%rbp), %rsi
je 0x163e2
movq %r15, (%rsi)
movq -0x48(%rbp), %rsi
addq $0x8, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x163f3
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x17952
movq -0x48(%rbp), %rsi
movq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq -0x40(%rbp), %rsi
je 0x1640b
movq %rax, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x16418
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x17952
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movq -0x58(%rbp), %rsi
callq 0x16470
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x16436
callq 0x85d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1644f
jmp 0x1644f
jmp 0x1644f
jmp 0x1644f
jmp 0x1644f
movq %rax, %r14
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x16460
callq 0x85d0
movq %rbx, %rdi
callq 0x16b4c
movq %r14, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O3/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
movq (%rcx), %rax
cmpq 0x8(%rdx), %rax
je 0x166e6
movq (%rax), %rdx
cmpl %r8d, 0x24(%rdx)
jne 0x166e6
leaq 0x8(%rax), %rdx
movq %rdx, (%rcx)
movq (%rax), %rsi
popq %rbp
jmp 0x16ba4
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
leaq -0x18(%rbp), %rsi
movb $0x0, (%rsi)
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rdi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r8d
subl %eax, %r8d
orb $0x30, %r8b
movb %r8b, -0x1(%rsi)
decq %rsi
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x18068
leaq -0x30(%rbp), %rax
cmpq %rax, %rsi
jb 0x180b1
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x8260
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x52217(%rip), %rdi     # 0x6a2cf
leaq 0x52222(%rip), %rsi     # 0x6a2e1
leaq 0x52261(%rip), %rcx     # 0x6a327
movl $0x71, %edx
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x10(%rsi)
movq 0x8(%rsi), %rax
movb $0x0, (%rax)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x188a4
cmpb $0x0, 0x2a(%r14)
jne 0x18882
leaq 0x8(%r14), %rdi
movl $0xa, %esi
callq 0x8530
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x111e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsi), %r12
xorl %eax, %eax
movq %rax, 0x28(%rsi)
movq 0x20(%rsi), %rcx
movb %al, (%rcx)
movb %al, 0x68(%rsi)
movq %rax, 0x48(%rsi)
movq 0x40(%rsi), %rcx
movb %al, (%rcx)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x18cc2
movq %r14, %rdi
movq %r15, %rsi
callq 0x18db2
movq %r14, %rdi
movq %r15, %rsi
callq 0x191bc
movq %r12, %rdi
movl $0xa, %esi
callq 0x8530
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x111e0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1600c
testb %al, %al
je 0x18d85
leaq 0x20(%rbx), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x8530
movq %rbx, %rdi
callq 0x19816
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x16028
cmpq $0x0, 0x8(%r12)
je 0x18d66
movq -0x40(%rbp), %r15
movsbl (%r15), %esi
movq %r14, %rdi
callq 0x8530
cmpb $0xa, (%r15)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
jne 0x18d5b
leaq 0x1(%r15), %rdx
leaq (%rcx,%rax), %rsi
cmpq %rsi, %rdx
je 0x18d5b
cmpb $0x2f, (%rdx)
jne 0x18d5b
movq %rbx, %rdi
callq 0x19816
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
incq %r15
cmpq %rax, %r15
jne 0x18d1f
movq %r14, %rdi
movl $0xa, %esi
callq 0x8530
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18d85
callq 0x85d0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18d94
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x18da9
callq 0x85d0
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Json/json_writer.cpp
// Function: Json::StyledWriter::writeCommentAfterValueOnSameLine(Json::Value const&)
void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root) {
  if (root.hasComment(commentAfterOnSameLine))
    document_ += " " + root.getComment(commentAfterOnSameLine);

  if (root.hasComment(commentAfter)) {
    document_ += '\n';
    document_ += root.getComment(commentAfter);
    document_ += '\n';
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x1, %esi
callq 0x1600c
testb %al, %al
je 0x1927f
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x16028
leaq 0x5c2d0(%rip), %rcx     # 0x754cf
movl $0x1, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x86f0
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x19235
movq %rsi, -0x38(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x28(%rbp)
jmp 0x1923f
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq %r15, %rsi
movq 0x8(%rax), %rdx
movq %rdx, -0x30(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x20(%rbx), %rdi
callq 0x81f0
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1926d
callq 0x85d0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1927f
callq 0x85d0
movq %r14, %rdi
movl $0x2, %esi
callq 0x1600c
testb %al, %al
je 0x192e3
addq $0x20, %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x8530
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x16028
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x81f0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x192d6
callq 0x85d0
movq %rbx, %rdi
movl $0xa, %esi
callq 0x8530
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
jmp 0x19311
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x1930d
callq 0x85d0
jmp 0x1930d
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1931f
callq 0x85d0
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpb $0x1, 0x68(%rdi)
jne 0x1933c
addq $0x8, %rdi
popq %rbp
jmp 0x1bf2e
addq $0x20, %rdi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
popq %rbp
jmp 0x81f0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x18(%rdi)
andb $-0x2, 0x68(%rdi)
movq %rdx, %r14
movq $0x0, 0x28(%rdi)
movq 0x20(%rdi), %rax
movb $0x0, (%rax)
orb $0x2, 0x68(%rdi)
movq %rdx, %rsi
callq 0x199a8
movb 0x68(%rbx), %al
testb $0x2, %al
jne 0x1996a
movq %rbx, %rdi
callq 0x19a9c
movb 0x68(%rbx), %al
orb $0x2, %al
movb %al, 0x68(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19ad2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19efe
movq 0x18(%rbx), %rdi
leaq 0x5d488(%rip), %rsi     # 0x76e18
movl $0x1, %edx
callq 0x8720
movq $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1600c
testb %al, %al
je 0x19a71
testb $0x2, 0x68(%rbx)
jne 0x199dd
movq %rbx, %rdi
callq 0x19a9c
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x16028
movq (%r15), %r12
cmpq $0x0, 0x8(%r15)
je 0x19a5c
leaq -0x21(%rbp), %r14
movq 0x18(%rbx), %rdi
movb (%r12), %al
movb %al, -0x21(%rbp)
movl $0x1, %edx
movq %r14, %rsi
callq 0x8720
cmpb $0xa, (%r12)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
jne 0x19a4f
leaq 0x1(%r12), %rcx
leaq (%rdi,%rax), %rdx
cmpq %rdx, %rcx
je 0x19a4f
cmpb $0x2f, (%rcx)
jne 0x19a4f
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x8720
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
incq %r12
addq %rdi, %rax
cmpq %rax, %r12
jne 0x199fc
jmp 0x19a5f
movq %r12, %rdi
andb $-0x3, 0x68(%rbx)
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x19a71
callq 0x85d0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19a93
callq 0x85d0
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testb $0x2, 0x68(%rdi)
jne 0x1a2cf
movq %rbx, %rdi
callq 0x19a9c
movq 0x18(%rbx), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x8720
andb $-0x3, 0x68(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x8(%rdi)
movb 0xd8(%rdi), %al
andb $-0x4, %al
orb $0x2, %al
movb %al, 0xd8(%rdi)
movq $0x0, 0x30(%rdi)
movq 0x28(%rdi), %rax
movb $0x0, (%rax)
callq 0x1a70e
movb 0xd8(%rbx), %al
testb $0x2, %al
jne 0x1a6c9
movq %rbx, %rdi
callq 0x1a812
movb 0xd8(%rbx), %al
orb $0x2, %al
movb %al, 0xd8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a84e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ac5c
movq 0x8(%rbx), %rdi
movq 0xb8(%rbx), %rsi
movq 0xc0(%rbx), %rdx
callq 0x8720
movq $0x0, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
cmpl $0x0, 0x70(%rdi)
je 0x1a7e7
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1600c
testb %al, %al
je 0x1a7e7
testb $0x2, 0xd8(%rbx)
jne 0x1a750
movq %rbx, %rdi
callq 0x1a812
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x16028
movq (%r15), %r12
cmpq $0x0, 0x8(%r15)
je 0x1a7cf
leaq -0x21(%rbp), %r14
movq 0x8(%rbx), %rdi
movb (%r12), %al
movb %al, -0x21(%rbp)
movl $0x1, %edx
movq %r14, %rsi
callq 0x8720
cmpb $0xa, (%r12)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
jne 0x1a7c2
leaq 0x1(%r12), %rcx
leaq (%rdi,%rax), %rdx
cmpq %rdx, %rcx
je 0x1a7c2
cmpb $0x2f, (%rcx)
jne 0x1a7c2
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
callq 0x8720
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
incq %r12
addq %rdi, %rax
cmpq %rax, %r12
jne 0x1a76f
jmp 0x1a7d2
movq %r12, %rdi
andb $-0x3, 0xd8(%rbx)
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1a7e7
callq 0x85d0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a809
callq 0x85d0
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
cmpl $0x0, 0x70(%rdi)
je 0x1ad82
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x1600c
testb %al, %al
je 0x1ad30
movq 0x8(%r14), %r15
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x16028
leaq 0x5a820(%rip), %rcx     # 0x754cf
movl $0x1, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x86f0
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x1ace6
movq %rsi, -0x40(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x30(%rbp)
jmp 0x1acf1
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq %r12, %rsi
movq 0x8(%rax), %rdx
movq %rdx, -0x38(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r15, %rdi
callq 0x8720
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1ad1e
callq 0x85d0
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ad30
callq 0x85d0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1600c
testb %al, %al
je 0x1ad82
movq %r14, %rdi
callq 0x1a812
movq 0x8(%r14), %r14
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x16028
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x8720
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ad82
callq 0x85d0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
jmp 0x1adb2
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1adae
callq 0x85d0
jmp 0x1adae
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1adc0
callq 0x85d0
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O3/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
testb $0x1, 0xd8(%rdi)
je 0x1addf
addq $0x10, %rdi
popq %rbp
jmp 0x1bf2e
movq 0x8(%rdi), %rdi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
popq %rbp
jmp 0x8720
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testb $0x2, 0xd8(%rdi)
jne 0x1b0fa
movq %rbx, %rdi
callq 0x1a812
movq 0x8(%rbx), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x8720
andb $-0x3, 0xd8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x190(%rbp), %rdi
callq 0x8860
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %r14
movq (%rax), %rax
leaq -0x190(%rbp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x89f0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x7223b(%rip), %rsi     # 0x8dfc8
leaq -0x190(%rbp), %rdi
callq 0x8370
leaq -0x120(%rbp), %rdi
callq 0x8220
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1bdc7
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x721fa(%rip), %rsi     # 0x8dfc8
leaq -0x190(%rbp), %rdi
callq 0x8370
leaq -0x120(%rbp), %rdi
callq 0x8220
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x1b31e
movq %r14, %rdi
callq 0x1b57c
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)
leaq 0x71619(%rip), %rax     # 0x8d450
leaq -0x40(%rbp), %rdi
movq %rax, -0x8(%rdi)
callq 0x1315e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x1be63
movq %rax, %rbx
leaq 0x715e6(%rip), %rax     # 0x8d450
leaq -0x40(%rbp), %rdi
movq %rax, -0x8(%rdi)
callq 0x1315e
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movl $0x4, %esi
movl $0x20, %edx
callq 0x8740
movl %r14d, %eax
shrl $0x8, %eax
movl $0xff, %ecx
andl %ecx, %eax
leaq 0x4e7ea(%rip), %rdx     # 0x6a6a0
movq (%rbx), %rsi
movb (%rdx,%rax,2), %dil
movb 0x1(%rdx,%rax,2), %al
movb %dil, (%rsi)
movq (%rbx), %rsi
movb %al, 0x1(%rsi)
andl %ecx, %r14d
movq (%rbx), %rax
movb (%rdx,%r14,2), %cl
movb 0x1(%rdx,%r14,2), %dl
movb %cl, 0x2(%rax)
movq (%rbx), %rax
movb %dl, 0x3(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Encoder/RtcmExEncoder.cpp
// Function: bamboo::RtcmExEncoder::m_encodeRtcmExMsg(char const*, bamboo::gtime_t, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bamboo::RtSatObs, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bamboo::RtSatObs>>>&)
int RtcmExEncoder::m_encodeRtcmExMsg(const char* sitname,gtime_t tt,map<string, RtSatObs>& obs){
	unsigned int crc;
	int i = 0;
	nbyte = len = nbit = 0;
	setbitu((unsigned char*)buff, i, 8, RTCMEX_PREAMB); i += 8;
	setbitu((unsigned char*)buff, i, 16, 0);        i += 16;
	if(0 == (nbit = m_encodeObsMsg(sitname,tt,obs))){
		nbyte = nbit = len = 0;
		return 0;
	}
	/* padding to align 8 bit boundary */
	for (i = nbit; i % 8; i++) {
		setbitu((unsigned char*)buff, i, 1, 0);
	}
	/* message length (header+data) (bytes) */
	if ((len = i / 8) > sizeof(buff) - 4) {
		nbyte = nbit = len = 0;
		return 0;
	}
	/* message length without header and parity */
	setbitu((unsigned char*)buff, 8, 16, len - 3);

	/* crc-24q */
	crc = rtk_crc24q((unsigned char*)buff, len);
	setbitu((unsigned char*)buff, i, 32, crc);
	/* length total (bytes) */
	nbyte = len + 4;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movsd %xmm0, -0x30(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x0, 0x808(%rdi)
movq $0x0, 0x800(%rdi)
xorl %r13d, %r13d
xorl %esi, %esi
movl $0x8, %edx
movl $0xda, %ecx
callq 0x4da98
movq %rbx, %rdi
movl $0x8, %esi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x4da98
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movsd -0x30(%rbp), %xmm0
movq %r14, %rcx
callq 0x1c472
movl %eax, 0x808(%rbx)
testl %eax, %eax
je 0x1c408
movl %eax, %r14d
testb $0x7, %r14b
je 0x1c3e4
movq %rbx, %rdi
movl %r14d, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x4da98
incl %r14d
jmp 0x1c3c7
movl %r14d, %ecx
sarl $0x3, %ecx
movl %ecx, 0x804(%rbx)
cmpl $0x7fd, %ecx            # imm = 0x7FD
jb 0x1c417
movq $0x0, 0x804(%rbx)
xorl %r13d, %r13d
jmp 0x1c413
movq $0x0, 0x804(%rbx)
xorl %eax, %eax
jmp 0x1c45c
addl $-0x3, %ecx
movq %rbx, %rdi
movl $0x8, %esi
movl $0x10, %edx
callq 0x4da98
movl 0x804(%rbx), %esi
movq %rbx, %rdi
callq 0x4db73
movq %rbx, %rdi
movl %r14d, %esi
movl $0x20, %edx
movl %eax, %ecx
callq 0x4da98
movl 0x804(%rbx), %r13d
addl $0x4, %r13d
movl $0x1, %eax
movl %r13d, 0x800(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::md_julday(int, int, int)
int md_julday(int iyear,int imonth,int iday){
	int iyr, result;
	int doy_of_month[12] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304,
			334 };
	if (iyear < 0 || imonth < 0 || iday < 0 || imonth > 12 || iday > 366
			|| (imonth != 0 && iday > 31)) {
		printf("iyear = %d,imonth = %d,iday = %d,incorrect argument",iyear,imonth,iday);
		exit(1);
	}
	iyr = iyear;
	if (imonth <= 2)
		iyr -= 1;
	result = 365 * iyear - 678941 + iyr / 4 - iyr / 100 + iyr / 400 + iday;
	if (imonth != 0)
		result = result + doy_of_month[imonth - 1];
	return result;
}

// Assembly:
movl %edx, %ecx
movl %esi, %edx
movl %edi, %esi
cmpl $0x16e, %ecx            # imm = 0x16E
jg 0x1c98d
cmpl $0xc, %edx
jg 0x1c98d
movl %edx, %eax
orl %esi, %eax
orl %ecx, %eax
js 0x1c98d
testl %edx, %edx
sete %al
cmpl $0x20, %ecx
setl %dil
orb %al, %dil
je 0x1c98d
xorl %eax, %eax
cmpl $0x3, %edx
setl %al
movl %esi, %edi
subl %eax, %edi
imull $0x16d, %esi, %r8d      # imm = 0x16D
addl %ecx, %r8d
negl %eax
addl %esi, %eax
addl $0x3, %eax
testl %edi, %edi
cmovnsl %edi, %eax
sarl $0x2, %eax
addl %r8d, %eax
movslq %edi, %rcx
imulq $-0x51eb851f, %rcx, %rsi # imm = 0xAE147AE1
movq %rsi, %rdi
shrq $0x3f, %rdi
sarq $0x25, %rsi
addl %edi, %esi
addl %eax, %esi
imulq $0x51eb851f, %rcx, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x27, %rax
addl %ecx, %eax
addl %esi, %eax
addl $0xfff5a3e3, %eax       # imm = 0xFFF5A3E3
testl %edx, %edx
je 0x1c98c
decl %edx
leaq 0x4e187(%rip), %rcx     # 0x6ab10
addl (%rcx,%rdx,4), %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x4e928(%rip), %rdi     # 0x6b2c0
xorl %eax, %eax
callq 0x8080
movl $0x1, %edi
callq 0x87b0
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::gpsweek(int, int, int, int*, int*)
void gpsweek(int year, int month, int day, int* week, int* wd) {
	int mjd;
	if (year != 0) {
		if (month != 0)
			mjd = md_julday(year, month, day);
		else
			mjd = md_julday(year, 1, 1) + day - 1;
	} else
		mjd = day;
	*week = (mjd - 44244) / 7;
	*wd = mjd - 44244 - (*week) * 7;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r14d
testl %edi, %edi
je 0x1c9e6
testl %esi, %esi
je 0x1c9d1
movl %r14d, %edx
callq 0x1c8ec
movl %eax, %r14d
jmp 0x1c9e6
movl $0x1, %esi
movl $0x1, %edx
callq 0x1c8ec
addl %eax, %r14d
decl %r14d
movl %r14d, %eax
addl $0xffff532c, %eax       # imm = 0xFFFF532C
cltq
imulq $-0x6db6db6d, %rax, %rax # imm = 0x92492493
shrq $0x20, %rax
addl %r14d, %eax
addl $0xffff532c, %eax       # imm = 0xFFFF532C
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x2, %eax
addl %ecx, %eax
movl %eax, (%r15)
leal (,%rax,8), %ecx
subl %ecx, %eax
addl %r14d, %eax
addl $0xffff532c, %eax       # imm = 0xFFFF532C
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::cur_time(int*, double*)
void cur_time(int* mjd,double* sod){
//	struct timeval tv;
//    struct tm* ptr;
//	gettimeofday(&tv,NULL);
//	ptr = gmtime (&tv.tv_sec);
//	*mjd = md_julday(ptr->tm_year + 1900,ptr->tm_mon + 1,ptr->tm_mday);
//	*sod = ptr->tm_hour * 3600.0 + ptr->tm_min * 60.0 + ptr->tm_sec + tv.tv_usec / 1e6;
//
//	timinc(*mjd, *sod, Taiutc::s_getInstance()->m_getTaiutc(*mjd) - 19.0, mjd, sod);
	struct tm *ptr;
	time_t rawtime;
	time(&rawtime);
	ptr = gmtime(&rawtime);
	*mjd = md_julday(ptr->tm_year + 1900,ptr->tm_mon + 1,ptr->tm_mday);
	*sod = ptr->tm_hour * 3600.0 + ptr->tm_min * 60.0 + ptr->tm_sec;
	// 从UTC转成GPST
	timinc(*mjd, *sod, 38 - 19.0, mjd, sod);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0x85b0
movq %r15, %rdi
callq 0x8540
movq %rax, %r15
movl $0x76c, %edi            # imm = 0x76C
addl 0x14(%rax), %edi
movl 0xc(%rax), %edx
movl 0x10(%rax), %esi
incl %esi
callq 0x1c8ec
movl %eax, (%r14)
cvtsi2sdl 0x8(%r15), %xmm1
cvtsi2sdl 0x4(%r15), %xmm0
mulsd 0x4ddb2(%rip), %xmm0    # 0x6a8b8
mulsd 0x4ddb2(%rip), %xmm1    # 0x6a8c0
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sdl (%r15), %xmm0
addsd %xmm1, %xmm0
addsd 0x4dda2(%rip), %xmm0    # 0x6a8c8
movsd 0x4dda2(%rip), %xmm1    # 0x6a8d0
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %ecx
addl %eax, %ecx
movl %ecx, (%r14)
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, (%rbx)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x1cb6e
decl %ecx
movl %ecx, (%r14)
addsd 0x4dd66(%rip), %xmm0    # 0x6a8d0
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::timinc(int, double, double, int*, double*)
void timinc(int jd, double sec, double delt, int* jd1, double* sec1) {
	*sec1 = sec + delt;
	int inc = (int) (*sec1 / 86400.0);
	*jd1 = jd + inc;
	*sec1 = *sec1 - inc * 86400.0;
	if (*sec1 >= 0)
		return;
	*jd1 = *jd1 - 1;
	*sec1 = *sec1 + 86400;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addsd %xmm1, %xmm0
movsd 0x4dd47(%rip), %xmm1    # 0x6a8d0
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
addl %edi, %eax
movl %eax, (%rsi)
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, (%rdx)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x1cbc7
decl %eax
movl %eax, (%rsi)
addsd 0x4dd0d(%rip), %xmm0    # 0x6a8d0
movsd %xmm0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::runtime(char*)
char* runtime(char* buf){
	int iy,im,id,ih,imin,mjd;
	double dsec,sod;
	cur_time(&mjd,&sod);
	mjd2date(mjd,sod,&iy,&im,&id,&ih,&imin,&dsec);
	if(buf!=NULL)
		sprintf(buf,"%02d-%02d-%02d %02d:%02d:%02d",iy,im,id,ih,imin,(int)dsec);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq -0x3c(%rbp), %r14
leaq -0x48(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1cab3
movl (%r14), %edi
movsd (%r15), %xmm0
subq $0x8, %rsp
leaq -0x38(%rbp), %rax
leaq -0x2c(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x24(%rbp), %rcx
leaq -0x20(%rbp), %r8
leaq -0x1c(%rbp), %r9
pushq %rax
callq 0x1cc5e
addq $0x10, %rsp
testq %rbx, %rbx
je 0x1cc50
movl -0x2c(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %r8d
movl -0x20(%rbp), %r9d
movl -0x1c(%rbp), %r10d
cvttsd2si -0x38(%rbp), %r11d
leaq 0x4e6b6(%rip), %rsi     # 0x6b2f4
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x8120
addq $0x10, %rsp
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::runlocaltime(char*)
char* runlocaltime(char* buf){
	int iy, im, id, ih, imin, mjd;
	double dsec, sod;
	struct tm *ptr;
	time_t rawtime;
	time(&rawtime);
	ptr = localtime(&rawtime);
	mjd = md_julday(ptr->tm_year + 1900,ptr->tm_mon + 1,ptr->tm_mday);
	sod = ptr->tm_hour * 3600.0 + ptr->tm_min * 60.0 + ptr->tm_sec;
	mjd2date(mjd, sod, &iy, &im, &id, &ih, &imin, &dsec);
	if (buf != NULL)
		sprintf(buf, "%02d-%02d-%02d %02d:%02d:%02d", iy, im, id, ih, imin,
				(int) dsec);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x85b0
movq %r14, %rdi
callq 0x84a0
movq %rax, %r14
movl $0x76c, %edi            # imm = 0x76C
addl 0x14(%rax), %edi
movl 0xc(%rax), %edx
movl 0x10(%rax), %esi
incl %esi
callq 0x1c8ec
cvtsi2sdl 0x8(%r14), %xmm1
cvtsi2sdl 0x4(%r14), %xmm0
mulsd 0x4db3e(%rip), %xmm0    # 0x6a8b8
mulsd 0x4db3e(%rip), %xmm1    # 0x6a8c0
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sdl (%r14), %xmm0
addsd %xmm1, %xmm0
subq $0x8, %rsp
leaq -0x30(%rbp), %r10
leaq -0x24(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
leaq -0x18(%rbp), %r8
leaq -0x14(%rbp), %r9
movl %eax, %edi
pushq %r10
callq 0x1cc5e
addq $0x10, %rsp
testq %rbx, %rbx
je 0x1cdf1
movl -0x24(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movl -0x18(%rbp), %r9d
movl -0x14(%rbp), %r10d
cvttsd2si -0x30(%rbp), %r11d
leaq 0x4e515(%rip), %rsi     # 0x6b2f4
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x8120
addq $0x10, %rsp
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::run_timefmt(int, double, char*)
char* run_timefmt(int mjd,double sod,char* buf){
	int iy,im,id,ih,imin;
	double dsec;
	mjd2date(mjd,sod,&iy,&im,&id,&ih,&imin,&dsec);
	if(buf!=NULL)
		sprintf(buf,"%02d-%02d-%02d %02d:%02d:%02d",iy,im,id,ih,imin,(int)dsec);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
subq $0x8, %rsp
leaq -0x28(%rbp), %rax
leaq -0x1c(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x14(%rbp), %rcx
leaq -0x10(%rbp), %r8
leaq -0xc(%rbp), %r9
pushq %rax
callq 0x1cc5e
addq $0x10, %rsp
testq %rbx, %rbx
je 0x1ce65
movl -0x1c(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl -0x10(%rbp), %r9d
movl -0xc(%rbp), %r10d
cvttsd2si -0x28(%rbp), %r11d
leaq 0x4e4a1(%rip), %rsi     # 0x6b2f4
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x8120
addq $0x10, %rsp
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::yeardoy2monthday(int, int, int*, int*)
void yeardoy2monthday(int iyear, int idoy, int* imonth, int* iday) {
	int days_in_month[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	int id, i;
	if ((iyear % 4 == 0 && iyear % 100 != 0) || iyear % 400 == 0)
		days_in_month[1] = 29;
	id = idoy;
	for (i = 0; i < 12; i++) {
		id = id - days_in_month[i];
		if (id > 0)
			continue;
		*iday = id + days_in_month[i];
		*imonth = i + 1;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movaps 0x4dce6(%rip), %xmm0    # 0x6ab60
movaps %xmm0, -0x10(%rbp)
movaps 0x4dccb(%rip), %xmm0    # 0x6ab50
movaps %xmm0, -0x20(%rbp)
movaps 0x4dcb0(%rip), %xmm0    # 0x6ab40
movaps %xmm0, -0x30(%rbp)
testb $0x3, %dil
sete %al
imull $0xc28f5c29, %edi, %r8d # imm = 0xC28F5C29
addl $0x51eb850, %r8d        # imm = 0x51EB850
movl %r8d, %edi
rorl $0x2, %edi
cmpl $0x28f5c29, %edi        # imm = 0x28F5C29
setae %dil
rorl $0x4, %r8d
cmpl $0xa3d70b, %r8d         # imm = 0xA3D70B
jb 0x1cecb
andb %dil, %al
je 0x1ced2
movl $0x1d, -0x2c(%rbp)
xorl %eax, %eax
movl %esi, %edi
subl -0x30(%rbp,%rax,4), %edi
jle 0x1cee9
incq %rax
movl %edi, %esi
cmpq $0xc, %rax
jne 0x1ced6
jmp 0x1ceef
movl %esi, (%rcx)
incl %eax
movl %eax, (%rdx)
popq %rbp
retq