LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15ddf
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 0x17b76
movq %rax, %r12
movq (%r14), %rax
addq $0x8, %rax
cmpq %rax, %r12
setne %bl
je 0x15dc4
testq %r15, %r15
je 0x15db9
movq %r12, %rsi
addq $0x30, %rsi
leaq -0x60(%rbp), %r13
movq %r13, %rdi
callq 0x13372
movzwl 0x8(%r15), %eax
movl $0xff, %edx
movl %eax, %esi
andl %edx, %esi
movzwl 0x8(%r13), %edi
andl %edi, %edx
movl $0xff00, %ecx           # imm = 0xFF00
movl %eax, %r8d
andl %ecx, %r8d
orl %edx, %r8d
movw %r8w, 0x8(%r15)
andl %edi, %ecx
orl %esi, %ecx
movw %cx, 0x8(%r13)
movq (%r15), %rdx
movq (%r13), %rsi
movq %rsi, (%r15)
movq %rdx, (%r13)
movl $0x100, %edx            # imm = 0x100
andl %edx, %edi
andl $0xfeff, %r8d           # imm = 0xFEFF
orl %edi, %r8d
movw %r8w, 0x8(%r15)
andl %edx, %eax
andl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
orl %eax, %ecx
movw %cx, 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 0x13416
movq (%r14), %rdi
movq %r12, %rsi
callq 0x1785a
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x15de1
movl -0x30(%rbp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x15de1
callq 0x87b0
jmp 0x15de1
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 0x15e0e
movl -0x30(%rbp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x15e0e
callq 0x87b0
movq %rbx, %rdi
callq 0x8b40
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15ed6
cmpl $0x7, %eax
jne 0x15ee2
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 0x17730
movq %rbx, %rdi
movq %rax, %rsi
callq 0x177f6
movq -0x1a8(%rbp), %rdi
testq %rdi, %rdi
je 0x15ed6
movl -0x1a0(%rbp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x15ed6
callq 0x87b0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x1a8(%rbp), %rbx
movq %rbx, %rdi
callq 0x8870
leaq 0x540f1(%rip), %rsi     # 0x69fe9
movl $0x34, %edx
movq %rbx, %rdi
callq 0x8730
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x8a00
leaq -0x30(%rbp), %rdi
callq 0x1288d
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15f3a
callq 0x85d0
jmp 0x15f3a
jmp 0x15f37
movq %rax, %rbx
movq 0x7807f(%rip), %rsi     # 0x8dfc0
leaq -0x1a8(%rbp), %rdi
callq 0x8370
leaq -0x138(%rbp), %rdi
callq 0x8220
jmp 0x15f7d
movq %rax, %rbx
movq -0x1a8(%rbp), %rdi
testq %rdi, %rdi
je 0x15f7d
movl -0x1a0(%rbp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x15f7d
callq 0x87b0
movq %rbx, %rdi
callq 0x8b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x164d6
cmpl $0x3, %ecx
jne 0x164d7
movsd (%rdi), %xmm0
xorl %eax, %eax
ucomisd 0x53471(%rip), %xmm0    # 0x69910
jb 0x164d6
movsd 0x5346f(%rip), %xmm1    # 0x69918
ucomisd %xmm0, %xmm1
jbe 0x164d6
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
callq 0x8b60
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_O1/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, %r15d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0x16542
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(%r14)
testq %r12, %r12
je 0x16558
leaq -0x1(%r12), %rdx
cmpb $0xa, -0x1(%rbx,%r12)
cmovneq %r12, %rdx
jmp 0x1655a
xorl %edx, %edx
movl %r15d, %edi
shlq $0x3, %rdi
addq 0x10(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1292e
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b968
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x16693
cmpq $0x0, (%rax)
leaq 0x53256(%rip), %rax     # 0x698dc
leaq 0x60806(%rip), %r15     # 0x76e93
cmoveq %rax, %r15
jmp 0x1669a
leaq 0x53242(%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 0x1126a
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %r14, %rdx
callq 0x1c374
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 0x166ea
callq 0x85d0
movq %rbx, %rdi
movl $0xa, %esi
callq 0x8530
leaq -0x70(%rbp), %rdi
callq 0x1bb84
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16729
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1672c
callq 0x85d0
jmp 0x1672c
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1673e
callq 0x85d0
jmp 0x1673e
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x1bb84
movq %r14, %rdi
callq 0x8b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x170ea
movq %r14, -0x30(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x1690d
movq %r14, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x1691a
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x17f92
movq %r13, -0x30(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x16932
movq %r13, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x1693f
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x17f92
movq %r12, -0x30(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x16957
movq %r12, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x16964
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x17f92
movq %r15, -0x30(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x1697c
movq %r15, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x16989
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x17f92
movq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x169a5
movq %rax, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x169b2
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x17f92
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movq -0x58(%rbp), %rsi
callq 0x16a0a
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x169d0
callq 0x85d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x169e9
jmp 0x169e9
jmp 0x169e9
jmp 0x169e9
jmp 0x169e9
movq %rax, %r14
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x169fa
callq 0x85d0
movq %rbx, %rdi
callq 0x17182
movq %r14, %rdi
callq 0x8b40
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16c80
movq (%rax), %rdx
cmpl %r8d, 0x24(%rdx)
jne 0x16c80
leaq 0x8(%rax), %rdx
movq %rdx, (%rcx)
movq (%rax), %rsi
popq %rbp
jmp 0x171d0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x186d8
leaq -0x30(%rbp), %rax
cmpq %rax, %rsi
jb 0x18721
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x8260
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0x51ba7(%rip), %rdi     # 0x6a2cf
leaq 0x51bb2(%rip), %rsi     # 0x6a2e1
leaq 0x51bf1(%rip), %rcx     # 0x6a327
movl $0x71, %edx
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18f0a
cmpb $0x0, 0x2a(%r14)
jne 0x18ee8
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 0x1143c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19328
movq %r14, %rdi
movq %r15, %rsi
callq 0x19410
movq %r14, %rdi
movq %r15, %rsi
callq 0x1983a
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 0x1143c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x165c0
testb %al, %al
je 0x193e4
leaq 0x20(%rbx), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x8530
movq %rbx, %rdi
callq 0x19e96
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x165dc
cmpq $0x0, 0x8(%r12)
je 0x193c5
movq -0x40(%rbp), %r15
movsbl (%r15), %esi
movq %r14, %rdi
callq 0x8530
cmpb $0xa, (%r15)
jne 0x193b5
leaq 0x1(%r15), %rax
movq -0x40(%rbp), %rcx
addq -0x38(%rbp), %rcx
cmpq %rcx, %rax
je 0x193b5
cmpb $0x2f, (%rax)
jne 0x193b5
movq %rbx, %rdi
callq 0x19e96
incq %r15
movq -0x40(%rbp), %rax
addq -0x38(%rbp), %rax
cmpq %rax, %r15
jne 0x19385
movq %r14, %rdi
movl $0xa, %esi
callq 0x8530
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x193e4
callq 0x85d0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x193f3
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19408
callq 0x85d0
movq %rbx, %rdi
callq 0x8b40
// File: /workspace/github_cpp_makefile_star2_O1/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 0x199be
addq $0x8, %rdi
popq %rbp
jmp 0x1c57a
addq $0x20, %rdi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
popq %rbp
jmp 0x81f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a022
testb $0x2, 0x68(%rbx)
jne 0x19fe6
movq %rbx, %rdi
callq 0x1a112
orb $0x2, 0x68(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a148
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a560
movq 0x18(%rbx), %rdi
leaq 0x5ce88(%rip), %rsi     # 0x76e93
movl $0x1, %edx
callq 0x8730
movq $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x165c0
testb %al, %al
je 0x1a0e7
testb $0x2, 0x68(%rbx)
jne 0x1a057
movq %rbx, %rdi
callq 0x1a112
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x165dc
movq (%r15), %r12
cmpq $0x0, 0x8(%r15)
je 0x1a0d2
leaq -0x21(%rbp), %r14
movq 0x18(%rbx), %rdi
movb (%r12), %al
movb %al, -0x21(%rbp)
movl $0x1, %edx
movq %r14, %rsi
callq 0x8730
cmpb $0xa, (%r12)
jne 0x1a0bd
leaq 0x1(%r12), %rax
movq -0x48(%rbp), %rcx
addq -0x40(%rbp), %rcx
cmpq %rcx, %rax
je 0x1a0bd
cmpb $0x2f, (%rax)
jne 0x1a0bd
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x8730
incq %r12
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
addq %rdi, %rax
cmpq %rax, %r12
jne 0x1a076
jmp 0x1a0d5
movq %r12, %rdi
andb $-0x3, 0x68(%rbx)
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1a0e7
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 0x1a109
callq 0x85d0
movq %rbx, %rdi
callq 0x8b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a935
movq %rbx, %rdi
callq 0x1a112
movq 0x18(%rbx), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x8730
andb $-0x3, 0x68(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ad68
testb $0x2, 0xd8(%rbx)
jne 0x1ad24
movq %rbx, %rdi
callq 0x1ae68
orb $0x2, 0xd8(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1aea4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b29e
movq 0x8(%rbx), %rdi
movq 0xb8(%rbx), %rsi
movq 0xc0(%rbx), %rdx
callq 0x8730
movq $0x0, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ae3d
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x165c0
testb %al, %al
je 0x1ae3d
testb $0x2, 0xd8(%rbx)
jne 0x1adaa
movq %rbx, %rdi
callq 0x1ae68
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x165dc
movq (%r15), %r12
cmpq $0x0, 0x8(%r15)
je 0x1ae25
leaq -0x21(%rbp), %r14
movq 0x8(%rbx), %rdi
movb (%r12), %al
movb %al, -0x21(%rbp)
movl $0x1, %edx
movq %r14, %rsi
callq 0x8730
cmpb $0xa, (%r12)
jne 0x1ae10
leaq 0x1(%r12), %rax
movq -0x48(%rbp), %rcx
addq -0x40(%rbp), %rcx
cmpq %rcx, %rax
je 0x1ae10
cmpb $0x2f, (%rax)
jne 0x1ae10
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
callq 0x8730
incq %r12
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
addq %rdi, %rax
cmpq %rax, %r12
jne 0x1adc9
jmp 0x1ae28
movq %r12, %rdi
andb $-0x3, 0xd8(%rbx)
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1ae3d
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 0x1ae5f
callq 0x85d0
movq %rbx, %rdi
callq 0x8b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b3c9
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x165c0
testb %al, %al
je 0x1b377
movq 0x8(%r14), %r15
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x165dc
leaq 0x5a204(%rip), %rcx     # 0x754f5
movl $0x1, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x8700
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1b328
movq %rdx, -0x40(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x30(%rbp)
jmp 0x1b330
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, -0x38(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %r15, %rdi
callq 0x8730
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1b365
callq 0x85d0
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b377
callq 0x85d0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x165c0
testb %al, %al
je 0x1b3c9
movq %r14, %rdi
callq 0x1ae68
movq 0x8(%r14), %r14
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x165dc
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x8730
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b3c9
callq 0x85d0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
jmp 0x1b3f9
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1b3f5
callq 0x85d0
jmp 0x1b3f5
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b407
callq 0x85d0
movq %rbx, %rdi
callq 0x8b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b427
addq $0x10, %rdi
popq %rbp
jmp 0x1c57a
movq 0x8(%rdi), %rdi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
popq %rbp
jmp 0x8730
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b750
movq %rbx, %rdi
callq 0x1ae68
movq 0x8(%rbx), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x8730
andb $-0x3, 0xd8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8870
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 0x8a00
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x71be9(%rip), %rsi     # 0x8dfc0
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 0x1c411
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x71ba8(%rip), %rsi     # 0x8dfc0
leaq -0x190(%rbp), %rdi
callq 0x8370
leaq -0x120(%rbp), %rdi
callq 0x8220
movq %rbx, %rdi
callq 0x8b40
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b968
movq %r14, %rdi
callq 0x1bbc6
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 0x70e2f(%rip), %rax     # 0x8d2b0
leaq -0x40(%rbp), %rdi
movq %rax, -0x8(%rdi)
callq 0x13416
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 0x1c4ad
movq %rax, %rbx
leaq 0x70dfc(%rip), %rax     # 0x8d2b0
leaq -0x40(%rbp), %rdi
movq %rax, -0x8(%rdi)
callq 0x13416
movq %rbx, %rdi
callq 0x8b40
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8750
movl %r14d, %eax
shrl $0x8, %eax
movl $0xff, %ecx
andl %ecx, %eax
leaq 0x4e1a0(%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)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4e403
movq %rbx, %rdi
movl $0x8, %esi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x4e403
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movsd -0x30(%rbp), %xmm0
movq %r14, %rcx
callq 0x1caee
movl %eax, 0x808(%rbx)
testl %eax, %eax
je 0x1ca84
movl %eax, %r14d
testb $0x7, %r14b
je 0x1ca60
movq %rbx, %rdi
movl %r14d, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x4e403
incl %r14d
jmp 0x1ca43
movl %r14d, %ecx
sarl $0x3, %ecx
movl %ecx, 0x804(%rbx)
cmpl $0x7fd, %ecx            # imm = 0x7FD
jb 0x1ca93
movq $0x0, 0x804(%rbx)
xorl %r13d, %r13d
jmp 0x1ca8f
movq $0x0, 0x804(%rbx)
xorl %eax, %eax
jmp 0x1cad8
addl $-0x3, %ecx
movq %rbx, %rdi
movl $0x8, %esi
movl $0x10, %edx
callq 0x4e403
movl 0x804(%rbx), %esi
movq %rbx, %rdi
callq 0x4e4e2
movq %rbx, %rdi
movl %r14d, %esi
movl $0x20, %edx
movl %eax, %ecx
callq 0x4e403
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_O1/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 0x1cff9
cmpl $0xc, %edx
jg 0x1cff9
movl %edx, %eax
orl %esi, %eax
orl %ecx, %eax
js 0x1cff9
testl %edx, %edx
sete %al
cmpl $0x20, %ecx
setl %dil
orb %al, %dil
je 0x1cff9
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 0x1cff8
decl %edx
leaq 0x4db1b(%rip), %rcx     # 0x6ab10
addl (%rcx,%rdx,4), %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x4e2bc(%rip), %rdi     # 0x6b2c0
xorl %eax, %eax
callq 0x8080
movl $0x1, %edi
callq 0x87c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d052
testl %esi, %esi
je 0x1d03d
movl %r14d, %edx
callq 0x1cf58
movl %eax, %r14d
jmp 0x1d052
movl $0x1, %esi
movl $0x1, %edx
callq 0x1cf58
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_O1/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 0x1cf58
movl %eax, (%r14)
cvtsi2sdl 0x8(%r15), %xmm1
cvtsi2sdl 0x4(%r15), %xmm0
mulsd 0x4d746(%rip), %xmm0    # 0x6a8b8
mulsd 0x4d746(%rip), %xmm1    # 0x6a8c0
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sdl (%r15), %xmm0
addsd %xmm1, %xmm0
addsd 0x4d736(%rip), %xmm0    # 0x6a8c8
movsd %xmm0, (%rbx)
movsd 0x4d732(%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 0x1d1de
decl %ecx
movl %ecx, (%r14)
addsd 0x4d6f6(%rip), %xmm0    # 0x6a8d0
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %xmm0, (%rdx)
movsd 0x4d6d3(%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 0x1d23b
decl %eax
movl %eax, (%rsi)
addsd 0x4d699(%rip), %xmm0    # 0x6a8d0
movsd %xmm0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d11f
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 0x1d2d2
addq $0x10, %rsp
testq %rbx, %rbx
je 0x1d2c4
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 0x4e042(%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_O1/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
movl $0x0, (%r14)
movq %r14, %rdx
callq 0x1d09a
movl (%r13), %edi
movl (%r14), %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1d4e3
movsd 0x4d59b(%rip), %xmm0    # 0x6a8c0
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 0x4d560(%rip), %xmm1    # 0x6a8b8
divsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movq -0x38(%rbp), %rcx
movl %eax, (%rcx)
xorps %xmm3, %xmm3
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_O1/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 0x1cf58
cvtsi2sdl 0x8(%r14), %xmm1
cvtsi2sdl 0x4(%r14), %xmm0
mulsd 0x4d4ca(%rip), %xmm0    # 0x6a8b8
mulsd 0x4d4ca(%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 0x1d2d2
addq $0x10, %rsp
testq %rbx, %rbx
je 0x1d465
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 0x4dea1(%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_O1/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 0x1d2d2
addq $0x10, %rsp
testq %rbx, %rbx
je 0x1d4d9
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 0x4de2d(%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_O1/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 0x4d672(%rip), %xmm0    # 0x6ab60
movaps %xmm0, -0x10(%rbp)
movaps 0x4d657(%rip), %xmm0    # 0x6ab50
movaps %xmm0, -0x20(%rbp)
movaps 0x4d63c(%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 0x1d53f
andb %dil, %al
je 0x1d546
movl $0x1d, -0x2c(%rbp)
xorl %eax, %eax
movl %esi, %edi
subl -0x30(%rbp,%rax,4), %edi
jle 0x1d55d
incq %rax
movl %edi, %esi
cmpq $0xc, %rax
jne 0x1d54a
jmp 0x1d563
movl %esi, (%rcx)
incl %eax
movl %eax, (%rdx)
popq %rbp
retq