LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Json/json_value.cpp
// Function: Json::Value::find(char const*, char const*) const
Value const* Value::find(char const* begin, char const* end) const {
  JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
                      "in Json::Value::find(key, end, found): requires "
                      "objectValue or nullValue");
  if (type_ == nullValue)
    return NULL;
  CZString actualKey(begin, static_cast<unsigned>(end - begin),
                     CZString::noDuplication);
  ObjectValues::const_iterator it = value_.map_->find(actualKey);
  if (it == value_.map_->end())
    return NULL;
  return &(*it).second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movzbl 0x8(%rdi), %eax
testl %eax, %eax
je 0x1389d
cmpl $0x7, %eax
jne 0x138ac
movq %rdi, %rbx
subl %esi, %edx
leaq -0x1a0(%rbp), %rax
movq %rsi, (%rax)
shll $0x2, %edx
movl %edx, 0x8(%rax)
movq (%rdi), %rdi
movq %rax, %rsi
callq 0x1554e
movq (%rbx), %rcx
addq $0x8, %rcx
leaq 0x30(%rax), %rdx
xorl %ebx, %ebx
cmpq %rcx, %rax
cmovneq %rdx, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x11578
jmp 0x1389f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %rbp
retq
leaq -0x1a0(%rbp), %rbx
movq %rbx, %rdi
callq 0x8850
leaq 0x4c6ce(%rip), %rsi     # 0x5ff90
movq %rbx, %rdi
callq 0x8610
leaq -0x198(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x89e0
leaq -0x28(%rbp), %rdi
callq 0x112e7
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x82c0
jmp 0x138f6
jmp 0x138f3
movq %rax, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x81a0
jmp 0x13913
movq %rax, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x11578
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x8290
leaq (%rax,%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13842
testq %rax, %rax
jne 0x13951
callq 0x10e7c
leaq 0x74577(%rip), %rax     # 0x87ec8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x13842
testq %rax, %rax
jne 0x1397d
callq 0x10e7c
leaq 0x7454b(%rip), %rax     # 0x87ec8
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13bbf
movq %rcx, %r14
movq %rdi, %rbx
subl %esi, %edx
leaq -0x38(%rbp), %rax
movq %rsi, (%rax)
shll $0x2, %edx
movl %edx, 0x8(%rax)
movq (%rdi), %rdi
movq %rax, %rsi
callq 0x1554e
movq %rax, %r12
movq (%rbx), %rdi
leaq 0x8(%rdi), %rax
cmpq %rax, %r12
setne %r15b
je 0x13bb4
testq %r14, %r14
je 0x13bac
movq %r12, %rsi
addq $0x30, %rsi
leaq -0x60(%rbp), %r13
movq %r13, %rdi
callq 0x11c6a
movq %r14, %rdi
movq %r13, %rsi
callq 0x11c86
movq %r13, %rdi
callq 0x11cce
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x15596
leaq -0x38(%rbp), %rdi
callq 0x11578
jmp 0x13bc2
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x11578
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13c87
cmpl $0x7, %eax
jne 0x13c93
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), %rdi
callq 0x15060
leaq -0x1a8(%rbp), %rdi
callq 0x11578
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x1a8(%rbp), %rbx
movq %rbx, %rdi
callq 0x8850
leaq 0x4c330(%rip), %rsi     # 0x5ffd9
movq %rbx, %rdi
callq 0x8610
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x89e0
leaq -0x30(%rbp), %rdi
callq 0x112e7
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x82c0
jmp 0x13cdd
jmp 0x13cda
movq %rax, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x81a0
jmp 0x13cfa
movq %rax, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x11578
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O2/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
movzbl 0x8(%rdi), %ecx
movb $0x1, %al
leal -0x1(%rcx), %edx
cmpl $0x2, %edx
jb 0x1407c
cmpl $0x3, %ecx
jne 0x1407a
movsd (%rdi), %xmm0
xorl %eax, %eax
ucomisd 0x4b8a9(%rip), %xmm0    # 0x5f910
jb 0x1407c
movsd 0x4b8a7(%rip), %xmm1    # 0x5f918
ucomisd %xmm0, %xmm1
jbe 0x1407c
popq %rbp
jmp 0x14019
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x140e4
movq %rdi, %r12
pushq $0x20
popq %rdi
callq 0x8040
movq $0x3, (%rax)
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
movq %rcx, 0x10(%r12)
testq %r15, %r15
je 0x140f9
leaq -0x1(%r15), %rdx
cmpb $0xa, -0x1(%rbx,%r15)
cmovneq %r15, %rdx
jmp 0x140fb
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 0x11372
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x60(%rbp), %rdi
callq 0x188e6
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x1421b
cmpq $0x0, (%rax)
leaq 0x4b6ce(%rip), %rax     # 0x5f8dc
leaq 0x58c43(%rip), %rsi     # 0x6ce58
cmoveq %rax, %rsi
jmp 0x14222
leaq 0x4b6ba(%rip), %rsi     # 0x5f8dc
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x8260
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq %r14, %rdx
callq 0x19142
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x8c60
leaq -0x30(%rbp), %rdi
callq 0x82c0
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x8530
leaq -0x60(%rbp), %rdi
callq 0x18b00
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x14283
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x82c0
jmp 0x14286
movq %rax, %r14
movq %rbx, %rdi
callq 0x82c0
jmp 0x14293
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x18b00
movq %r14, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
pushq $0x5
popq %rsi
callq 0x149e8
leaq -0x30(%rbp), %rsi
movq %r14, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x159ae
leaq -0x30(%rbp), %rsi
movq %r13, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x159ae
leaq -0x30(%rbp), %rsi
movq %r12, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x159ae
leaq -0x30(%rbp), %rsi
movq %r15, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x159ae
movq 0x10(%rbp), %rax
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x159ae
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movq -0x58(%rbp), %rsi
callq 0x144e6
leaq -0x50(%rbp), %rdi
callq 0x15950
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x144c9
jmp 0x144c9
jmp 0x144c9
jmp 0x144c9
jmp 0x144c9
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x15950
movq %rbx, %rdi
callq 0x14a82
movq %r14, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x146c8
movq (%rax), %rdx
cmpl %r8d, 0x24(%rdx)
jne 0x146c8
leaq 0x8(%rax), %rdx
movq %rdx, (%rcx)
movq (%rax), %rsi
popq %rbp
jmp 0x14aae
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq -0x27(%rbp), %rax
leaq -0x20(%rbp), %r14
movq %rax, (%r14)
movq %rsi, %rdi
movq %r14, %rsi
callq 0x15eac
movq (%r14), %rsi
leaq -0x40(%rbp), %rax
cmpq %rax, %rsi
jb 0x15f34
leaq -0x11(%rbp), %rdx
movq %rbx, %rdi
callq 0x8260
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4a384(%rip), %rdi     # 0x602bf
leaq 0x4a38f(%rip), %rsi     # 0x602d1
leaq 0x4a3ce(%rip), %rcx     # 0x60317
pushq $0x71
popq %rdx
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
andq $0x0, 0x10(%rsi)
movq %rdi, %rbx
leaq 0x8(%rsi), %r14
movq 0x8(%rsi), %rax
movb $0x0, (%rax)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x165fe
cmpb $0x0, 0x2a(%r15)
jne 0x165e5
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x8530
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8870
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
andq $0x0, 0x28(%rsi)
movq %rdx, %r15
movq 0x20(%rsi), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movb %cl, 0x68(%rsi)
andq $0x0, 0x48(%rsi)
movq %rdi, %rbx
leaq 0x20(%rsi), %r12
movq 0x40(%rsi), %rax
movb %cl, (%rax)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x16986
movq %r14, %rdi
movq %r15, %rsi
callq 0x16a58
movq %r14, %rdi
movq %r15, %rsi
callq 0x16d7c
pushq $0xa
popq %rsi
movq %r12, %rdi
callq 0x8530
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8870
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1415c
testb %al, %al
je 0x16a35
leaq 0x20(%rbx), %r14
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x8530
movq %rbx, %rdi
callq 0x172c2
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x14178
movq (%r12), %rax
movq %rax, %r15
addq -0x38(%rbp), %rax
cmpq %rax, %r15
je 0x16a21
movsbl (%r15), %esi
movq %r14, %rdi
callq 0x8530
cmpb $0xa, (%r15)
movq -0x40(%rbp), %rax
jne 0x16a1c
leaq 0x1(%r15), %rcx
movq -0x38(%rbp), %rdx
addq %rax, %rdx
cmpq %rdx, %rcx
je 0x16a1c
cmpb $0x2f, (%rcx)
jne 0x16a1c
movq %rbx, %rdi
callq 0x172c2
movq -0x40(%rbp), %rax
incq %r15
jmp 0x169dc
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x8530
leaq -0x40(%rbp), %rdi
callq 0x82c0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16a44
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x82c0
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1415c
testb %al, %al
je 0x16de2
leaq -0x58(%rbp), %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x14178
leaq 0x5472e(%rip), %rsi     # 0x6b4e5
leaq -0x38(%rbp), %rdi
movq %r15, %rdx
callq 0xe8ad
leaq 0x20(%rbx), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8c60
leaq -0x38(%rbp), %rdi
callq 0x82c0
leaq -0x58(%rbp), %rdi
callq 0x82c0
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x1415c
testb %al, %al
je 0x16e31
addq $0x20, %rbx
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x8530
leaq -0x38(%rbp), %r15
pushq $0x2
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x14178
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8c60
leaq -0x38(%rbp), %rdi
callq 0x82c0
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x8530
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x16e5a
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x82c0
jmp 0x16e56
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x82c0
movq %rbx, %rdi
callq 0x8b30
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16e7c
addq $0x8, %rdi
popq %rbp
jmp 0x192d0
addq $0x20, %rdi
popq %rbp
jmp 0x8c60
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rdi, %rbx
movq %rsi, 0x18(%rdi)
andb $-0x2, 0x68(%rdi)
andq $0x0, 0x28(%rdi)
movq 0x20(%rdi), %rax
movb $0x0, (%rax)
orb $0x2, 0x68(%rdi)
movq %rdx, %rsi
callq 0x17426
movb 0x68(%rbx), %al
testb $0x2, %al
jne 0x173f1
movq %rbx, %rdi
callq 0x174ea
movb 0x68(%rbx), %al
orb $0x2, %al
movb %al, 0x68(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17514
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17834
movq 0x18(%rbx), %rdi
leaq 0x55a41(%rip), %rsi     # 0x6ce58
callq 0x8610
andq $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1415c
testb %al, %al
je 0x174cb
testb $0x2, 0x68(%rbx)
jne 0x17459
movq %rbx, %rdi
callq 0x174ea
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x14178
movq (%r15), %rax
leaq 0x20(%rbx), %r14
movq %rax, %r15
addq -0x30(%rbp), %rax
cmpq %rax, %r15
je 0x174be
movq 0x18(%rbx), %rdi
movsbl (%r15), %esi
callq 0x8720
cmpb $0xa, (%r15)
movq -0x38(%rbp), %rax
jne 0x174b9
leaq 0x1(%r15), %rcx
movq -0x30(%rbp), %rdx
addq %rax, %rdx
cmpq %rdx, %rcx
je 0x174b9
cmpb $0x2f, (%rcx)
jne 0x174b9
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x8560
movq -0x38(%rbp), %rax
incq %r15
jmp 0x17474
andb $-0x3, 0x68(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x82c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x82c0
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17b79
movq %rbx, %rdi
callq 0x174ea
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x8560
andb $-0x3, 0x68(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movq %rdx, 0x8(%rdi)
movb 0xd8(%rdi), %al
andb $-0x4, %al
orb $0x2, %al
movb %al, 0xd8(%rdi)
andq $0x0, 0x30(%rdi)
movq %rsi, %r14
movq 0x28(%rdi), %rax
movb $0x0, (%rax)
callq 0x17f04
movb 0xd8(%rbx), %al
testb $0x2, %al
jne 0x17eca
movq %rbx, %rdi
callq 0x17fd8
movb 0xd8(%rbx), %al
orb $0x2, %al
movb %al, 0xd8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1800a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18336
movq 0x8(%rbx), %rdi
leaq 0xb8(%rbx), %rsi
callq 0x8560
andq $0x0, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
cmpl $0x0, 0x70(%rdi)
je 0x17fb9
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1415c
testb %al, %al
je 0x17fb9
testb $0x2, 0xd8(%rbx)
jne 0x17f44
movq %rbx, %rdi
callq 0x17fd8
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x14178
movq (%r15), %rax
leaq 0x28(%rbx), %r14
movq %rax, %r15
addq -0x30(%rbp), %rax
cmpq %rax, %r15
je 0x17fa9
movq 0x8(%rbx), %rdi
movsbl (%r15), %esi
callq 0x8720
cmpb $0xa, (%r15)
movq -0x38(%rbp), %rax
jne 0x17fa4
leaq 0x1(%r15), %rcx
movq -0x30(%rbp), %rdx
addq %rax, %rdx
cmpq %rdx, %rcx
je 0x17fa4
cmpb $0x2f, (%rcx)
jne 0x17fa4
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x8560
movq -0x38(%rbp), %rax
incq %r15
jmp 0x17f5f
andb $-0x3, 0xd8(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x82c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x82c0
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O2/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 0x183ec
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1415c
testb %al, %al
je 0x183ab
movq 0x8(%r14), %r15
leaq -0x60(%rbp), %r12
pushq $0x1
popq %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x14178
leaq 0x53164(%rip), %rsi     # 0x6b4e5
leaq -0x40(%rbp), %rdi
movq %r12, %rdx
callq 0xe8ad
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x8560
leaq -0x40(%rbp), %rdi
callq 0x82c0
leaq -0x60(%rbp), %rdi
callq 0x82c0
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x1415c
testb %al, %al
je 0x183ec
movq %r14, %rdi
callq 0x17fd8
movq 0x8(%r14), %r14
leaq -0x40(%rbp), %r15
pushq $0x2
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x14178
movq %r14, %rdi
movq %r15, %rsi
callq 0x8560
leaq -0x40(%rbp), %rdi
callq 0x82c0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x18417
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x82c0
jmp 0x18413
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x82c0
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1843b
addq $0x10, %rdi
popq %rbp
jmp 0x192d0
movq 0x8(%rdi), %rdi
popq %rbp
jmp 0x8560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x186f0
movq %rbx, %rdi
callq 0x17fd8
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x8560
andb $-0x3, 0xd8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8850
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 0x89e0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq -0x190(%rbp), %rdi
callq 0x81a0
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x191cc
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq -0x190(%rbp), %rdi
callq 0x81a0
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O2/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 0x188e6
movq %r14, %rdi
callq 0x18b34
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 -0x48(%rbp), %rdi
callq 0x18b00
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 0x1924a
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x18b00
movq %rbx, %rdi
callq 0x8b30
// File: /workspace/github_cpp_makefile_star2_O2/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)
pushq $0x4
popq %rsi
pushq $0x20
popq %rdx
callq 0x8710
movl %r14d, %eax
shrl $0x8, %eax
movl $0xff, %ecx
andl %ecx, %eax
leaq 0x47402(%rip), %rdx     # 0x60690
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)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rax
cmpq %rsi, %rax
je 0x19431
cmpb $0x2c, (%rax)
jne 0x1942c
movb $0x2e, (%rax)
incq %rax
jmp 0x1941f
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x1(%rsi), %rcx
leaq 0x1(%rcx), %rax
cmpq %rdi, %rax
je 0x1945c
cmpb $0x30, (%rcx)
jne 0x19461
cmpq %rdi, %rcx
je 0x19454
cmpb $0x2e, -0x1(%rcx)
je 0x19464
decq %rsi
decq %rcx
jmp 0x1943b
movq %rdi, %rax
jmp 0x19464
movq %rsi, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
movq %rcx, -0x38(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rdx, %r15
movq %rdi, %rbx
andl $0x0, 0x808(%rdi)
movq %rsi, %r12
andq $0x0, 0x800(%rdi)
xorl %r13d, %r13d
pushq $0x8
popq %r14
xorl %esi, %esi
movl %r14d, %edx
movl $0xda, %ecx
callq 0x45a69
pushq $0x10
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
xorl %ecx, %ecx
callq 0x45a69
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movsd -0x30(%rbp), %xmm0
movq -0x38(%rbp), %rcx
callq 0x196ea
movl %eax, 0x808(%rbx)
testl %eax, %eax
je 0x1968a
movl %eax, %r15d
pushq $0x1
popq %r14
testb $0x7, %r15b
je 0x19669
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x45a69
incl %r15d
jmp 0x1964e
movl %r15d, %ecx
sarl $0x3, %ecx
movl %ecx, 0x804(%rbx)
cmpl $0x7fd, %ecx            # imm = 0x7FD
jb 0x19697
andq $0x0, 0x804(%rbx)
xorl %r13d, %r13d
jmp 0x19692
andq $0x0, 0x804(%rbx)
xorl %r14d, %r14d
jmp 0x196d1
addl $-0x3, %ecx
pushq $0x8
popq %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x45a69
movl 0x804(%rbx), %esi
movq %rbx, %rdi
callq 0x45b4d
pushq $0x20
popq %rdx
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %ecx
callq 0x45a69
movl 0x804(%rbx), %r13d
addl $0x4, %r13d
movl %r13d, 0x800(%rbx)
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %eax
movl %esi, %ecx
movl %edi, %esi
cmpl $0x16e, %edx            # imm = 0x16E
jg 0x19bb5
cmpl $0xc, %ecx
jg 0x19bb5
movl %ecx, %edx
orl %esi, %edx
orl %eax, %edx
js 0x19bb5
testl %ecx, %ecx
sete %dl
cmpl $0x20, %eax
setl %dil
orb %dl, %dil
je 0x19bb5
xorl %edx, %edx
cmpl $0x3, %ecx
setl %dl
imull $0x16d, %esi, %r9d      # imm = 0x16D
subl %edx, %esi
addl %eax, %r9d
pushq $0x4
popq %rdi
movl %esi, %eax
cltd
idivl %edi
movl %eax, %edi
pushq $-0x64
popq %r8
movl %esi, %eax
cltd
idivl %r8d
movl %eax, %r8d
movl $0x190, %r10d           # imm = 0x190
movl %esi, %eax
cltd
idivl %r10d
addl %r9d, %edi
addl %r8d, %edi
addl %edi, %eax
addl $0xfff5a3e3, %eax       # imm = 0xFFF5A3E3
testl %ecx, %ecx
je 0x19bb4
decl %ecx
leaq 0x46f4f(%rip), %rdx     # 0x60b00
addl (%rdx,%rcx,4), %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x476f0(%rip), %rdi     # 0x612b0
movl %ecx, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x8070
pushq $0x1
popq %rdi
callq 0x8790
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movl %edx, %r15d
testl %edi, %edi
je 0x19c0b
testl %esi, %esi
je 0x19bfb
movl %r15d, %edx
callq 0x19b34
movl %eax, %r15d
jmp 0x19c0b
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0x19b34
addl %eax, %r15d
decl %r15d
leal -0xacd4(%r15), %eax
pushq $0x7
popq %rcx
cltd
idivl %ecx
movl %eax, (%r14)
imull $-0x7, %eax, %eax
addl %r15d, %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_O2/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 0x19b34
movl %eax, (%r14)
cvtsi2sdl 0x8(%r15), %xmm1
cvtsi2sdl 0x4(%r15), %xmm0
mulsd 0x46bbb(%rip), %xmm0    # 0x608a8
mulsd 0x46bbb(%rip), %xmm1    # 0x608b0
addsd %xmm0, %xmm1
cvtsi2sdl (%r15), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
movsd 0x46baa(%rip), %xmm1    # 0x608b8
movl %eax, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x19d26
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x46b8a(%rip), %xmm1    # 0x608c0
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 0x19d74
decl %eax
movl %eax, (%rsi)
addsd 0x46b50(%rip), %xmm0    # 0x608c0
movsd %xmm0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19c9a
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 0x19e07
popq %rax
popq %rcx
testq %rbx, %rbx
je 0x19df9
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 0x474fb(%rip), %rsi     # 0x612e4
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x8110
popq %rcx
popq %rdx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/DoubleString[P]RtConverter/src/Rnxobs/Com.cpp
// Function: bamboo::mjd2date(int, double, int*, int*, int*, int*, int*, double*)
void mjd2date(int jd, double sod, int* iyear, int* imonth, int* iday, int* ih,
		int* imin, double* sec) {
	int doy = 0;
	mjd2doy(jd, iyear, &doy);
	yeardoy2monthday(*iyear, doy, imonth, iday);

	*ih =  static_cast<int>( sod / 3600.0);
	*imin = static_cast<int> ((sod - (*ih) * 3600.0) / 60.0);
	*sec = sod - (*ih) * 3600.0 - (*imin) * 60.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x38(%rbp)
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movsd %xmm0, -0x30(%rbp)
leaq -0x3c(%rbp), %r14
andl $0x0, (%r14)
movq %r14, %rdx
callq 0x19c33
movl (%r13), %edi
movl (%r14), %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1a007
movsd 0x46a59(%rip), %xmm0    # 0x608b0
movsd -0x30(%rbp), %xmm3
movapd %xmm3, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
movl %eax, (%rbx)
mulsd %xmm0, %xmm1
movapd %xmm3, %xmm2
movapd %xmm3, %xmm4
subsd %xmm1, %xmm2
movsd 0x46a1e(%rip), %xmm1    # 0x608a8
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movq -0x38(%rbp), %rcx
movl %eax, (%rcx)
cvtsi2sdl (%rbx), %xmm3
mulsd %xmm0, %xmm3
cvttpd2dq %xmm2, %xmm0
cvtdq2pd %xmm0, %xmm0
movapd %xmm4, %xmm2
subsd %xmm3, %xmm2
mulsd %xmm1, %xmm0
subsd %xmm0, %xmm2
movq 0x10(%rbp), %rax
movsd %xmm2, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19b34
cvtsi2sdl 0x8(%r14), %xmm1
cvtsi2sdl 0x4(%r14), %xmm0
mulsd 0x4698b(%rip), %xmm0    # 0x608a8
mulsd 0x4698b(%rip), %xmm1    # 0x608b0
addsd %xmm0, %xmm1
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 0x19e07
popq %rax
popq %rcx
testq %rbx, %rbx
je 0x19f8d
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 0x47367(%rip), %rsi     # 0x612e4
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x8110
popq %rcx
popq %rdx
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19e07
popq %rax
popq %rcx
testq %rbx, %rbx
je 0x19ffd
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 0x472f7(%rip), %rsi     # 0x612e4
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x8110
popq %rcx
popq %rdx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq