LLVMFuzzerTestOneInput:
   24|    126|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   25|    126|  sentencepiece::SentencePieceProcessor fuzz_sp_processor;
   26|    126|  FuzzedDataProvider data_provider(data, size);
   27|    126|  const int nbest_size = data_provider.ConsumeIntegral<int>();
   28|    126|  const float alpha = data_provider.ConsumeFloatingPoint<float>();
   29|    126|  const std::string in_string = data_provider.ConsumeRemainingBytesAsString();
   30|       |
   31|       |  // SampleEncodeAsSerializedProto() was removed upstream; the piece-returning
   32|       |  // overload drives the same sampling path.
   33|    126|  const auto pieces =
   34|    126|      fuzz_sp_processor.SampleEncodeAsPieces(in_string, nbest_size, alpha);
   35|    126|  (void)pieces;
   36|    126|  return 0;
   37|    126|}

_ZN4absl12lts_2026081713InlinedVectorINSt3__115source_locationELm1ENS2_9allocatorIS3_EEED2Ev:
  309|    126|  ~InlinedVector() {}
_ZNK4absl12lts_2026081713InlinedVectorINSt3__115source_locationELm1ENS2_9allocatorIS3_EEE4sizeEv:
  323|    252|  size_type size() const noexcept { return storage_.GetSize(); }
_ZN4absl12lts_2026081713InlinedVectorINSt3__115source_locationELm1ENS2_9allocatorIS3_EEEC2Ev:
  128|    126|  InlinedVector() noexcept(noexcept(allocator_type())) : storage_() {}
_ZN4absl12lts_2026081713InlinedVectorINSt3__115source_locationELm1ENS2_9allocatorIS3_EEE9push_backERKS3_:
  783|    252|  void push_back(const_reference v) { static_cast<void>(emplace_back(v)); }
_ZN4absl12lts_2026081713InlinedVectorINSt3__115source_locationELm1ENS2_9allocatorIS3_EEE12emplace_backIJRKS3_EEERS3_DpOT_:
  773|    252|  reference emplace_back(Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
  774|    252|    if (ABSL_PREDICT_FALSE(size() == max_size())) {
  ------------------
  |  |  190|    252|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 252]
  |  |  |  Branch (190:49): [Folded, False: 252]
  |  |  |  Branch (190:58): [True: 0, False: 252]
  |  |  ------------------
  ------------------
  775|      0|      ThrowStdLengthError("InlinedVector::emplace_back failed length check");
  776|      0|    }
  777|    252|    return storage_.EmplaceBack(std::forward<Args>(args)...);
  778|    252|  }
_ZNK4absl12lts_2026081713InlinedVectorINSt3__115source_locationELm1ENS2_9allocatorIS3_EEE8max_sizeEv:
  328|    252|  size_type max_size() const noexcept {
  329|       |    // One bit of the size storage is used to indicate whether the inlined
  330|       |    // vector contains allocated memory. As a result, the maximum size that the
  331|       |    // inlined vector can express is the minimum of the limit of how many
  332|       |    // objects we can allocate and std::numeric_limits<size_type>::max() / 2.
  333|    252|    return (std::min)(AllocatorTraits<A>::max_size(storage_.GetAllocator()),
  334|    252|                      (std::numeric_limits<size_type>::max)() / 2);
  335|    252|  }

_ZNR4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorINS5_15source_locationEEEmEEELb0EE3getEv:
   91|    378|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026081718container_internal15CompressedTupleIJNSt3__19allocatorINS3_15source_locationEEEmEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS7_XT_EE4typeEv:
  240|    378|  constexpr ElemT<I>& get() & {
  241|    378|    return StorageT<I>::get();
  242|    378|  }
_ZNKR4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorINS5_15source_locationEEEmEEELb0EE3getEv:
   90|    882|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2026081718container_internal15CompressedTupleIJNSt3__19allocatorINS3_15source_locationEEEmEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS7_XT_EE4typeEv:
  245|    882|  constexpr const ElemT<I>& get() const& {
  246|    882|    return StorageT<I>::get();
  247|    882|  }
_ZNR4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS4_15source_locationEEELm0ENS2_10StorageTagIJS7_mEEELb1EE3getEv:
  104|    252|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026081718container_internal15CompressedTupleIJNSt3__19allocatorINS3_15source_locationEEEmEE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS7_XT_EE4typeEv:
  240|    252|  constexpr ElemT<I>& get() & {
  241|    252|    return StorageT<I>::get();
  242|    252|  }
_ZN4absl12lts_2026081718container_internal15CompressedTupleIJNSt3__19allocatorINS3_15source_locationEEEmEEC2IS6_JjETnNS3_9enable_ifIXsr3stdE13conjunction_vINS3_8negationINS3_7is_sameIFvS7_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS7_JSD_DpT0_EEEEEbE4typeELb1EEEOSD_DpOSK_:
  235|    126|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  236|    126|                                             std::forward<First>(first),
  237|    126|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026081718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNSt3__19allocatorINS5_15source_locationEEEmEEENS5_16integer_sequenceImJLm0ELm1EEEELb1EEC2IJS8_jEEENS5_10in_place_tEDpOT_:
  125|    252|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  126|    252|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS4_15source_locationEEELm0ENS2_10StorageTagIJS7_mEEELb1EEC2IS7_EENS4_10in_place_tEOT_:
  101|    126|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorINS5_15source_locationEEEmEEELb0EEC2IjEENS5_10in_place_tEOT_:
   89|    126|      : value(std::forward<V>(v)) {}
_ZNKR4absl12lts_2026081718container_internal15CompressedTupleIJNSt3__19allocatorINS3_15source_locationEEEmEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemIS7_XT_EE4typeEv:
  245|    252|  constexpr const ElemT<I>& get() const& {
  246|    252|    return StorageT<I>::get();
  247|    252|  }
_ZNKR4absl12lts_2026081718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS4_15source_locationEEELm0ENS2_10StorageTagIJS7_mEEELb1EE3getEv:
  103|    252|  constexpr const T& get() const& { return *this; }

_ZN4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEE21GetSizeAndIsAllocatedEv:
  364|    378|  SizeType<A>& GetSizeAndIsAllocated() { return metadata_.template get<1>(); }
_ZN4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEE21DeallocateIfAllocatedEv:
  520|    126|  void DeallocateIfAllocated() {
  521|    126|    if (GetIsAllocated()) {
  ------------------
  |  Branch (521:9): [True: 0, False: 126]
  ------------------
  522|      0|      MallocAdapter<A>::Deallocate(GetAllocator(), GetAllocatedData(),
  523|      0|                                   GetAllocatedCapacity());
  524|      0|    }
  525|    126|  }
_ZNK4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEE14GetIsAllocatedEv:
  372|    378|  bool GetIsAllocated() const { return GetSizeAndIsAllocated() & 1; }
_ZNK4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEE21GetSizeAndIsAllocatedEv:
  366|    882|  const SizeType<A>& GetSizeAndIsAllocated() const {
  367|    882|    return metadata_.template get<1>();
  368|    882|  }
_ZN4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEE12GetAllocatorEv:
  419|    252|  A& GetAllocator() { return metadata_.template get<0>(); }
_ZN4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEE14GetInlinedDataEv:
  396|    252|  ABSL_ATTRIBUTE_NO_SANITIZE_CFI Pointer<A> GetInlinedData() {
  397|    252|    return reinterpret_cast<Pointer<A>>(data_.inlined.inlined_data);
  398|    252|  }
_ZNK4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEE7GetSizeEv:
  370|    504|  SizeType<A> GetSize() const { return GetSizeAndIsAllocated() >> 1; }
_ZN4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEED2Ev:
  342|    126|  ~Storage() {
  343|       |    // Fast path: if we are empty and not allocated, there's nothing to do.
  344|    126|    if (GetSizeAndIsAllocated() == 0) {
  ------------------
  |  Branch (344:9): [True: 0, False: 126]
  ------------------
  345|      0|      return;
  346|      0|    }
  347|       |
  348|       |    // Fast path: if no destructors need to be run and we know the allocator
  349|       |    // doesn't do anything fancy, then all we need to do is deallocate (and
  350|       |    // maybe not even that).
  351|    126|    if (std::is_trivially_destructible_v<ValueType<A>> &&
  ------------------
  |  Branch (351:9): [True: 0, Folded]
  ------------------
  352|    126|        std::is_same_v<A, std::allocator<ValueType<A>>>) {
  ------------------
  |  Branch (352:9): [True: 0, Folded]
  ------------------
  353|    126|      DeallocateIfAllocated();
  354|    126|      return;
  355|    126|    }
  356|       |
  357|      0|    DestroyContents();
  358|      0|  }
_ZN4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEEC2Ev:
  337|    126|  Storage() : metadata_(A(), /* size and is_allocated */ 0u) {}
_ZNK4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEE12GetAllocatorEv:
  421|    252|  const A& GetAllocator() const { return metadata_.template get<0>(); }
_ZN4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEE11EmplaceBackIJRKS4_EEERS4_DpOT_:
  816|    252|auto Storage<T, N, A>::EmplaceBack(Args&&... args) -> Reference<A> {
  817|    252|  StorageView<A> storage_view = MakeStorageView();
  818|    252|  const SizeType<A> n = storage_view.size;
  819|    252|  if (ABSL_PREDICT_TRUE(n != storage_view.capacity)) {
  ------------------
  |  |  191|    252|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 252, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 252]
  |  |  |  Branch (191:57): [True: 252, False: 0]
  |  |  ------------------
  ------------------
  820|       |    // Fast path; new element fits.
  821|    252|    Pointer<A> last_ptr = storage_view.data + n;
  822|    252|    AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
  823|    252|                                  std::forward<Args>(args)...);
  824|    252|    AddSize(1);
  825|    252|    return *last_ptr;
  826|    252|  }
  827|       |  // TODO(b/173712035): Annotate with musttail attribute to prevent regression.
  828|      0|  return EmplaceBackSlow(std::forward<Args>(args)...);
  829|    252|}
_ZN4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEE15MakeStorageViewEv:
  412|    252|  StorageView<A> MakeStorageView() {
  413|    252|    return GetIsAllocated() ? StorageView<A>{GetAllocatedData(), GetSize(),
  ------------------
  |  Branch (413:12): [True: 0, False: 252]
  ------------------
  414|      0|                                             GetAllocatedCapacity()}
  415|    252|                            : StorageView<A>{GetInlinedData(), GetSize(),
  416|    252|                                             GetInlinedCapacity()};
  417|    252|  }
_ZNK4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEE18GetInlinedCapacityEv:
  408|    252|  SizeType<A> GetInlinedCapacity() const {
  409|    252|    return static_cast<SizeType<A>>(kOptimalInlinedSize);
  410|    252|  }
_ZN4absl12lts_2026081723inlined_vector_internal7StorageINSt3__115source_locationELm1ENS3_9allocatorIS4_EEE7AddSizeEm:
  474|    252|  void AddSize(SizeType<A> count) {
  475|    252|    GetSizeAndIsAllocated() += count << static_cast<SizeType<A>>(1);
  476|    252|  }

_ZNK4absl12lts_2026081715status_internal9StatusRep5UnrefEv:
   54|    126|void StatusRep::Unref() const {
   55|       |  // Fast path: if ref==1, there is no need for a RefCountDec (since
   56|       |  // this is the only reference and therefore no other thread is
   57|       |  // allowed to be mucking with r).
   58|    126|  if (ref_.load(std::memory_order_acquire) == 1 ||
  ------------------
  |  Branch (58:7): [True: 126, False: 0]
  ------------------
   59|    126|      ref_.fetch_sub(1, std::memory_order_acq_rel) - 1 == 0) {
  ------------------
  |  Branch (59:7): [True: 0, False: 0]
  ------------------
   60|    126|    delete this;
   61|    126|  }
   62|    126|}
_ZN4absl12lts_2026081715status_internal9StatusRep17AddSourceLocationENSt3__115source_locationE:
  142|    252|void StatusRep::AddSourceLocation(absl::SourceLocation loc) {
  143|    252|  source_locations_.push_back(loc);
  144|    252|}
_ZNK4absl12lts_2026081715status_internal9StatusRep5CloneENS0_12optional_refINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEbb:
  218|    252|    bool include_source_locations) const {
  219|       |  // Optimization: no need to create a clone if we already have a refcount of 1.
  220|    252|  if (ref_.load(std::memory_order_acquire) == 1 && !new_message.has_value() &&
  ------------------
  |  Branch (220:7): [True: 252, False: 0]
  |  Branch (220:52): [True: 252, False: 0]
  ------------------
  221|    252|      include_payloads && include_source_locations) {
  ------------------
  |  Branch (221:7): [True: 252, False: 0]
  |  Branch (221:27): [True: 252, False: 0]
  ------------------
  222|       |    // All StatusRep instances are heap allocated and mutable, therefore this
  223|       |    // const_cast will never cast away const from a stack instance.
  224|       |    //
  225|       |    // CloneAndUnref is the only method that doesn't involve an external cast to
  226|       |    // get a mutable StatusRep* from the uintptr_t rep stored in Status.
  227|    252|    return const_cast<StatusRep*>(this);
  228|    252|  }
  229|      0|  std::unique_ptr<status_internal::Payloads> payloads;
  230|      0|  if (include_payloads && payloads_) {
  ------------------
  |  Branch (230:7): [True: 0, False: 0]
  |  Branch (230:27): [True: 0, False: 0]
  ------------------
  231|      0|    payloads = std::make_unique<status_internal::Payloads>(*payloads_);
  232|      0|  }
  233|      0|  auto* new_rep =
  234|      0|      new StatusRep(code_, new_message.value_or(message_), std::move(payloads));
  235|      0|  if (include_source_locations) {
  ------------------
  |  Branch (235:7): [True: 0, False: 0]
  ------------------
  236|      0|    new_rep->source_locations_ = source_locations_;
  237|      0|  }
  238|      0|  return new_rep;
  239|    252|}
_ZNK4absl12lts_2026081715status_internal9StatusRep13CloneAndUnrefEv:
  241|    252|StatusRep* absl_nonnull StatusRep::CloneAndUnref() const {
  242|    252|  return CloneAndUnref(std::nullopt, true, true);
  243|    252|}
_ZNK4absl12lts_2026081715status_internal9StatusRep13CloneAndUnrefENS0_12optional_refINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEbb:
  247|    252|    bool include_source_locations) const {
  248|    252|  StatusRep* new_rep =
  249|    252|      Clone(new_message, /*include_payloads=*/include_payloads,
  250|    252|            /*include_source_locations=*/include_source_locations);
  251|    252|  if (new_rep != this) {
  ------------------
  |  Branch (251:7): [True: 0, False: 252]
  ------------------
  252|      0|    Unref();
  253|      0|  }
  254|    252|  return new_rep;
  255|    252|}

_ZN4absl12lts_2026081715status_internal9StatusRepC2ENS0_10StatusCodeENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS4_10unique_ptrINS0_13InlinedVectorINS1_7PayloadELm1ENS4_9allocatorISB_EEEENS4_14default_deleteISE_EEEE:
   90|    126|      : ref_(int32_t{1}),
   91|    126|        code_(code_arg),
   92|    126|        message_(message_arg),
   93|    126|        payloads_(std::move(payloads_arg)) {}

_ZN4absl12lts_202608176Status21MakeRepFromStringViewEmNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS2_15source_locationE:
  129|    126|                                        absl::SourceLocation loc) {
  130|    126|  return MakeStatusRepImpl<absl::string_view>(inlined_rep, msg, loc);
  131|    126|}
_ZN4absl12lts_202608176Status21AddSourceLocationImplEmNSt3__115source_locationE:
  142|    252|                                        absl::SourceLocation loc) {
  143|    252|  if (IsInlined(rep)) return rep;
  ------------------
  |  Branch (143:7): [True: 0, False: 252]
  ------------------
  144|    252|  if (loc.file_name()[0] == '\0') return rep;
  ------------------
  |  Branch (144:7): [True: 0, False: 252]
  ------------------
  145|    252|  status_internal::StatusRep* rep_ptr = PrepareToModify(rep);
  146|    252|  rep_ptr->AddSourceLocation(loc);
  147|    252|  return PointerToRep(rep_ptr);
  148|    252|}
_ZN4absl12lts_202608176Status15PrepareToModifyEm:
  151|    252|    uintptr_t rep) {
  152|    252|  if (IsInlined(rep)) {
  ------------------
  |  Branch (152:7): [True: 0, False: 252]
  ------------------
  153|      0|    return new status_internal::StatusRep(InlinedRepToCode(rep),
  154|      0|                                          absl::string_view(), nullptr);
  155|      0|  }
  156|    252|  return RepToPointer(rep)->CloneAndUnref();
  157|    252|}
_ZN4absl12lts_2026081717MakeStatusRepImplINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEmmT_NS2_15source_locationE:
  109|    126|                            absl::SourceLocation loc) {
  110|    126|  static_assert(std::is_same_v<StringOrView, absl::string_view> ||
  111|    126|                std::is_same_v<StringOrView, std::string&&>);
  112|    126|  bool ok = inlined_rep == Status::CodeToInlinedRep(absl::StatusCode::kOk);
  113|    126|  if (ok) return inlined_rep;
  ------------------
  |  Branch (113:7): [True: 0, False: 126]
  ------------------
  114|    126|  if (msg.empty()
  ------------------
  |  Branch (114:7): [True: 126, False: 0]
  ------------------
  115|    126|  ) {
  116|    126|    return inlined_rep;
  117|    126|  }
  118|      0|  auto* rep =
  119|      0|      new status_internal::StatusRep(Status::InlinedRepToCode(inlined_rep),
  120|      0|                                     std::forward<StringOrView>(msg), nullptr);
  121|      0|  if (loc.file_name()[0] != '\0') {
  ------------------
  |  Branch (121:7): [True: 0, False: 0]
  ------------------
  122|      0|    rep->AddSourceLocation(loc);
  123|      0|  }
  124|      0|  return Status::PointerToRep(rep);
  125|    126|}

_ZN4absl12lts_202608176Status17AddSourceLocationENSt3__115source_locationE:
  683|    252|      absl::SourceLocation loc = absl::SourceLocation::current()) {
  684|    252|    if (ok()) return;
  ------------------
  |  Branch (684:9): [True: 0, False: 252]
  ------------------
  685|    252|    rep_ = AddSourceLocationImpl(rep_, loc);
  686|    252|    [[maybe_unused]] bool okay = ok();
  687|       |    // This hint tells the optimizer that the status is still not ok after the
  688|       |    // AddSourceLocation() call. This is useful when passing a known !ok status
  689|       |    // to StatusOr. StatusOr checks for ok() on its constructor and this assume
  690|       |    // helps the optimizer remove that check.
  691|    252|    ABSL_ASSUME(!okay);
  ------------------
  |  |  272|    252|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  692|    252|  }
_ZN4absl12lts_202608176Status16InlinedRepToCodeEm:
 1097|    126|constexpr absl::StatusCode Status::InlinedRepToCode(uintptr_t rep) {
 1098|    126|  ABSL_ASSERT(IsInlined(rep));
  ------------------
  |  |  131|    126|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|    126|#define ABSL_INTERNAL_UNEVALUATED(expr) (decltype((void)(expr))())
  |  |  ------------------
  ------------------
 1099|    126|  return static_cast<absl::StatusCode>(rep >> 2);
 1100|    126|}
_ZN4absl12lts_202608176Status12PointerToRepEPNS0_15status_internal9StatusRepE:
 1113|    378|    status_internal::StatusRep* absl_nonnull rep) {
 1114|    378|  return reinterpret_cast<uintptr_t>(rep);
 1115|    378|}

_ZN4absl12lts_2026081713StatusBuilder3RepC2EONS0_6StatusE:
   55|    252|StatusBuilder::Rep::Rep(absl::Status&& s) : status(std::move(s)) {}
_ZN4absl12lts_2026081713StatusBuilder3RepD2Ev:
   56|    252|StatusBuilder::Rep::~Rep() = default;
_ZN4absl12lts_2026081713StatusBuilder11InitRepImplENS0_6StatusE:
   58|    252|StatusBuilder::Rep* StatusBuilder::InitRepImpl(absl::Status s) {
   59|    252|  if (s.ok()) {
  ------------------
  |  Branch (59:7): [True: 0, False: 252]
  ------------------
   60|      0|    return nullptr;
   61|    252|  } else {
   62|    252|    return new Rep(std::move(s));
   63|    252|  }
   64|    252|}
_ZN4absl12lts_2026081713StatusBuilder3Rep10InitStreamEv:
   83|    126|void StatusBuilder::Rep::InitStream() { stream.emplace(stream_message); }
_ZN4absl12lts_2026081713StatusBuilder31CreateStatusAndConditionallyLogENSt3__115source_locationENS2_10unique_ptrINS1_3RepENS2_14default_deleteIS5_EEEE:
  163|    252|    absl::SourceLocation loc, std::unique_ptr<Rep> rep) {
  164|    252|  if (rep == nullptr) return absl::OkStatus();
  ------------------
  |  Branch (164:7): [True: 0, False: 252]
  ------------------
  165|    252|  absl::Status result = status_internal::StatusPrivateAccessorForStatusBuilder::
  166|    252|      JoinMessageToStatus(std::move(rep->status), rep->stream_message,
  167|    252|                          rep->message_join_style);
  168|       |  // Passing in the `loc` last to ensure the sequence of the source locations.
  169|    252|  result.AddSourceLocation(loc);
  170|    252|  return result;
  171|    252|}
_ZN4absl12lts_2026081715status_internal37StatusPrivateAccessorForStatusBuilder19JoinMessageToStatusENS0_6StatusENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS0_16MessageJoinStyleE:
  136|    252|                                          MessageJoinStyle style) {
  137|    252|    if (s.ok() || msg.empty()) return s;
  ------------------
  |  Branch (137:9): [True: 0, False: 252]
  |  Branch (137:19): [True: 126, False: 126]
  ------------------
  138|    126|    const absl::string_view original_message = s.message();
  139|    126|    switch (style) {
  140|    126|      case MessageJoinStyle::kAnnotate: {
  ------------------
  |  Branch (140:7): [True: 126, False: 0]
  ------------------
  141|    126|        std::string annotated;
  142|    126|        if (!original_message.empty()) {
  ------------------
  |  Branch (142:13): [True: 0, False: 126]
  ------------------
  143|      0|          absl::StrAppend(&annotated, original_message, "; ", msg);
  144|      0|          msg = annotated;
  145|      0|        }
  146|    126|        return SetMessage(s, msg);
  147|      0|      }
  148|      0|      case MessageJoinStyle::kPrepend:
  ------------------
  |  Branch (148:7): [True: 0, False: 126]
  ------------------
  149|      0|        return SetMessage(s, absl::StrCat(msg, original_message));
  150|      0|      case MessageJoinStyle::kAppend:
  ------------------
  |  Branch (150:7): [True: 0, False: 126]
  ------------------
  151|      0|        return SetMessage(s, absl::StrCat(original_message, msg));
  152|      0|      default:
  ------------------
  |  Branch (152:7): [True: 0, False: 126]
  ------------------
  153|      0|        return absl::InternalError("Unknown MessageJoinStyle");
  154|    126|    }
  155|    126|  }
_ZN4absl12lts_2026081715status_internal37StatusPrivateAccessorForStatusBuilder10SetMessageERKNS0_6StatusENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE:
  115|    126|                                 absl::string_view message) {
  116|    126|    ABSL_ASSERT(!status.ok());
  ------------------
  |  |  131|    126|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|    126|#define ABSL_INTERNAL_UNEVALUATED(expr) (decltype((void)(expr))())
  |  |  ------------------
  ------------------
  117|       |
  118|    126|    if (message.empty()) {
  ------------------
  |  Branch (118:9): [True: 0, False: 126]
  ------------------
  119|      0|      return absl::Status(status.code(), message, absl::SourceLocation());
  120|      0|    }
  121|       |
  122|    126|    using StatusRep =
  123|    126|        std::remove_cv_t<std::remove_pointer_t<decltype(Status::RepToPointer(
  124|    126|            std::declval<uintptr_t>()))>>;
  125|    126|    StatusRep* rep;
  126|    126|    if (Status::IsInlined(status.rep_)) {
  ------------------
  |  Branch (126:9): [True: 126, False: 0]
  ------------------
  127|    126|      rep = new StatusRep(Status::InlinedRepToCode(status.rep_), message,
  128|    126|                          nullptr);
  129|    126|    } else {
  130|      0|      rep = Status::RepToPointer(status.rep_)->Clone(message, true, true);
  131|      0|    }
  132|    126|    return absl::Status(Status::PointerToRep(rep));
  133|    126|  }

_ZN4absl12lts_2026081715status_internal6StreamC2ERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   57|    126|      : ostringstream_(&message), absl_stringify_stream_(ostringstream_) {}

_ZN4absl12lts_2026081716strings_internal13OStringStream9Streambuf6xsputnEPKcl:
   35|    882|                                                 std::streamsize n) {
   36|       |  assert(str_);
   37|    882|  str_->append(s, static_cast<size_t>(n));
   38|    882|  return n;
   39|    882|}

_ZN4absl12lts_2026081716strings_internal13OStringStream9StreambufC2EPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE:
   93|    126|    explicit Streambuf(std::string* str) : str_(str) {}
_ZN4absl12lts_2026081716strings_internal13OStringStreamC1EPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   73|    126|      : std::ostream(&buf_), buf_(str) {}

_ZN4absl12lts_2026081716strings_internal15StringifyStreamC2ERNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEE:
   64|    126|  explicit StringifyStream(std::ostream& os) : sink_{os} {}

_ZN4absl12lts_202608178DurationC2Ev:
  185|    252|  constexpr Duration() : rep_hi_(0), rep_lo_(0) {}  // zero-length duration

_ZNK4absl12lts_2026081712optional_refINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEE9has_valueEv:
  132|    252|  constexpr bool has_value() const { return ptr_ != nullptr; }
_ZN4absl12lts_2026081712optional_refINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEC2ENS2_9nullopt_tE:
   89|    252|      : ptr_(nullptr) {}

_ZN6google8protobuf8internal24InitProtobufDefaultsSlowEv:
  104|      2|void InitProtobufDefaultsSlow() {
  105|      2|  static bool is_inited = InitProtobufDefaultsImpl();
  106|      2|  (void)is_inited;
  107|      2|}
generated_message_util.cc:_ZN6google8protobuf8internalL24InitProtobufDefaultsImplEv:
   93|      2|static bool InitProtobufDefaultsImpl() {
   94|      2|  if (auto* to_destroy = fixed_address_empty_string.Init()) {
  ------------------
  |  Branch (94:13): [True: 0, False: 2]
  ------------------
   95|      0|    OnShutdownDestroyString(to_destroy);
   96|      0|  }
   97|      2|  InitWeakDefaults();
   98|       |
   99|       |
  100|      2|  init_protobuf_defaults_state.store(true, std::memory_order_release);
  101|      2|  return true;
  102|      2|}
generated_message_util.cc:_ZN6google8protobuf8internalL16InitWeakDefaultsEv:
   72|      2|static void InitWeakDefaults() {
   73|       |  // force link the dummy entry.
   74|      2|  StrongPointer<DummyWeakDefault*, &dummy_weak_default>();
   75|       |  // We don't know the size of each object, but we know the layout of the tail.
   76|       |  // It contains a WeakDescriptorDefaultTail object.
   77|       |  // As such, we iterate the section backwards.
   78|      2|  const char* start = &__start_pb_defaults;
   79|      2|  const char* end = &__stop_pb_defaults;
   80|      4|  while (start != end) {
  ------------------
  |  Branch (80:10): [True: 2, False: 2]
  ------------------
   81|      2|    auto* tail = reinterpret_cast<const WeakDescriptorDefaultTail*>(end) - 1;
   82|      2|    end -= tail->size;
   83|      2|    const MessageGlobalsBase* instance =
   84|      2|        reinterpret_cast<const MessageGlobalsBase*>(end);
   85|      2|    *tail->target = instance;
   86|      2|  }
   87|      2|}

_ZNK6google8protobuf8internal26GlobalEmptyStringConstexpr4InitEv:
  867|      2|  std::string* Init() const { return nullptr; }
_ZN6google8protobuf8internal13StrongPointerIPNS1_16DummyWeakDefaultETnT_XadL_ZNS1_18dummy_weak_defaultEEEEEvv:
   74|      2|PROTOBUF_ALWAYS_INLINE void StrongPointer() {
   75|       |  // This injects a relocation in the code path without having to run code, but
   76|       |  // we can only do it with a newer clang.
   77|      2|  asm(".reloc ., BFD_RELOC_NONE, %p0" ::"Ws"(ptr));
   78|      2|}

_ZN4absl12lts_202608176StatusD2Ev:
 1008|  1.13k|inline Status::~Status() { Unref(rep_); }
_ZN4absl12lts_202608176Status5UnrefEm:
 1121|  1.13k|inline void Status::Unref(uintptr_t rep) {
 1122|  1.13k|  if (!IsInlined(rep)) RepToPointer(rep)->Unref();
  ------------------
  |  Branch (1122:7): [True: 126, False: 1.00k]
  ------------------
 1123|  1.13k|}
_ZN4absl12lts_202608176Status9IsInlinedEm:
 1089|  2.01k|constexpr bool Status::IsInlined(uintptr_t rep) { return (rep & 1) != 0; }
_ZN4absl12lts_202608176Status12RepToPointerEm:
 1107|    378|    uintptr_t rep) {
 1108|    378|  assert(!IsInlined(rep));
  ------------------
  |  Branch (1108:3): [True: 126, False: 252]
  ------------------
 1109|    126|  return reinterpret_cast<const status_internal::StatusRep*>(rep);
 1110|    378|}

_ZNK13sentencepiece22SentencePieceProcessor20SampleEncodeAsPiecesENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEif:
  316|    126|      absl::string_view input, int nbest_size, float alpha) const {
  317|    126|    DEFINE_SPP_DIRECT_FUNC_IMPL(SampleEncode, std::vector<std::string>, input,
  ------------------
  |  |  286|    126|  OutType output;                                           \
  |  |  287|    126|  const auto status = FuncName(__VA_ARGS__, &output);       \
  |  |  288|    126|  return output;
  ------------------
  318|    126|                                nbest_size, alpha);
  319|      0|  }

_ZN13sentencepiece22SentencePieceProcessorC2Ev:
   75|    126|SentencePieceProcessor::SentencePieceProcessor() {}
_ZN13sentencepiece22SentencePieceProcessorD2Ev:
   76|    126|SentencePieceProcessor::~SentencePieceProcessor() {}
_ZNK13sentencepiece22SentencePieceProcessor6statusEv:
  145|    126|absl::Status SentencePieceProcessor::status() const {
  146|    126|  RET_CHECK(model_) << "Model is not initialized.";
  ------------------
  |  |   23|    252|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (23:7): [True: 0, False: 126]
  |  |  ------------------
  |  |   24|      0|  } else /* NOLINT */                                         \
  |  |   25|    252|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |   26|    126|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  147|      0|  RET_CHECK(normalizer_) << "Normalizer is not initialized.";
  ------------------
  |  |   23|      0|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (23:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   24|      0|  } else /* NOLINT */                                         \
  |  |   25|      0|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |   26|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  148|      0|  ABSL_RETURN_IF_ERROR(model_->status());
  ------------------
  |  |   90|      0|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  ------------------
  |  |  |  |  162|      0|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  ------------------
  |  |  |  |  |  |  349|      0|  switch (0)                                           \
  |  |  |  |  |  |  350|      0|  case 0:                                              \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (350:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  351|      0|  default:  // NOLINT
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  163|      0|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (163:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  164|      0|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  165|      0|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  167|      0|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  ------------------
  ------------------
  149|      0|  ABSL_RETURN_IF_ERROR(normalizer_->status());
  ------------------
  |  |   90|      0|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  ------------------
  |  |  |  |  162|      0|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  ------------------
  |  |  |  |  |  |  349|      0|  switch (0)                                           \
  |  |  |  |  |  |  350|      0|  case 0:                                              \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (350:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  351|      0|  default:  // NOLINT
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  163|      0|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (163:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  164|      0|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  165|      0|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  167|      0|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  ------------------
  ------------------
  150|      0|  return absl::OkStatus();
  151|      0|}
_ZNK13sentencepiece22SentencePieceProcessor12SampleEncodeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEifPNS1_6vectorINS1_12basic_stringIcS4_NS1_9allocatorIcEEEENS8_ISA_EEEE:
  234|    126|    std::vector<std::string>* pieces) const {
  235|    126|  RET_CHECK_STATUS_STL(pieces);
  ------------------
  |  |  154|    126|  ABSL_RETURN_IF_ERROR(status());                     \
  |  |  ------------------
  |  |  |  |   90|    126|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|    252|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|    252|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|    252|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 126, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|    126|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 126]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|    252|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 0, False: 126]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|    252|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|    252|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|    252|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  155|    126|  RET_CHECK(container) << "output container is null"; \
  |  |  ------------------
  |  |  |  |   23|      0|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (23:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   24|      0|  } else /* NOLINT */                                         \
  |  |  |  |   25|      0|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |   26|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  156|      0|  container->clear();
  ------------------
  236|       |
  237|      0|  Arena arena;
  238|      0|  auto* spt = Arena::Create<SentencePieceText>(&arena);
  239|      0|  ABSL_RETURN_IF_ERROR(SampleEncode(input, nbest_size, alpha, spt));
  ------------------
  |  |   90|      0|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  ------------------
  |  |  |  |  162|      0|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  ------------------
  |  |  |  |  |  |  349|      0|  switch (0)                                           \
  |  |  |  |  |  |  350|      0|  case 0:                                              \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (350:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  351|      0|  default:  // NOLINT
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  163|      0|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (163:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  164|      0|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  165|      0|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  167|      0|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  ------------------
  ------------------
  240|      0|  pieces->reserve(spt->pieces().size());
  241|      0|  for (const auto& sp : spt->pieces()) {
  ------------------
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    pieces->emplace_back(sp.piece());
  243|      0|  }
  244|       |
  245|      0|  return absl::OkStatus();
  246|      0|}

_ZN4absl12lts_202608176StatusC2Em:
  770|  1.26k|  explicit Status(uintptr_t rep) : rep_(rep) {}
_ZNK4absl12lts_202608176Status2okEv:
 1010|  1.38k|inline bool Status::ok() const {
 1011|  1.38k|  return rep_ == CodeToInlinedRep(absl::StatusCode::kOk);
 1012|  1.38k|}
_ZNK4absl12lts_202608176Status7messageEv:
 1023|    126|inline absl::string_view Status::message() const {
 1024|    126|  return !IsInlined(rep_)
  ------------------
  |  Branch (1024:10): [True: 0, False: 126]
  ------------------
 1025|    126|             ? RepToPointer(rep_)->message()
 1026|    126|             : (IsMovedFrom(rep_) ? absl::string_view(kMovedFromString)
  ------------------
  |  Branch (1026:17): [True: 0, False: 126]
  ------------------
 1027|    126|                                  : absl::string_view());
 1028|    126|}
_ZN4absl12lts_202608176Status11IsMovedFromEm:
 1091|    126|constexpr bool Status::IsMovedFrom(uintptr_t rep) { return (rep & 2) != 0; }
_ZN4absl12lts_202608176Status16CodeToInlinedRepENS0_10StatusCodeE:
 1093|  2.64k|constexpr uintptr_t Status::CodeToInlinedRep(absl::StatusCode code) {
 1094|  2.64k|  return (static_cast<uintptr_t>(code) << 2) + 1;
 1095|  2.64k|}
_ZN4absl12lts_202608176Status12MovedFromRepEv:
 1102|  1.00k|constexpr uintptr_t Status::MovedFromRep() {
 1103|  1.00k|  return CodeToInlinedRep(absl::StatusCode::kInternal) | 2;
 1104|  1.00k|}
_ZN4absl12lts_202608176StatusC2EOS1_:
  979|  1.00k|inline Status::Status(Status&& x) noexcept : Status(x.rep_) {
  980|  1.00k|  x.rep_ = MovedFromRep();
  981|  1.00k|}
_ZN4absl12lts_202608176StatusC2ENS0_10StatusCodeENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS3_15source_locationE:
  956|    126|    : Status(MakeRepFromStringView(CodeToInlinedRep(code), msg, loc)) {}

_ZN4absl12lts_2026081713StatusBuilderC2EONS0_6StatusENSt3__115source_locationE:
  775|    126|    : loc_(location), rep_(InitRep(std::move(original_status))) {}
_ZN4absl12lts_2026081713StatusBuilder7InitRepEONS0_6StatusE:
  672|    252|  static Rep* InitRep(absl::Status&& s) {
  673|    252|    if (s.ok()) {
  ------------------
  |  Branch (673:9): [True: 0, False: 252]
  ------------------
  674|      0|      return nullptr;
  675|    252|    } else {
  676|    252|      Rep* rep = InitRepImpl(std::move(s));
  677|    252|      ABSL_ASSUME(rep != nullptr);
  ------------------
  |  |  272|    252|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  678|    252|      return rep;
  679|    252|    }
  680|    252|  }
_ZNO4absl12lts_2026081713StatusBuildercvNS0_6StatusEEv:
  946|    252|inline StatusBuilder::operator absl::Status() && {
  947|       |  // Tell the compiler that the `ok()` path will return an `Ok` status, but do
  948|       |  // it only if the compiler can determine it at compile time.
  949|       |  // When it can't, we delegate this check into the out of line function.
  950|    252|  if (IsKnownToBeEmpty()) {
  ------------------
  |  Branch (950:7): [True: 0, False: 252]
  ------------------
  951|      0|    return absl::OkStatus();
  952|      0|  }
  953|    252|  absl::Status result = CreateStatusAndConditionallyLog(loc_, std::move(rep_));
  954|       |  // Tell the compiler that `rep_` was not filled again even if `this` escaped.
  955|    252|  AssumeEmpty();
  956|    252|  return result;
  957|    252|}
_ZNK4absl12lts_2026081713StatusBuilder16IsKnownToBeEmptyEv:
  570|    504|  ABSL_ATTRIBUTE_ALWAYS_INLINE bool IsKnownToBeEmpty() const {
  571|    504|#if ABSL_HAVE_BUILTIN(__builtin_constant_p)
  572|       |    // __builtin_constant_p does not like it when it has non trivial expressions
  573|       |    // in it, and `rep_==nullptr` is a user-defined operator.
  574|       |    // Do it out of the builtin and pass the bool instead.
  575|    504|    bool is_empty = rep_ == nullptr;
  576|    504|    return __builtin_constant_p(is_empty) && is_empty;
  ------------------
  |  Branch (576:12): [True: 252, False: 252]
  |  Branch (576:46): [True: 252, False: 0]
  ------------------
  577|       |#else
  578|       |    return false;
  579|       |#endif
  580|    504|  }
_ZNK4absl12lts_2026081713StatusBuilder11AssumeEmptyEv:
  584|    252|  void AssumeEmpty() const {
  585|    252|    if (rep_ != nullptr) ABSL_UNREACHABLE();
  ------------------
  |  |  237|      0|  do {                                           \
  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  ------------------
  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  ------------------
  |  |  241|      0|  } while (false)
  |  |  ------------------
  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (585:9): [True: 0, False: 252]
  ------------------
  586|    252|  }
_ZN4absl12lts_2026081713StatusBuilderD2Ev:
  777|    252|inline StatusBuilder::~StatusBuilder() {
  778|    252|  if (IsKnownToBeEmpty()) {
  ------------------
  |  Branch (778:7): [True: 252, False: 0]
  ------------------
  779|       |    // Nothing to do.
  780|    252|    return;
  781|    252|  }
  782|       |  // We will run the destructor logic, so move it out of line.
  783|       |  // The destructor of the unique_ptr runs ~Rep() and then ::operator delete.
  784|       |  // We don't want that bloat on the caller.
  785|      0|  Destroy(std::move(rep_));
  786|       |  // Tell the compiler that `rep_` was not filled again even if `this` escaped.
  787|      0|  AssumeEmpty();
  788|      0|}
_ZN4absl12lts_2026081713StatusBuilderC2ENS0_10StatusCodeENSt3__115source_locationE:
  765|    126|    : loc_(location), rep_(InitRep(absl::Status(code, ""))) {}
_ZNO4absl12lts_2026081713StatusBuilderlsIA31_cEEOS1_RKT_:
  921|    126|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|    126|  return std::move(operator<<(value));
  923|    126|}
_ZNR4absl12lts_2026081713StatusBuilderlsIA31_cEERS1_RKT_:
  911|    126|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|    126|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 126]
  ------------------
  913|    126|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 126, False: 0]
  ------------------
  914|    126|    rep_->InitStream();
  915|    126|  }
  916|    126|  *rep_->stream << value;
  917|    126|  return *this;
  918|    126|}
_ZN4absl12lts_2026081715status_internallsIA31_cEERNS1_6StreamES5_RKT_:
   60|    126|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|    126|    stream.absl_stringify_stream_ << t;
   62|    126|    return stream;
   63|    126|  }
_ZNO4absl12lts_2026081713StatusBuilderlsIA2_cEEOS1_RKT_:
  921|    126|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|    126|  return std::move(operator<<(value));
  923|    126|}
_ZNR4absl12lts_2026081713StatusBuilderlsIA2_cEERS1_RKT_:
  911|    126|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|    126|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 126]
  ------------------
  913|    126|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 126]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|    126|  *rep_->stream << value;
  917|    126|  return *this;
  918|    126|}
_ZN4absl12lts_2026081715status_internallsIA2_cEERNS1_6StreamES5_RKT_:
   60|    126|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|    126|    stream.absl_stringify_stream_ << t;
   62|    126|    return stream;
   63|    126|  }
_ZNO4absl12lts_2026081713StatusBuilderlsIiEEOS1_RKT_:
  921|    126|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|    126|  return std::move(operator<<(value));
  923|    126|}
_ZNR4absl12lts_2026081713StatusBuilderlsIiEERS1_RKT_:
  911|    126|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|    126|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 126]
  ------------------
  913|    126|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 126]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|    126|  *rep_->stream << value;
  917|    126|  return *this;
  918|    126|}
_ZN4absl12lts_2026081715status_internallsIiEERNS1_6StreamES4_RKT_:
   60|    126|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|    126|    stream.absl_stringify_stream_ << t;
   62|    126|    return stream;
   63|    126|  }
_ZNO4absl12lts_2026081713StatusBuilderlsIA4_cEEOS1_RKT_:
  921|    126|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|    126|  return std::move(operator<<(value));
  923|    126|}
_ZNR4absl12lts_2026081713StatusBuilderlsIA4_cEERS1_RKT_:
  911|    126|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|    126|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 126]
  ------------------
  913|    126|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 126]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|    126|  *rep_->stream << value;
  917|    126|  return *this;
  918|    126|}
_ZN4absl12lts_2026081715status_internallsIA4_cEERNS1_6StreamES5_RKT_:
   60|    126|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|    126|    stream.absl_stringify_stream_ << t;
   62|    126|    return stream;
   63|    126|  }
_ZNO4absl12lts_2026081713StatusBuilderlsIA3_cEEOS1_RKT_:
  921|    126|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|    126|  return std::move(operator<<(value));
  923|    126|}
_ZNR4absl12lts_2026081713StatusBuilderlsIA3_cEERS1_RKT_:
  911|    126|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|    126|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 126]
  ------------------
  913|    126|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 126]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|    126|  *rep_->stream << value;
  917|    126|  return *this;
  918|    126|}
_ZN4absl12lts_2026081715status_internallsIA3_cEERNS1_6StreamES5_RKT_:
   60|    126|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|    126|    stream.absl_stringify_stream_ << t;
   62|    126|    return stream;
   63|    126|  }
_ZNO4absl12lts_2026081713StatusBuilderlsIA7_cEEOS1_RKT_:
  921|    126|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|    126|  return std::move(operator<<(value));
  923|    126|}
_ZNR4absl12lts_2026081713StatusBuilderlsIA7_cEERS1_RKT_:
  911|    126|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|    126|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 126]
  ------------------
  913|    126|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 126]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|    126|  *rep_->stream << value;
  917|    126|  return *this;
  918|    126|}
_ZN4absl12lts_2026081715status_internallsIA7_cEERNS1_6StreamES5_RKT_:
   60|    126|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|    126|    stream.absl_stringify_stream_ << t;
   62|    126|    return stream;
   63|    126|  }
_ZNO4absl12lts_2026081713StatusBuilderlsIA26_cEEOS1_RKT_:
  921|    126|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|    126|  return std::move(operator<<(value));
  923|    126|}
_ZNR4absl12lts_2026081713StatusBuilderlsIA26_cEERS1_RKT_:
  911|    126|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|    126|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 126]
  ------------------
  913|    126|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 126]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|    126|  *rep_->stream << value;
  917|    126|  return *this;
  918|    126|}
_ZN4absl12lts_2026081715status_internallsIA26_cEERNS1_6StreamES5_RKT_:
   60|    126|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|    126|    stream.absl_stringify_stream_ << t;
   62|    126|    return stream;
   63|    126|  }

_ZN4absl12lts_2026081721status_macro_internal12MacroAdaptorEONS0_6StatusENSt3__115source_locationE:
  444|    126|                                         absl::SourceLocation loc) {
  445|    126|  return ReturnIfErrorAdaptor(std::move(s), loc);
  446|    126|}
_ZN4absl12lts_2026081721status_macro_internal20ReturnIfErrorAdaptorC2EONS0_6StatusENSt3__115source_locationE:
  404|    126|      : status_(std::move(status)), loc_(loc) {}
_ZNK4absl12lts_2026081721status_macro_internal20ReturnIfErrorAdaptorcvbEv:
  420|    126|  explicit operator bool() const { return ABSL_PREDICT_TRUE(status_.ok()); }
  ------------------
  |  |  191|    126|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:48): [Folded, False: 126]
  |  |  |  Branch (191:57): [True: 0, False: 126]
  |  |  ------------------
  ------------------
_ZN4absl12lts_2026081721status_macro_internal20ReturnIfErrorAdaptor7ConsumeEv:
  422|    126|  StatusBuilder Consume() { return StatusBuilder(std::move(status_), loc_); }
_ZN4absl12lts_2026081721status_macro_internal20ReturnIfErrorAdaptorD2Ev:
  406|    126|  ~ReturnIfErrorAdaptor() {
  407|       |    // WARNING! WARNING! WARNING!
  408|       |    //
  409|       |    // We play fast and loose here and avoid destroying status_. This should be
  410|       |    // safe because status_ will never own memory at destruction time. The two
  411|       |    // cases to consider are:
  412|       |    //  (1) OK: OkStatus() representation needs no cleanup
  413|       |    //  (2) Not-OK: we take the else branch in ABSL_RETURN_IF_ERROR and move
  414|       |    //      status_ into StatusBuilder which leaves status_ with a MovedFromRep
  415|       |    //      that needs no cleanup.
  416|       |    // If the absl::Status implementation changes, leaks should be caught by
  417|       |    // the various tests we have when run under lsan or debug leak checker.
  418|    126|  }

_ZN4absl12lts_2026081716strings_internallsIA31_cEERNS1_15StringifyStreamES5_RKT_:
   69|    126|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|    126|    if constexpr (HasStreamInsertion<T>::value) {
   71|    126|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|    126|    return stream;
   76|    126|  }
_ZN4absl12lts_2026081716strings_internallsIA2_cEERNS1_15StringifyStreamES5_RKT_:
   69|    126|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|    126|    if constexpr (HasStreamInsertion<T>::value) {
   71|    126|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|    126|    return stream;
   76|    126|  }
_ZN4absl12lts_2026081716strings_internallsIiEERNS1_15StringifyStreamES4_RKT_:
   69|    126|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|    126|    if constexpr (HasStreamInsertion<T>::value) {
   71|    126|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|    126|    return stream;
   76|    126|  }
_ZN4absl12lts_2026081716strings_internallsIA4_cEERNS1_15StringifyStreamES5_RKT_:
   69|    126|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|    126|    if constexpr (HasStreamInsertion<T>::value) {
   71|    126|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|    126|    return stream;
   76|    126|  }
_ZN4absl12lts_2026081716strings_internallsIA3_cEERNS1_15StringifyStreamES5_RKT_:
   69|    126|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|    126|    if constexpr (HasStreamInsertion<T>::value) {
   71|    126|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|    126|    return stream;
   76|    126|  }
_ZN4absl12lts_2026081716strings_internallsIA7_cEERNS1_15StringifyStreamES5_RKT_:
   69|    126|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|    126|    if constexpr (HasStreamInsertion<T>::value) {
   71|    126|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|    126|    return stream;
   76|    126|  }
_ZN4absl12lts_2026081716strings_internallsIA26_cEERNS1_15StringifyStreamES5_RKT_:
   69|    126|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|    126|    if constexpr (HasStreamInsertion<T>::value) {
   71|    126|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|    126|    return stream;
   76|    126|  }

_ZN4absl12lts_202608178Duration5HiRepC2El:
  267|    252|          lo_(0),
  268|    252|          hi_(0)
  269|       |#endif
  270|    252|    {
  271|    252|      *this = value;
  272|    252|    }
_ZN4absl12lts_202608178Duration5HiRepaSEl:
  294|    252|    constexpr HiRep& operator=(const int64_t value) {
  295|       |      // "If the destination type is unsigned, the resulting value is the
  296|       |      // smallest unsigned value equal to the source value modulo 2^n
  297|       |      // where `n` is the number of bits used to represent the destination
  298|       |      // type".
  299|    252|      const auto unsigned_value = static_cast<uint64_t>(value);
  300|    252|      hi_ = static_cast<uint32_t>(unsigned_value >> 32);
  301|    252|      lo_ = static_cast<uint32_t>(unsigned_value);
  302|    252|      return *this;
  303|    252|    }