_ZN4absl16HexStringToBytesENS_11string_viewE:
  922|    670|std::string HexStringToBytes(absl::string_view from) {
  923|    670|  std::string result;
  924|    670|  const auto num = from.size() / 2;
  925|    670|  strings_internal::STLStringResizeUninitialized(&result, num);
  926|    670|  absl::HexStringToBytesInternal<std::string&>(from.data(), result, num);
  927|    670|  return result;
  928|    670|}
_ZN4absl16BytesToHexStringENS_11string_viewE:
  930|    657|std::string BytesToHexString(absl::string_view from) {
  931|    657|  std::string result;
  932|    657|  strings_internal::STLStringResizeUninitialized(&result, 2 * from.size());
  933|    657|  absl::BytesToHexStringInternal<std::string&>(
  934|    657|      reinterpret_cast<const unsigned char*>(from.data()), result, from.size());
  935|    657|  return result;
  936|    657|}
escaping.cc:_ZN4absl12_GLOBAL__N_124HexStringToBytesInternalIRNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvPKcT_m:
  838|    670|void HexStringToBytesInternal(const char* from, T to, size_t num) {
  839|  6.27k|  for (size_t i = 0; i < num; i++) {
  ------------------
  |  Branch (839:22): [True: 5.60k, False: 670]
  ------------------
  840|  5.60k|    to[i] = static_cast<char>(kHexValueLenient[from[i * 2] & 0xFF] << 4) +
  841|  5.60k|            (kHexValueLenient[from[i * 2 + 1] & 0xFF]);
  842|  5.60k|  }
  843|    670|}
escaping.cc:_ZN4absl12_GLOBAL__N_124BytesToHexStringInternalIRNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvPKhT_m:
  848|    657|void BytesToHexStringInternal(const unsigned char* src, T dest, size_t num) {
  849|    657|  auto dest_ptr = &dest[0];
  850|  6.13k|  for (auto src_ptr = src; src_ptr != (src + num); ++src_ptr, dest_ptr += 2) {
  ------------------
  |  Branch (850:28): [True: 5.47k, False: 657]
  ------------------
  851|  5.47k|    const char* hex_p = &numbers_internal::kHexTable[*src_ptr * 2];
  852|  5.47k|    std::copy(hex_p, hex_p + 2, dest_ptr);
  853|  5.47k|  }
  854|    657|}

_ZN4absl16strings_internal28STLStringResizeUninitializedINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvEEvPT_m:
   67|  1.76k|inline void STLStringResizeUninitialized(string_type* s, size_t new_size) {
   68|  1.76k|  ResizeUninitializedTraits<string_type>::Resize(s, new_size);
   69|  1.76k|}
_ZN4absl16strings_internal25ResizeUninitializedTraitsINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvE6ResizeEPS8_m:
   47|  1.76k|  static void Resize(string_type* s, size_t new_size) {
   48|  1.76k|    s->__resize_default_init(new_size);
   49|  1.76k|  }

_ZN4absl6StrCatERKNS_8AlphaNumES2_:
   60|    219|std::string StrCat(const AlphaNum& a, const AlphaNum& b) {
   61|    219|  std::string result;
   62|    219|  absl::strings_internal::STLStringResizeUninitialized(&result,
   63|    219|                                                       a.size() + b.size());
   64|    219|  char* const begin = &result[0];
   65|    219|  char* out = begin;
   66|    219|  out = Append(out, a);
   67|    219|  out = Append(out, b);
   68|    219|  assert(out == begin + result.size());
   69|    219|  return result;
   70|    219|}
_ZN4absl16strings_internal9CatPiecesESt16initializer_listINS_11string_viewEE:
  103|    219|std::string CatPieces(std::initializer_list<absl::string_view> pieces) {
  104|    219|  std::string result;
  105|    219|  size_t total_size = 0;
  106|  1.09k|  for (absl::string_view piece : pieces) total_size += piece.size();
  ------------------
  |  Branch (106:32): [True: 1.09k, False: 219]
  ------------------
  107|    219|  strings_internal::STLStringResizeUninitialized(&result, total_size);
  108|       |
  109|    219|  char* const begin = &result[0];
  110|    219|  char* out = begin;
  111|  1.09k|  for (absl::string_view piece : pieces) {
  ------------------
  |  Branch (111:32): [True: 1.09k, False: 219]
  ------------------
  112|  1.09k|    const size_t this_size = piece.size();
  113|  1.09k|    if (this_size != 0) {
  ------------------
  |  Branch (113:9): [True: 1.09k, False: 0]
  ------------------
  114|  1.09k|      memcpy(out, piece.data(), this_size);
  115|  1.09k|      out += this_size;
  116|  1.09k|    }
  117|  1.09k|  }
  118|    219|  assert(out == begin + result.size());
  119|    219|  return result;
  120|    219|}
str_cat.cc:_ZN4absl12_GLOBAL__N_16AppendEPcRKNS_8AlphaNumE:
   43|    438|inline char* Append(char* out, const AlphaNum& x) {
   44|       |  // memcpy is allowed to overwrite arbitrary memory, so doing this after the
   45|       |  // call would force an extra fetch of x.size().
   46|    438|  char* after = out + x.size();
   47|    438|  if (x.size() != 0) {
  ------------------
  |  Branch (47:7): [True: 438, False: 0]
  ------------------
   48|    438|    memcpy(out, x.data(), x.size());
   49|    438|  }
   50|    438|  return after;
   51|    438|}

_ZN4absl8AlphaNumC2EPKc:
  354|    657|      : piece_(NullSafeStringView(c_str)) {}
_ZN4absl8AlphaNumC2INSt3__19allocatorIcEEEERKNS2_12basic_stringIcNS2_11char_traitsIcEET_EE:
  370|    876|      : piece_(str) {}
_ZNK4absl8AlphaNum4sizeEv:
  378|  1.75k|  absl::string_view::size_type size() const { return piece_.size(); }
_ZNK4absl8AlphaNum4dataEv:
  379|    438|  const char* data() const { return piece_.data(); }
_ZNK4absl8AlphaNum5PieceEv:
  380|  1.09k|  absl::string_view Piece() const { return piece_; }
_ZN4absl6StrCatIJEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS_8AlphaNumESA_SA_SA_SA_DpRKT_:
  546|    219|    const AlphaNum& e, const AV&... args) {
  547|    219|  return strings_internal::CatPieces(
  548|    219|      {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
  549|    219|       static_cast<const AlphaNum&>(args).Piece()...});
  550|    219|}

_ZN4absl11string_viewC2EPKcm:
  202|  1.66k|      : ptr_(data), length_(CheckLengthInternal(len)) {}
_ZN4absl11string_view19CheckLengthInternalEm:
  603|  1.66k|  static constexpr size_type CheckLengthInternal(size_type len) {
  604|  1.66k|    return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
  ------------------
  |  |  128|  1.66k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|  1.66k|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  605|  1.66k|  }
_ZN4absl11string_viewC2EPKc:
  198|    657|      : ptr_(str), length_(str ? StrlenInternal(str) : 0) {}
_ZNK4absl11string_view4sizeEv:
  271|  18.2k|  constexpr size_type size() const noexcept { return length_; }
_ZNK4absl11string_view6lengthEv:
  276|  12.0k|  constexpr size_type length() const noexcept { return size(); }
_ZNK4absl11string_viewixEm:
  292|  36.0k|  constexpr const_reference operator[](size_type i) const {
  293|  36.0k|    return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
  ------------------
  |  |  128|  36.0k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|  36.0k|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  294|  36.0k|  }
_ZNK4absl11string_view4dataEv:
  330|  2.86k|  constexpr const_pointer data() const noexcept { return ptr_; }
_ZNK4absl11string_view6substrEmm:
  393|    689|  constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
  394|    689|    return ABSL_PREDICT_FALSE(pos > length_)
  ------------------
  |  |  178|    689|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 689]
  |  |  |  Branch (178:49): [Folded - Ignored]
  |  |  |  Branch (178:58): [True: 0, False: 689]
  |  |  ------------------
  ------------------
  395|    689|               ? (base_internal::ThrowStdOutOfRange(
  396|      0|                      "absl::string_view::substr"),
  397|      0|                  string_view())
  398|    689|               : string_view(ptr_ + pos, Min(n, length_ - pos));
  399|    689|  }
_ZN4absl11string_viewC2EPKcmNS0_18SkipCheckLengthTagE:
  598|    876|      : ptr_(data), length_(len) {}
_ZN4absl11string_view14StrlenInternalEPKc:
  607|    657|  static constexpr size_type StrlenInternal(const char* str) {
  608|       |#if defined(_MSC_VER) && _MSC_VER >= 1910 && !defined(__clang__)
  609|       |    // MSVC 2017+ can evaluate this at compile-time.
  610|       |    const char* begin = str;
  611|       |    while (*str != '\0') ++str;
  612|       |    return str - begin;
  613|       |#elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \
  614|       |    (defined(__GNUC__) && !defined(__clang__))
  615|       |    // GCC has __builtin_strlen according to
  616|       |    // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
  617|       |    // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
  618|       |    // __builtin_strlen is constexpr.
  619|    657|    return __builtin_strlen(str);
  620|       |#else
  621|       |    return str ? strlen(str) : 0;
  622|       |#endif
  623|    657|  }
_ZN4absl11string_view3MinEmm:
  625|    689|  static constexpr size_t Min(size_type length_a, size_type length_b) {
  626|    689|    return length_a < length_b ? length_a : length_b;
  ------------------
  |  Branch (626:12): [True: 466, False: 223]
  ------------------
  627|    689|  }
_ZN4absl18NullSafeStringViewEPKc:
  697|    657|constexpr string_view NullSafeStringView(const char* p) {
  698|    657|  return p ? string_view(p) : string_view();
  ------------------
  |  Branch (698:10): [True: 657, False: 0]
  ------------------
  699|    657|}
_ZN4absl11string_viewC2INSt3__19allocatorIcEEEERKNS2_12basic_stringIcNS2_11char_traitsIcEET_EE:
  191|    876|      : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {}

_ZNK10opencensus5trace11SpanContext7IsValidEv:
   30|    323|bool SpanContext::IsValid() const {
   31|    323|  return trace_id_.IsValid() && span_id_.IsValid();
  ------------------
  |  Branch (31:10): [True: 222, False: 101]
  |  Branch (31:33): [True: 219, False: 3]
  ------------------
   32|    323|}
_ZNK10opencensus5trace11SpanContext8ToStringEv:
   34|    219|std::string SpanContext::ToString() const {
   35|    219|  return absl::StrCat(trace_id_.ToHex(), "-", span_id_.ToHex(), "-",
   36|    219|                      trace_options_.ToHex());
   37|    219|}

_ZN10opencensus5trace6SpanIdC2EPKh:
   26|    222|SpanId::SpanId(const uint8_t *buf) { memcpy(rep_, buf, kSize); }
_ZNK10opencensus5trace6SpanId5ToHexEv:
   28|    219|std::string SpanId::ToHex() const {
   29|    219|  return absl::BytesToHexString(
   30|    219|      absl::string_view(reinterpret_cast<const char *>(rep_), kSize));
   31|    219|}
_ZNK10opencensus5trace6SpanId7IsValidEv:
   39|    222|bool SpanId::IsValid() const {
   40|    222|  static_assert(kSize == 8,
   41|    222|                "IsValid assumes the internal representation is 8 bytes.");
   42|    222|  uint64_t tmp;
   43|    222|  memcpy(&tmp, rep_, kSize);
   44|    222|  return tmp != 0;
   45|    222|}

_ZN10opencensus5trace11propagation21FromTraceParentHeaderEN4absl11string_viewE:
   51|    323|SpanContext FromTraceParentHeader(absl::string_view header) {
   52|    323|  constexpr int kDelimiterLen = 1;
   53|    323|  constexpr char kDelimiter = '-';
   54|    323|  constexpr int kVersionLen = 1;
   55|    323|  constexpr int kTraceIdLen = 16;
   56|    323|  constexpr int kSpanIdLen = 8;
   57|    323|  constexpr int kTraceOptionsLen = 1;
   58|    323|  constexpr int kVersionLenHex = 2 * kVersionLen;
   59|    323|  constexpr int kTraceIdLenHex = 2 * kTraceIdLen;
   60|    323|  constexpr int kSpanIdLenHex = 2 * kSpanIdLen;
   61|    323|  constexpr int kTraceOptionsLenHex = 2 * kTraceOptionsLen;
   62|    323|  constexpr int kTotalLenInHexDigits = kVersionLenHex + kTraceIdLenHex +
   63|    323|                                       kSpanIdLenHex + kTraceOptionsLenHex +
   64|    323|                                       3 * kDelimiterLen;
   65|    323|  constexpr int kVersionOfs = 0;
   66|    323|  constexpr int kTraceIdOfs = kVersionOfs + kVersionLenHex + kDelimiterLen;
   67|    323|  constexpr int kSpanIdOfs = kTraceIdOfs + kTraceIdLenHex + kDelimiterLen;
   68|    323|  constexpr int kOptionsOfs = kSpanIdOfs + kSpanIdLenHex + kDelimiterLen;
   69|    323|  static_assert(kOptionsOfs + kTraceOptionsLenHex == kTotalLenInHexDigits,
   70|    323|                "bad offsets");
   71|    323|  static SpanContext invalid;
   72|    323|  if (header.size() != kTotalLenInHexDigits || header[kVersionOfs] != '0' ||
  ------------------
  |  Branch (72:7): [True: 29, False: 294]
  |  Branch (72:48): [True: 10, False: 284]
  ------------------
   73|    323|      header[kVersionOfs + 1] != '0' ||
  ------------------
  |  Branch (73:7): [True: 10, False: 274]
  ------------------
   74|    323|      header[kTraceIdOfs - kDelimiterLen] != kDelimiter ||
  ------------------
  |  Branch (74:7): [True: 12, False: 262]
  ------------------
   75|    323|      header[kSpanIdOfs - kDelimiterLen] != kDelimiter ||
  ------------------
  |  Branch (75:7): [True: 11, False: 251]
  ------------------
   76|    323|      header[kOptionsOfs - kDelimiterLen] != kDelimiter) {
  ------------------
  |  Branch (76:7): [True: 10, False: 241]
  ------------------
   77|     82|    return invalid;  // Invalid length, version or format.
   78|     82|  }
   79|    241|  std::string trace_id_bin, span_id_bin, options_bin;
   80|    241|  if (!FromHex(header.substr(kTraceIdOfs, kTraceIdLenHex), &trace_id_bin) ||
  ------------------
  |  Branch (80:7): [True: 16, False: 225]
  |  Branch (80:7): [True: 19, False: 222]
  ------------------
   81|    241|      !FromHex(header.substr(kSpanIdOfs, kSpanIdLenHex), &span_id_bin) ||
  ------------------
  |  Branch (81:7): [True: 2, False: 223]
  ------------------
   82|    241|      !FromHex(header.substr(kOptionsOfs, kTraceOptionsLenHex), &options_bin)) {
  ------------------
  |  Branch (82:7): [True: 1, False: 222]
  ------------------
   83|     19|    return invalid;  // Invalid hex.
   84|     19|  }
   85|    222|  return SpanContext(
   86|    222|      TraceId(reinterpret_cast<const uint8_t*>(trace_id_bin.data())),
   87|    222|      SpanId(reinterpret_cast<const uint8_t*>(span_id_bin.data())),
   88|    222|      TraceOptions(reinterpret_cast<const uint8_t*>(options_bin.data())));
   89|    241|}
_ZN10opencensus5trace11propagation19ToTraceParentHeaderERKNS0_11SpanContextE:
   91|    219|std::string ToTraceParentHeader(const SpanContext& ctx) {
   92|    219|  return absl::StrCat("00-", ctx.ToString());
   93|    219|}
trace_context.cc:_ZN10opencensus5trace11propagation12_GLOBAL__N_17FromHexEN4absl11string_viewEPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
   43|    689|bool FromHex(absl::string_view hex, std::string* bin) {
   44|    689|  if (!IsLowercaseHexDigits(hex)) return false;
  ------------------
  |  Branch (44:7): [True: 19, False: 670]
  ------------------
   45|    670|  *bin = absl::HexStringToBytes(hex);
   46|    670|  return true;
   47|    689|}
trace_context.cc:_ZN10opencensus5trace11propagation12_GLOBAL__N_120IsLowercaseHexDigitsEN4absl11string_viewE:
   33|    689|bool IsLowercaseHexDigits(absl::string_view s) {
   34|  12.0k|  for (int i = 0; i < s.length(); ++i) {
  ------------------
  |  Branch (34:19): [True: 11.3k, False: 670]
  ------------------
   35|  11.3k|    if (!((s[i] >= '0' && s[i] <= '9') || (s[i] >= 'a' && s[i] <= 'f'))) {
  ------------------
  |  Branch (35:12): [True: 11.3k, False: 13]
  |  Branch (35:27): [True: 5.41k, False: 5.95k]
  |  Branch (35:44): [True: 5.94k, False: 18]
  |  Branch (35:59): [True: 5.94k, False: 1]
  ------------------
   36|     19|      return false;
   37|     19|    }
   38|  11.3k|  }
   39|    670|  return true;
   40|    689|}

LLVMFuzzerTestOneInput:
   23|    323|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   24|    323|  absl::string_view header(reinterpret_cast<const char *>(Data), Size);
   25|    323|  SpanContext ctx = FromTraceParentHeader(header);
   26|    323|  if (ctx.IsValid()) {
  ------------------
  |  Branch (26:7): [True: 219, False: 104]
  ------------------
   27|    219|    ToTraceParentHeader(ctx);
   28|    219|  }
   29|    323|  return 0;
   30|    323|}

_ZN10opencensus5trace7TraceIdC2EPKh:
   26|    222|TraceId::TraceId(const uint8_t *buf) { memcpy(rep_, buf, kSize); }
_ZNK10opencensus5trace7TraceId5ToHexEv:
   28|    219|std::string TraceId::ToHex() const {
   29|    219|  return absl::BytesToHexString(
   30|    219|      absl::string_view(reinterpret_cast<const char *>(rep_), kSize));
   31|    219|}
_ZNK10opencensus5trace7TraceId7IsValidEv:
   39|    323|bool TraceId::IsValid() const {
   40|    323|  static_assert(kSize == 16, "Internal representation must be 16 bytes.");
   41|    323|  uint64_t tmp1;
   42|    323|  uint64_t tmp2;
   43|    323|  memcpy(&tmp1, &rep_[0], 8);
   44|    323|  memcpy(&tmp2, &rep_[8], 8);
   45|    323|  return (tmp1 != 0 || tmp2 != 0);
  ------------------
  |  Branch (45:11): [True: 107, False: 216]
  |  Branch (45:24): [True: 115, False: 101]
  ------------------
   46|    323|}

_ZN10opencensus5trace12TraceOptionsC2EPKh:
   30|    222|TraceOptions::TraceOptions(const uint8_t* buf) { memcpy(rep_, buf, kSize); }
_ZNK10opencensus5trace12TraceOptions5ToHexEv:
   38|    219|std::string TraceOptions::ToHex() const {
   39|    219|  return absl::BytesToHexString(
   40|    219|      absl::string_view(reinterpret_cast<const char*>(rep_), kSize));
   41|    219|}

_ZN10opencensus5trace11SpanContextC2Ev:
   34|      1|  SpanContext() {}
_ZN10opencensus5trace11SpanContextC2ENS0_7TraceIdENS0_6SpanIdENS0_12TraceOptionsE:
   44|    222|      : trace_id_(trace_id), span_id_(span_id), trace_options_(trace_options) {}

_ZN10opencensus5trace6SpanIdC2Ev:
   32|      1|  SpanId() : rep_{0} {}

_ZN10opencensus5trace7TraceIdC2Ev:
   32|      1|  TraceId() : rep_{0} {}

_ZN10opencensus5trace12TraceOptionsC2Ev:
   36|      1|  TraceOptions() : rep_{0} {}